【Kafka】Kafka生产者概述
文章目录
1. 生产者
1.1 生产者消息发送流程
1.1.1 发送原理
在消息发送过程中,涉及到了两个线程—— main 线程和 Sender 线程。在 main 线程 中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator, Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。
1.1.2 生产者重要参数列表
参数名称 | 描述 |
---|---|
bootstrap.servers | 生产者连接集群所需的 broker 地 址 清 单 。 例 如 node1:9092,node2:9092,node3:9092,可以 设置 1 个或者多个,中间用逗号隔开。注意这里并非需要所有的 broker 地址,因为生产者从给定的 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 之间。 |
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。 |
1.2 异步发送 API
1.2.1 普通异步发送
**需求:**创建 Kafka 生产者,采用异步的方式发送到 Kafka Broker
创建一个maven功能,导入如下依赖:
<dependency>
<groupId>org.apache.kafka</groupId>
<artifactId>kafka-clients</artifactId>
<version>3.0.0</version>
</dependency>
编写一个不带回调函数的API代码:
public class CustomProducer {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello,world" + i));
}
//3.关闭资源
kafkaProducer.close();
}
}
在node1节点中开启kafka消费者 bin/kafka-console-consumer.sh -- bootstrap-server node1:9092 --from-beginning --topic first
,控制台收到如下消息:
1.2.2 带回调函数的异步发送
回调函数会在 producer 收到 ack 时调用,为异步调用,该方法有两个参数,分别是元数据信息(RecordMetadata)和异常信息(Exception),如果 Exception 为 null,说明消息发送成功,如果 Exception 不为 null,说明消息发送失败。
注意:消息发送失败会自动重试,不需要我们在回调函数中手动重试
public class CustomProducerCallback {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello,world" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "\t分区" + recordMetadata.partition());
}
}
});
}
//3.关闭资源
kafkaProducer.close();
}
}
运行程序之后,node1节点收到消息,idea控制台输出如下消息:
1.3 同步发送 Api
只需在异步发送的基础之上,再调用一下 get() 方法即可。
public class CustomProducerSync {
public static void main(String[] args) throws ExecutionException, InterruptedException {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 5; i < 10; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello,world" + i)).get();
}
//3.关闭资源
kafkaProducer.close();
}
}
node1节点上的控制台输出:
2. 生产者分区
2.1 分区的好处
好处:
- 便于合理使用存储资源,每个 Partition 在一个 Broker 上存储,可以把海量的数据按照分区切割成一块一块的数据存储在多台 Broker 上。合理控制分区的任务,可以实现负载均衡的效果。
- 提高并行度,生产者可以以分区为单位发送数据;消费者可以以分区为单位进行消费数据。
2.2 分区策略
在Idea中找到 DefaultPartitioner
类,这里是默认分区策略的规则
我们在发送消息的时候需要创建一个 ProducerRecord
对象作为参数,在这个类中我们可以看到如下构造方法:
如上图所示:
- 前四个构造方法:指明partition的情况下,直接将指明的值作为partition的值。
- 例如:partition=0,所有数据写入分区0
- 第五个构造方法:没有指明partition值但是又key的情况下,将key的hash值与topic的partition数进行取余得到partition值。
- 例如:key1的hash值=5,key2的hash值=6,topic的partition数=2,那么key1对应的value1写入1号分区,key2对应的value2写入0号分区
- 第六个构造方法:既没有partition值又没有key值得情况下,Kafka采用
Sticky Partition
(黏性分区器),会随机选择一个分区,并尽可能一直使用该分区,待该分区得batch已满或者已完成,Kafka再随机选择一个分区使用(直至选到和上一次分区不同的为止)- 例如:第一次随机选择0号分区,等0号分区当前批次满了(默认16k)或者 linger.ms 设置的时间到了,Kafka再随机一个分区进行使用(如果还是0会继续随机)
代码示例:
①:向1号分区发送消息:
public class CustomProducerCallbackPartitions {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", 1, "", "hello,world" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "\t分区" + recordMetadata.partition());
}
}
});
}
//3.关闭资源
kafkaProducer.close();
}
}
②:没有指明分区数,但是指定了key。将 key 的 hash 值与 topic 的 partition 数进行取 余得到 partition 值。
public class CustomProducerCallbackPartitions {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "a", "hello,world" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "\t分区" + recordMetadata.partition());
}
}
});
}
//3.关闭资源
kafkaProducer.close();
}
}
2.3 自定义分区器
需求:实现一个分区器,使得发送过来的数据中如果包含atguigu,就发往0号分区,不包含atguigu,就发往1号分区。
实现步骤:
- 定义一个类实现
Partitioner
接口 - 重写
partition()
方法,自定义分区逻辑
public class MyPartitioner implements Partitioner {
/**
* 返回消息对应的分区
*
* @param topic 主题
* @param key 消息的key
* @param keyBytes 消息的key序列化后的字节数组
* @param value 消息的value
* @param valueBytes 消息的value序列化后的字节数组
* @param cluster 集群元数据可以查看分区信息
* @return
*/
@Override
public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
//获取数据 atguigu hello
String msgValues = value.toString();
int partition;
if (msgValues.contains("atguigu")) {
partition = 0;
} else {
partition = 1;
}
return partition;
}
@Override
public void close() {
}
@Override
public void configure(Map<String, ?> configs) {
}
}
- 使用分区器的方法,在生产者的配置中添加分区参数。
public class CustomProducerCallbackPartitions {
public static void main(String[] args) throws InterruptedException {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
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, "com.atguigu.kafka.producer.MyPartitioner");
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 0; i < 50; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "atguigu"), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "\t分区" + recordMetadata.partition());
}
}
});
TimeUnit.MILLISECONDS.sleep(20);
}
//3.关闭资源
kafkaProducer.close();
}
}
测试结果:所有 atguigu
消息都发往0号分区,其他的则发往1号分区。
3. 生产者提高吞吐量
生产者可以通过修改以下参数达到提高吞吐量的目的:
- batch.size:批次大小,默认16k
- linger.ms:等待时间,修改为5~100ms
- compression.type:压缩snappy
- RecordAccumulator:缓冲区大小,修改为64m
代码示例:
public class CustomProducerParameters {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//RecordAccumulator:缓存区大小,默认为32m
properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
//batch.size:批次大小,默认16k
properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
//linger.ms:等待时间,默认 0
properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
//compression.type:压缩,默认 none,可配置值 gzip、snappy、lz4 和 zstd
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello,world" + i), new Callback() {
@Override
public void onCompletion(RecordMetadata recordMetadata, Exception e) {
if (e == null) {
System.out.println("主题:" + recordMetadata.topic() + "\t分区" + recordMetadata.partition());
}
}
});
}
//3.关闭资源
kafkaProducer.close();
}
}
4. 生产数据可靠性
回顾kafka的发送流程,我们知道ack有三种应答级别(橙色表示数据还在内存,灰色表示数据已落盘):
- 0:生产者发送过来的数据,不需要等待数据落盘应该,立马就可以发下一条消息。
- 可靠性分析:当消息发到kafka集群时,Leader挂了,那么数据就丢失了。
-
1:生产者发送过来的数据,需要 Leader 收到数据后应答。
- 可靠性分析:消息落盘之后,但还没开始同步副本,Leader挂了,选举新的副本作为Leader,新的Leader不会受到Hello消息,因为生产者收到ack认为已经发送成功了。
-
-1(all):生产则发送过来的数据,需要 Leader 和 isr 队列里面所有节点收齐数据后应答,-1和all等价
问题:如果Leader收到数据,所有的Follower都开始同步数据,但是有一个Follower因为某种故障迟迟不能与Leader同步,那么会出现什么问题呢?
- Leader维护了一个动态的
in-sync replica set(ISR)
,意为和Leader保持同步的Follower+Leader集合(leader:0,isr:0,1,2) - 如果Follower长时间未向Leader发送通信请求或同步数据,则该Follower将被踢出ISR。该超时阈值由
replica.lag.time.max.ms
参数设定,默认30s。例如2超时,则(leader:0,isr:0,1),这样就不用等待长期联系不上或已经故障的节点。
数据可靠性分析:如果分区副本设置为1,即只有Leader,或者ISR里应答的最小副本数量(min.insync.replicas 默认为1)设置为1,那么此时ack=-1和ack=1的效果是一样的,仍然会有丢数的风险(leader:0,isr:0)。
数据重复分析:假设Leader和ISR队列种种那个所有节点收齐数据后,正要应答时Leader挂了,kafka选择一个Follower作为新的Leader,生产者重试,又向Leader发送了一条消息,所以此时kafka接收了两份相同的数据,导致了数据重复。
- Leader维护了一个动态的
数据完全可靠的条件=ACK级别设置为-1 + 分区副本>=2 + ISR里应答的最小副本数量>=2
总结:
- acks=0,生产者发送过来数据就不管了, 可靠性差,效率高。
- acks=1,生产者发送过来数据Leader应答,可靠性中等,效率中等。
- acks=-1,生产者发送过来数据Leader和ISR队列里面所有Follower应答,可靠性高,效率低。
- 在生产环境中,acks=0很少使用;acks=1一般用于传输普通日志,允许丢个别数据;acks=-1,一般用于传输和钱相关的数据,应用于对可靠性要求比较高的场景。
代码示例:
public class CustomProducerAcks {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
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, "1");
//重试次数
properties.put(ProducerConfig.RETRIES_CONFIG, 3);
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//2.发送数据
for (int i = 5; i < 10; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello,world" + i));
}
//3.关闭资源
kafkaProducer.close();
}
}
5. 生产数据去重
5.1 数据传递语义
- 至少一次(At Least Once)= ACK级别设置为-1 + 分区副本>=2 + ISR里应答的最小副本数量>=2。表示kafka集群至少收到1次消息。
- At Least Once 可以保证数据不丢失,但是不能保证数据不重复。
- 最多一次(At Most Once)=ACK级别设置为0
- At Most Once 可以保证数据不重复,但是不能保证数据不丢失。
- 精确一次(Exactly Once):对于一些非常重要的信息,比如和钱相关的数据,要求数据既不能重复也不能丢失。Kafka 0.11版本以后,引入了一项重大特性:幂等性和事务。
5.2 幂等性
幂等性就是指Producer不论向Broker发送多少次重复数据,Broker端都只会持久化一条,保证了不重复。
精确一次(Exactly Once)=幂等性 + 至少一次(ACK级别设置为-1 + 分区副本>=2 + ISR里应答的最小副本数量>=2)
重复数据的判断标准:具有相同主键的消息提交时,Broker只会持久化一条。其中PID是Kafka每次重启都会分配一个新的;Partition 表示分区号;Sequence Number是单调自增的。所以幂等性只能保证的是在单分区单会话内不重复。
如何使用幂等性?
只需开启参数
enable.idempotence
默认为true,false关闭
5.3 生产者事务
注意:使用事务,必须先开启幂等性
Kafka事务相关API一共有如下5个:
// 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;
示例代码:
public class CustomProducerTranactions {
public static void main(String[] args) {
//0.配置
Properties properties = new Properties();
//连接集群 bootstrap.server
properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.101.66:9092,192.168.101.67:9092,192.168.101.68:9092");
//指定对应的 key 和 value 的序列化类型(key.serializer,)
//properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
//指定事务id
properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "tranactional_id_01");
//1.创建kafka生产者对象
KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);
//初始化事务
kafkaProducer.initTransactions();
//开启事务
kafkaProducer.beginTransaction();
try {
//2.发送数据
for (int i = 0; i < 5; i++) {
kafkaProducer.send(new ProducerRecord<>("first", "hello,world" + i));
}
//int i = 1 / 0;
} catch (Exception e) {
kafkaProducer.abortTransaction();
} finally {
//3.关闭资源
kafkaProducer.close();
}
}
}
6. 数据有序
消息在单分区的某种条件下是有序的,而在多分区时,分区与分区之间是无序的。
7. 数据乱序
假设生产者往kafka中投递4条消息,序号分别为1,2,3,4.前两条正常投递,第三条投递失败,进行重试。第四条投递成功。那么到达kafka的顺序就变成了1,2,4,3.这样就造成了数据的乱序。
- kafka在1.x版本之前保证数据单分区有序,条件如下:
max.in.flight.requests.per.connection
= 1 (不需要考虑是否开启幂等性)
- 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的数据都是有序的。
- 未开启幂等性