一、生产者消息发送流程
1、发送原理
Kafka的Producer发送消息采用的是异步发送的方式。
在消息发送的过程中,涉及到了两个线程:main线程和Sender线程,以及一个线程共享变量:RecordAccumulator。
- ①main线程中创建了一个双端队列RecordAccumulator,将消息发送给RecordAccumulator。
- ②Sender线程不断从RecordAccumulator中拉取消息发送到Kafka broker。
2、生产者重要参数列表
描述 | |||
bootstrap.servers | 生产者连接集群所需的broker地址清单。可以设置1个或者多个,中间用逗号隔开。生产者从给定的broker里查找到其他broker信息。 | ||
key.serializer、 value.serializer | 指定发送消息的key和value的序列化类型。要写全类名。(反射获取) | ||
buffer.memory | RecordAccumulator缓冲区总大小,默认32m。 | ||
batch.size | 缓冲区一批数据最大值,默认16k。适当增加该值,可以提高吞吐量,但是如果该值设置太大,会导致数据传输延迟增加。 | ||
linger.ms | 如果数据迟迟未达到batch.size,sender等待linger.time之后就会发送数据。单位ms,默认值是0ms,表示没有延迟。生产环境建议该值大小为5-100ms之间。 | ||
0:生产者发送过来的数据,不需要等数据落盘应答。 1:生产者发送过来的数据,Leader数据落盘后应答。 -1(all):生产者发送过来的数据,Leader和isr队列里面的所有节点数据都落盘后应答。默认值是-1 | |||
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。 | ||
是否开启幂等性,默认true,开启幂等性。 | |||
compression.type | 生产者发送的所有数据的压缩方式。默认是none,不压缩。 支持压缩类型:none、gzip、snappy、lz4和zstd。 |
二、异步发送API
1、普通异步发送
1.1 需求
创建Kafka生产者,采用异步的方式发送到Kafka broker
1.2 异步发送流程
失败后重试的次数是int的最大值;
1.3 代码编写
1)创建工程kafka-demo
2)导入依赖
<!-- https://mvnrepository.com/artifact/org.apache.kafka/kafka-clients -->
<dependencies>
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.0.0</version>
</dependency>
</dependencies>
3)创建包名:com.wyr.kafka.producer
4)编写代码:不带回调函数的API
package com.atguigu.kafka.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;
public class CustomProducer {
public static void main(String[] args) throws InterruptedException {
// 1. 创建kafka生产者的配置对象
Properties properties = new Properties();
// 2. 给kafka配置对象添加配置信息
properties.put("bootstrap.servers","hadoop102:9092");
// key,value序列化
properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
// 3. 创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
// 4. 调用send方法,发送消息
for (int i = 0; i < 10; i++) {
kafkaProducer.send(new ProducerRecord<>("first","kafka" + i));
}
// 5. 关闭资源
kafkaProducer.close();
}
}
5)测试:
在hadoop102上开启kafka消费者
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
在IDEA中执行上述代码,观察hadoop102消费者输出
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
kafka0
kafka1
kafka2
kafka3
……
2、带回调函数的异步发送
2.1 回调函数callback()
回调函数callback()会在producer收到ack时调用,为异步调用。
该方法有两个参数分别是RecordMetadata(元数据信息)和Exception(异常信息)。
- 如果Exception为null,说明消息发送成功,
- 如果Exception不为null,说明消息发送失败。
2.2 带回调函数的异步调用发送流程
注意:消息发送失败会自动重试,不需要我们在回调函数中手动重试。
2.3 编写代码:带回调函数的生产者
package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
public class CustomProducerCallback {
public static void main(String[] args) throws InterruptedException {
// 1. 创建kafka生产者的配置对象
Properties properties = new Properties();
// 2. 给kafka配置对象添加配置信息
properties.put("bootstrap.servers", "hadoop102:9092");
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "hadoop102:9092");
// key,value序列化(必须)
properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
// 3. 创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
// 4. 调用send方法,发送消息
for (int i = 0; i < 10; i++) {
// 添加回调
kafkaProducer.send(new ProducerRecord<>("first", "kafka" + i), new Callback() {
// 该方法在Producer收到ack时调用,为异步调用
@Override
public void onCompletion(RecordMetadata metadata, Exception exception) {
if (exception == null)
// 没有异常,输出信息到控制台
System.out.println("主题"+recordMetadata.topic() +", 分区:"+recordMetadata.partition()+", 偏移量:"+recordMetadata.offset());
}
});
}
// 5. 关闭资源
kafkaProducer.close();
}
}
2.4 测试
1)在hadoop102上开启kafka消费者
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
2)在IDEA中执行代码,观察hadoop102消费者输出
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
kafka0
kafka1
kafka2
……
3)在IDEA控制台观察回调信息
主题first, 分区:0, 偏移量:10
主题first, 分区:0, 偏移量:11
主题first, 分区:0, 偏移量:12
主题first, 分区:0, 偏移量:13
主题first, 分区:0, 偏移量:14
主题first, 分区:0, 偏移量:15
主题first, 分区:0, 偏移量:16
主题first, 分区:0, 偏移量:17
主题first, 分区:0, 偏移量:18
主题first, 分区:0, 偏移量:19
……
三、同步发送API(实际项目中几乎不用)
1、同步发送的意思
同步发送的意思就是,一条消息发送之后,会阻塞当前线程,直至返回ack。
由于send方法返回的是一个Future对象,根据Futrue对象的特点,我们也可以实现同步发送的效果,只需在调用Future对象的get方发即可。
2、同步发送流程示意图
3、编写代码
同步发送消息的生产者
package com.atguigu.kafka.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;
import java.util.concurrent.ExecutionException;
public class ConsumerProducerSync {
public static void main(String[] args) throws InterruptedException, ExecutionException {
// 1. 创建kafka生产者的配置对象
Properties properties = new Properties();
// 2. 给kafka配置对象添加配置信息
//properties.put("bootstrap.servers","hadoop102:9092");
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092");
// key,value序列化(必须)
properties.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
properties.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");
// 3. 创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
// 4. 调用send方法,发送消息
for (int i = 0; i < 10; i++) {
// 同步发送
kafkaProducer.send(new ProducerRecord<>("first","kafka" + i)).get();
}
// 5. 关闭资源
kafkaProducer.close();
}
}
4. 测试
1)在hadoop102上开启kafka消费者
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
2)在IDEA中执行代码,观察hadoop102消费者的消费情况
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
kafka0
kafka1
kafka2
……
四、生产者分区
1、分区的原因
2、生产者分区策略
1.默认分区器DefaultPartitioner
The default partitioning strategy:
·If a partition is specified in the record, use it
·If no partition is specified but a key is present choose a partition based on a hash of the key
·If no partition or key is present choose the sticky partition that changes when the batch is full.
public class DefaultPartitioner implements Partitioner {
… …
}
2.使用:
1) 我们需要将producer发送的数据封装成一个ProducerRecord对象。
2) 上述的分区策略,我们在ProducerRecord对象中进行配置。
3)策略实现:
代码 | 解释 | |
ProducerRecord(topic,partition_num,……) | 指明partition的情况下直接发往指定的分区,key的分配方式将无效 | |
ProducerRecord(topic,key,value) | 没有指明partition值但有key的情况下: 将key的hash值与topic的partition个数进行取余得到分区号; | |
ProducerRecord(topic,value) | 既没有 partition 值又没有 key 值的情况下: kafka采用Sticky Partition(黏性分区器),会随机选择一个分区,并尽可能一直使用该分区,待该分区的batch已满或者已完成,kafka再随机一个分区(绝对不会是上一个)进行使用. | |
3. 案例实操:
1)案例1:将数据发送到指定partition的情况下,如:将所有消息发送到分区1中。
package com.wyr.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
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");
// key,value序列化(必须):
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
// 3. 创建生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
// 4. 造数据
for (int i = 0; i < 5; i++) {
// 指定数据发送到1号分区,key为空(IDEA中ctrl + p查看参数)
kafkaProducer.send(new ProducerRecord<>("first", 1,"","wyr " + i), new Callback() {
@Override
public void onCompletion(RecordMetadata metadata, Exception e) {
if (e == null){
System.out.println("主题:" + metadata.topic() + "->" + "分区:" + metadata.partition()
);
}else {
e.printStackTrace();
}
}
});
}
kafkaProducer.close();
}
}
2)测试:
① 在hadoop102上开启kafka消费者
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
② 在IDEA中执行代码,观察hadoop102上的消费者消费情况
[wyr@hadoop104 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
wyr0
wyr1
kafka2
……
③ 观察IDEA中控制台输出
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
主题:first->分区:1
3)案例2:没有指明partition但是有key的情况下的消费者分区分配
package com.wyr.kafka.producer;
import org.apache.kafka.clients.producer.*;
import java.util.Properties;
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");
// key,value序列化(必须):
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
// 3. 创建生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
// 4. 造数据
for (int i = 0; i < 5; i++) {
// 指定数据发送到1号分区,key为空(IDEA中ctrl + p查看参数)
kafkaProducer.send(new ProducerRecord<>("first", 1,"","wyr " + i), new Callback() {
@Override
public void onCompletion(RecordMetadata metadata, Exception e) {
if (e == null){
System.out.println("主题:" + metadata.topic() + "->" + "分区:" + metadata.partition()
);
}else {
e.printStackTrace();
}
}
});
}
kafkaProducer.close();
}
}
4)测试
观察IDEA中控制台输出
消息:wyr 1, 主题:first->分区:0
消息:wyr 5, 主题:first->分区:0
消息:wyr 7, 主题:first->分区:0
消息:wyr 8, 主题:first->分区:0
消息:wyr 2, 主题:first->分区:2
消息:wyr 3, 主题:first->分区:2
消息:wyr 9, 主题:first->分区:2
消息:wyr 4, 主题:first->分区:1
消息:wyr 6, 主题:first->分区:1
消息:wyr 10, 主题:first->分区:1
3、自定义分区器
1. 生产环境中,我们往往需要更加自由的分区需求,我们可以自定义分区器。
2. 需求:在上面的根据key分区案例中,我们发现与我们知道的hash分区结果不同。那么我们就实现一个。
3.实现步骤:
① 定义类,实现Partitioner接口
② 重写partition()方法
4. 代码实现:
package com.wyr.kafka.partitioner;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import java.util.Map;
/**
* @author leon
* @create 2020-12-11 10:43
* 1. 实现接口Partitioner
* 2. 实现3个方法:partition,close,configure
* 3. 编写partition方法,返回分区号
*/
public class MyPartitioner implements Partitioner {
/**
* 分区方法
**/
@Override
public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
// 1. 获取key
String keyStr = key.toString();
// 2. 创建分区号,返回的结果
int partNum;
// 3. 计算key的hash值
int keyStrHash = keyStr.hashCode();
// 4. 获取topic的分区个数
int partitionNumber = cluster.partitionCountForTopic(topic);
// 5. 计算分区号
partNum = Math.abs(keyStrHash) % partitionNumber;
// 4. 返回分区号
return partNum;
}
// 关闭资源
@Override
public void close() {
}
// 配置方法
@Override
public void configure(Map<String, ?> configs) {
}
}
5. 测试
在生产者代码中,通过配置对象,添加自定义分区器
// 添加自定义分区器
properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG," com.wyr.kafka.partitioner.MyPartitioner ");
在hadoop102上启动kafka消费者
[wyr@hadoop102 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
在IDEA中观察回调信息
消息:wyr 2, 主题:first->分区:2
消息:wyr 5, 主题:first->分区:2
消息:wyr 8, 主题:first->分区:2
消息:wyr 1, 主题:first->分区:1
消息:wyr 4, 主题:first->分区:1
消息:wyr 7, 主题:first->分区:1
消息:wyr 10, 主题:first->分区:1
消息:wyr 3, 主题:first->分区:0
消息:wyr 6, 主题:first->分区:0
消息:wyr 9, 主题:first->分区:0
五、生产经验——生产者如何提高吞吐量
1、吞吐量
2、案例实操
2.1 编写代码
package com.wyr.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
public class CustomProducerParameters {
public static void main(String[] args) throws InterruptedException {
// 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");
// batch.size:批次大小,默认16K
properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
// linger.ms:等待时间,默认0
properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
// RecordAccumulator:缓冲区大小,默认32M:buffer.memory
properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
// compression.type:压缩,默认none,可配置值gzip、snappy、lz4和zstd
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");
// 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","wyr" + i));
}
// 5. 关闭资源
kafkaProducer.close();
}
}
2.2 测试
① 在hadoop102上开启kafka消费者
[wyr@hadoop102 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
② 在IDEA中执行代码,观察hadoop102上的消费者消费情况
[wyr@hadoop102 kafka]$ sbin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first
wyr0
wyr0
wyr0
……
六、生产经验——数据可靠性
1、回顾消费发送流程
2、ack应答机制
3、ack应答级别
背景: | leader收到数据,所有follower都开始同步数据,但有一个follower,因为某种故障,迟迟不能与leader进行同步,那leader就要一直等下去,直到它完成同步,才能发送ack。这个问题怎么解决呢? | |
Kafka提供的解决方案:ISR队列 | ①Leader维护了一个动态的in-sync replica set (ISR)和leader保持同步的follower集合。 ②当ISR中的follower完成数据的同步之后,leader就会给producer发送ack。 ③如果follower长时间(replica.lag.time.max.ms)未向leader同步数据,则该follower将被踢出ISR。 Leader发生故障之后,就会从ISR中选举新的leader。 | |
ack应答级别
对于某些不太重要的数据,对数据的可靠性要求不是很高,能够容忍数据的少量丢失,所以没必要等ISR中的follower全部接收成功。
所以Kafka为用户提供了三种可靠性级别,用户根据对可靠性和延迟的要求进行权衡,选择以下的配置。
acks=0 | 这一操作提供了一个最低的延迟,partition的leader副本接收到消息还没有写入磁盘就已经返回ack,当leader故障时有可能丢失数据; |
acks=1 | partition的leader副本落盘后返回ack,如果在follower副本同步数据之前leader故障,那么将会丢失数据; |
acks-1 (all) | partition的leader和follower副本全部落盘成功后才返回ack。但是如果在follower副本同步完成后,leader副本所在节点发送ack之前,leader副本发生故障,那么会造成数据重复。 |
4、ack应答机制总结
5、案例实操
代码编写
package com.wyr.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
public class CustomProducerAck {
public static void main(String[] args) throws InterruptedException {
// 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, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
// 设置acks
properties.put(ProducerConfig.ACKS_CONFIG, "all");
// 重试次数retries,默认是int最大值,2147483647
properties.put(ProducerConfig.RETRIES_CONFIG, 3);
// 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","wyr " + i));
}
// 5. 关闭资源
kafkaProducer.close();
}
}
七、生产经验——数据去重
1、数据传递语义
2、幂等性
2.1 幂等性原理
2.2 开启幂等性
在prudocer的配置对象中,添加参数enable.idempotence,参数值默认为true,设置为false就关闭了。
3、生产者事务
3.1 kafka事务原理
3.2 事务代码流程
// 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;
八、生产经验——数据有序
九、生产经验——数据乱序
参考资料:
尚硅谷大数据技术之Kafka-3.0.0-授课.docx