在消息发生的过程中,设计到了两个线程——main线程和Sender线程。在main线程中创建了一个双端队列线程将消息发给RecordAccumulator,Sender线程不断从RecordAccumulator中拉取消息发送到Kafka Broker。
生产者重要参数说明
bootstrap.servers
#生产者连接集群所需的Broker地址清单。例如hadoop102:9092,hadoop103:9092,hadoop104:9092,可以设置1个或多个,中间用逗号隔开。注意这里并非需要所有broker地址,因为生产者从给定的broker里查到其他broker信息
key.serializer和value.serializer
#指定发生信息的key和value的序列化类型。一定要写全类名
buffer.memory
#RecordAccumulator缓冲区总大小,默认32MB
batch.size
#缓冲区一批数据最大值,默认16K。适当增加该值,可以提高吞吐量,但是如果该值设置太大,会导致数据传输延迟增加
linger.ms
#如果数据迟迟未到batch.size,sender等待linger.time之后就会发送数据。单位ms,默认值是0ms,表示没有延迟。生产环境建议该值大小5-100ms之间
acks
#0:生产者发生过来的数据,不需要等数据落盘应答。1: 生产者发送过来的数据,Leader收到数据后应答。-1(all):生产者发给过来的数据,Leader和isr队列里面的所有节点收齐数据后应答。默认值是-1,-1和all是等价的
max.in.flight.requests.per.connection
#允许最多没有返回ack的次数,默认为5,开启幂等性包保证该值是1-5的数字
retries
#当消息发给出现错误的时候,系统会重发消息。retries表示重试的次数。默认是int的最大值,2147483647.如果设置了重试,还想抱着消息的有序性,需要设置MAX\_IN\_FLIGHT\_REQUESTS_PER_CONNECTION=1否则在重试此失败消息的时候,其他的消息可能发送成功了
retry.backoff.ms
#两次重试之间的时间间隔,默认是 100ms。
enable.idempotence
#是否开启幂等性,默认 true,开启幂等性。
compression.type
#生产者发送的所有数据的压缩方式。默认是 none,也就是不压缩。支持压缩类型:none、gzip、snappy、lz4 和 zstd。
<dependencies>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
package org.zhm.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
/**
* @ClassName CustomProducer
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 18:35
* @Version 1.0
*/
public class CustomProducer {
public static void main(String[] args) {
//1、创建kafka生产者的配置对象
Properties properties=new Properties();
//2、给kafka配置对象添加配置信息:bootstrap.servers
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
//key,value序列化(必须):key.serializer,value.serializer
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringSerializer");
//3、创建kafka生产者对象
KafkaProducer<String,String> kafkaProducer=new KafkaProducer<String, String>(properties);
//4、调用send()方法,发生消息
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first","zhm"+i));
}
//5、关闭资源
kafkaProducer.close();
}
}
(5)测试 ①在 hadoop102 上开启 Kafka 消费者。
bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
②在 IDEA 中执行代码,观察 hadoop102 控制台中是否接收到消息。
回调函数会在Producer收到ack时调用,为异步调用和异常信息·(Exception),如果Exception为null,说明消息发生成功,如果Exception不为null,说明消息发送失败。
注意:消息发送失败会自动重试,不需要我们在回调函数中手动重试。
package org.zhm.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
* @ClassName CustoProducerCallback
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 18:44
* @Version 1.0
*/
public class CustoProducerCallback {
public static void main(String[] args) throws InterruptedException {
//1、创建kafka生产者的配置对象
Properties properties=new Properties();
//2、给kafka配置对象添加配置信息
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
//key、value序列化(必须)
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//3、创建kafka生产者对象
KafkaProducer<String,String> producer=new KafkaProducer<>(properties);
//4、调用send()方法 发送信息
for (int i = 0; i < 6; i++) {
//添加回调
producer.send(new ProducerRecord<>("first", "zhm" + i), new Callback() {
//该方法在Producer收到ack时调用,为异步调用
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
//没有异常,输出信息到控制台
System.out.println("主题:"+recordMetadata.topic()+"->"+"分区:"
+recordMetadata.partition());
}
else {
//出现异常打印
e.printStackTrace();
}
}
});
//延迟一会会看到数据发往不同分区
Thread.sleep(20);
}
//5、关闭资源
producer.close();
}
}
①在 hadoop102 上开启 Kafka 消费者。
bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
②在 IDEA 中执行代码,观察 hadoop102 控制台中是否接收到消息。
同步发送API
只需在异步发送的基础上,再调用一下 get()方法即可。
package org.zhm.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
/**
* @ClassName CustomProducerSync
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 18:58
* @Version 1.0
*/
public class CustomProducerSync {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//1、创建kafka生产者的配置对象
Properties properties=new Properties();
//2、给kafka配置对象添加配置信息
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
//key、value序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//3、创建kafka生产者对象
KafkaProducer<String,String> producer=new KafkaProducer<>(properties);
//4、调用send方法,发送信息
for (int i = 0; i < 10; i++) {
//异步发送 默认
// producer.send(new ProducerRecord<>("first","zhm"+i));
//同步发送
producer.send(new ProducerRecord<>("first","zhmzhm"+i)).get();
}
//5、关闭资源
producer.close();
}
}
①在 hadoop102 上开启 Kafka 消费者。
bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
②在 IDEA 中执行代码,观察 hadoop102 控制台中是否接收到消息。
1、便于合理使用储存资源,每个Partition在一个Broker上储存,可以把海量的数据按照分区切割成一块一块数据储存在多台Broker上。合理控制分区的任务,可以实现负载均衡的效果。 2、提高并行度,生产者可以以分区为单位发送数据;消费者可以以分区为单位进行消费数据。
案例一
将数据发往指定 partition 的情况
package org.zhm.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
* @ClassName CustomProducerCallbackPartitions
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 19:10
* @Version 1.0
*/
public class CustomProducerCallbackPartitions {
public static void main(String[] args) {
//1、创建kafka生产者的配置对象
Properties properties=new Properties();
//2、给kafka配置对象添加配置信息
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
//键值序列化
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//3、创建生产者对象
KafkaProducer<String ,String> producer=new KafkaProducer<String, String>(properties);
//4、调用send方法,发送信息
for (int i = 0; i < 5; i++) {
//指定数据发送到1号分区,key1为空
producer.send(new ProducerRecord<>("first", 1, "", "zhm" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
System.out.println("主题:"+recordMetadata.topic()+"->"+"分区:"+recordMetadata.partition());
}else {
e.printStackTrace();
}
}
});
}
//5、关闭资源
producer.close();
}
}
①在 hadoop102 上开启 Kafka 消费者。
bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
②在 IDEA 中执行代码,观察 hadoop102 控制台中是否接收到消息。
没有指明 partition 值但有 key 的情况下,将 key 的 hash 值与 topic 的 partition 数进行取余得到 partition 值。
package org.zhm.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
* @ClassName CustomProducerCallback1
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 19:21
* @Version 1.0
*/
public class CustomProducerCallback1 {
public static void main(String[] args) {
Properties properties=new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
KafkaProducer<String,String> kafkaProducer=new KafkaProducer(properties);
for (int i = 0; i < 5; i++) {
//依次指定key值为a、b、f,数据key的hash值与3分别发往1、2、0
kafkaProducer.send(new ProducerRecord<>("first", "a", "zhm" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
System.out.println("当key为a时:"+"主题:"+recordMetadata.topic()+"分区:"+recordMetadata.partition());
}else {
e.printStackTrace();
}
}
});
}
for (int i = 0; i < 5; i++) {
//依次指定key值为a、b、f,数据key的hash值与3分别发往1、2、0
kafkaProducer.send(new ProducerRecord<>("first", "b", "zhm" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
System.out.println("当key为b时:"+"主题:"+recordMetadata.topic()+"分区:"+recordMetadata.partition());
}else {
e.printStackTrace();
}
}
});
}
for (int i = 0; i < 5; i++) {
//依次指定key值为a、b、f,数据key的hash值与3分别发往1、2、0
kafkaProducer.send(new ProducerRecord<>("first", "f", "zhm" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
System.out.println("当key为f时:"+"主题:"+recordMetadata.topic()+"分区:"+recordMetadata.partition());
}else {
e.printStackTrace();
}
}
});
}
kafkaProducer.close();
}
}
测试
①在 hadoop102 上开启 Kafka 消费者。
bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
②在 IDEA 中执行代码,观察 hadoop102 控制台中是否接收到消息。
如果研发人员可以根据企业需求,自己重新实现分区器
package org.zhm.producer;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import java.util.Map;
/**
* @ClassName Mypartitioner
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 19:28
* @Version 1.0
*/
/**
1、实现接口Partitioner
2、实现三个方法:Partition、close、configure
3、编写Partition方法,返回分区号
*/
public class MyPartitioner implements Partitioner {
/*
*
* @description:返回信息对应的分区
* @author: zouhuiming
* @date: 2023/6/12 19:30
* @param: [s, o, bytes, o1, bytes1, cluster]
* [主题、消息的key、消息的key序列化后的字节数组、消息的value、消息的value序列哈后字节数组、集群元数据可以查看的分区信息]
* @return: int
**/
@Override
public int partition(String s, Object o, byte[] bytes, Object o1, byte[] bytes1, Cluster cluster) {
//获取信息
String msyValue = o1.toString();
//创建partition
int partition;
//判断信息是否包含zhm
if (msyValue.contains("zhm")){
partition=0;
}
else {
partition=1;
}
//返回分区号
return partition;
}
@Override
public void close() {
}
@Override
public void configure(Map<String, ?> map) {
}
}
package org.zhm.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
/**
* @ClassName CustomProducerCallbackPartitionsMine
* @Description TODO
* @Author Zouhuiming
* @Date 2023/6/12 19:35
* @Version 1.0
*/
public class CustomProducerCallbackPartitionsMine {
public static void main(String[] args) {
Properties properties=new Properties();
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,StringSerializer.class.getName());
//添加自定义分区器
properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"org.zhm.producer.MyPartitioner");
KafkaProducer<String,String> kafkaProducer=new KafkaProducer<String, String>(properties);
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "zhm" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
System.out.println("主题:"+recordMetadata.topic()+"分区:"+recordMetadata.partition());
}else {
e.printStackTrace();
}
}
});
}
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e==null){
System.out.println("主题:"+recordMetadata.topic()+"分区:"+recordMetadata.partition());
}else {
e.printStackTrace();
}
}
});
}
kafkaProducer.close();
}
}
bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
②在 IDEA 控制台观察回调信息。
生产经验
数据重复分析
重复数据的判断标准:具有<PID,Partition,SeqNumber>相同主键的消息提交时,Broker只会持久化一条。其中PID是Kafka每次重启都会分配一个新的;Partition表示分区号;Sequence Number是单调自增的。
所以幂等性只能保证的是在单分区单会话内不重复。
开启参数 enable.idempotence 默认为 true,false 关闭
注意:开启事务,必须开启幂等性
// 1 初始化事务
void initTransactions();
// 2 开启事务
void beginTransaction() throws ProducerFencedException;
// 3 在事务内提交已经消费的偏移量(主要用于消费者)
void sendOffsetsToTransaction(Map<TopicPartition, OffsetAndMetadata> offsets,
String consumerGroupId) throws
ProducerFencedException;
// 4 提交事务
void commitTransaction() throws ProducerFencedException;
// 5 放弃事务(类似于回滚事务的操作)
void abortTransaction() throws ProducerFencedException;
1、kafka在1.x版本之前保证数据单分区有序,条件如下:
max.in.flight.requests.per.connection=1(不需要考虑是否开启幂等性)。
2、kafka在1.x及以后版本保证数据单分区有序,条件如下:
max.in.flight.requests.per.connection需要设置为1。
max.in.flight.requests.per.connection需要设置小于等于5。
原因说明:因为在kafka1.x以后,启用幂等后,kafka服务端会缓存producer发来的最近5个request的元数据,故无论如何,都可以保证最近5个request的数据都是有序的。
参考文章:https://blog.csdn.net/qq_44804713/article /details/131181542