Kafka快速入门(生产者)同步异步发送、分区、消息精确一次发送、幂等性、事务

本文涉及的产品
容器服务 Serverless 版 ACK Serverless,317元额度 多规格
容器服务 Serverless 版 ACK Serverless,952元额度 多规格
简介: Kafka快速入门(生产者)同步异步发送、分区、消息精确一次发送、幂等性、事务

1. 生产者消息发送流程


1.1 发送原理


在消息发送的过程中,涉及到了两个线程——main 线程和 Sender 线程。在 main 线程中创建了一个双端队列 RecordAccumulator。main 线程将消息发送给 RecordAccumulator,Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka Broker。

1673360881594.jpg


1.2 生产者重要参数列表

-参数名称 -描述
bootstrap.servers 生产者连接集群所需的broker地址清单。例如hadoop102:9092,hadoop103:9092,hadoop104:9092,可以设置1个或者多个,中间用逗号隔开。注意这里并
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。


2.异步发送 API


2.1 普通异步发送


1)需求:创建 Kafka 生产者,采用异步的方式发送到 Kafka Broker


异步发送流程

1673361086583.jpg

2)代码编写


(1)创建工程 kafka


(2)导入依赖

<dependencies>
  <dependency>
     <groupId>org.apache.kafka</groupId>
     <artifactId>kafka-clients</artifactId>
     <version>3.0.0</version>
  </dependency>
</dependencies>


(3)创建包名:com.atguigu.kafka.producer


(4)编写不带回调函数的 API 代码

package com.atguigu.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
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 配置对象添加配置信息: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","yy " + i));
         }
         // 5. 关闭资源
         kafkaProducer.close();
  }
}

测试:


①在 hadoop102 上开启 Kafka 消费者。

bin/kafka-console-consumer.sh --bootstrap-server hadoop102:9092 --topic first

②在 IDEA 中执行代码,观察 hadoop102 控制台中是否接收到消息。


2.2 带回调函数的异步发送


回调函数会在 producer 收到 ack 时调用,为异步调用,该方法有两个参数,分别是元数据信息(RecordMetadata)和异常信息(Exception),如果 Exception 为 null,说明消息发送成功,如果 Exception 不为 null,说明消息发送失败。


注意:消息发送失败会自动重试,不需要我们在回调函数中手动重试。

// 1. 创建 kafka 生产者的配置对象
 Properties properties = new Properties();
 // 2. 给 kafka 配置对象添加配置信息
 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());
 // 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", "atguigu " + i), new Callback() {
             // 该方法在 Producer 收到 ack 时调用,为异步调用
         @Override
         public void onCompletion(RecordMetadata metadata, 
            Exception exception) {
             if (exception == null) {
               // 没有异常,输出信息到控制台
               System.out.println(" 主题: " + 
               metadata.topic() + "->" + "分区:" + metadata.partition());
             } else {
               //  出现异常打印
               exception.printStackTrace();
              }
            }
         });
     //  延迟一会会看到数据发往不同分区
     Thread.sleep(2);
 }
 // 5. 关闭资源
 kafkaProducer.close();


3. 同步发送API


只需在异步发送的基础上,再调用一下 get()方法即可。

// 同步发送
 kafkaProducer.send(new ProducerRecord<>("first","kafka" + i)).get();


4. 生产者分区


4.1 分区好处


(1)便于合理使用存储资源,每个Partition在一个Broker上存储,可以把海量的数据按照分区切割成一


块一块数据存储在多台Broker上。合理控制分区的任务,可以实现负载均衡的效果。


(2)提高并行度,生产者可以以分区为单位发送数据;消费者可以以分区为单位进行消费数据。

1673361234141.jpg

4.2 生产者发送消息的分区策略


1)默认的分区器 DefaultPartitioner


在 IDEA 中 ctrl +n,全局查找 DefaultPartitioner。

1673361247191.jpg

4.3 自定义分区器


1)需求


例如我们实现一个分区器实现,发送过来的数据中如果包含 xxx,就发往 0 号分区,


不包含 xxx,就发往 1 号分区。


2)实现步骤


(1)定义类实现 Partitioner 接口。


(2)重写 partition()方法。

/**
* 1. 实现接口 Partitioner
* 2. 实现 3 个方法:partition,close,configure
* 3. 编写 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) {
    // 获取消息
     String msgValue = value.toString();
     // 创建 partition
     int partition;
     // 判断消息是否包含 atguigu
     if (msgValue.contains("xxx")){
      partition = 0;
     }else {
       partition = 1;
     }
     // 返回分区号
     return partition;
 }
 // 关闭资源
 @Override
 public void close() {
 }
 // 配置方法
 @Override
 public void configure(Map<String, ?> configs) {
 } 
}

(3)使用分区器的方法,在生产者的配置中添加分区器参数。


// 添加自定义分区器
properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.yy.kafka.producer.MyPartitioner");


5. 生产者如何提高吞吐量


1673361295788.jpg

// 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");


6. 数据可靠性


1)ack 应答原理

1673361320724.jpg

1673361331941.jpg

1673361342337.jpg

 // 设置 acks
 properties.put(ProducerConfig.ACKS_CONFIG, "all");
 // 重试次数 retries,默认是 int 最大值,2147483647
 properties.put(ProducerConfig.RETRIES_CONFIG, 3);


7. 数据去重


7.1 数据传递语义


1673361376224.jpg

7.2 幂等性


1)幂等性原理

1673361386857.jpg

2)如何使用幂等性


开启参数 enable.idempotence 默认为 true,false 关闭。


7.3 生产者事务


1)Kafka 事务原理

1673361397239.jpg

2)Kafka 的事务一共有如下 5 个 API

// 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;

3)单个 Producer,使用事务保证消息的仅一次发送

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerRecord;
import java.util.Properties;
public class CustomProducerTransactions {
   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());
     // 设置事务 id(必须),事务 id 任意起名
     properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0");
     // 3. 创建 kafka 生产者对象
     KafkaProducer<String, String> kafkaProducer = new 
     KafkaProducer<String, String>(properties);
     // 初始化事务
     kafkaProducer.initTransactions();
     // 开启事务
     kafkaProducer.beginTransaction();
     try {
         // 4. 调用 send 方法,发送消息
         for (int i = 0; i < 5; i++) {
         // 发送消息
             kafkaProducer.send(new ProducerRecord<>("first","atguigu " + i));
         }
        // int i = 1 / 0;
         // 提交事务
         kafkaProducer.commitTransaction();
     } catch (Exception e) {
         // 终止事务
         kafkaProducer.abortTransaction();
     } finally {
         // 5. 关闭资源
         kafkaProducer.close();
     }
 } 
}


8. 数据有序

1673361442608.jpg


9. 数据乱序


1)kafka在1.x版本之前保证数据单分区有序,条件如下:


max.in.flight.requests.per.connection=1(不需要考虑是否开启幂等性)。


2)kafka在1.x及以后版本保证数据单分区有序,条件如下:


(1)未开启幂等性


max.in.flight.requests.per.connection需要设置为1。


(2)开启幂等性


max.in.flight.requests.per.connection需要设置小于等于5。


原因说明:因为在kafka1.x以后,启用幂等后,kafka服务端会缓存producer发来的最近5个request的元数据,


故无论如何,都可以保证最近5个request的数据都是有序的

1673359137249.jpg

相关文章
|
7天前
|
消息中间件 监控 负载均衡
在Kafka中,如何进行主题的分区和复制?
在Kafka中,如何进行主题的分区和复制?
|
18天前
|
消息中间件 监控 负载均衡
在Kafka中,如何进行主题的分区和复制?
在Kafka中,如何进行主题的分区和复制?
|
29天前
|
消息中间件 存储 分布式计算
大数据-72 Kafka 高级特性 稳定性-事务 (概念多枯燥) 定义、概览、组、协调器、流程、中止、失败
大数据-72 Kafka 高级特性 稳定性-事务 (概念多枯燥) 定义、概览、组、协调器、流程、中止、失败
31 4
|
29天前
|
消息中间件 分布式计算 算法
大数据-67 Kafka 高级特性 分区 分配策略 Ranger、RoundRobin、Sticky、自定义分区器
大数据-67 Kafka 高级特性 分区 分配策略 Ranger、RoundRobin、Sticky、自定义分区器
46 3
|
29天前
|
消息中间件 分布式计算 Java
大数据-73 Kafka 高级特性 稳定性-事务 相关配置 事务操作Java 幂等性 仅一次发送
大数据-73 Kafka 高级特性 稳定性-事务 相关配置 事务操作Java 幂等性 仅一次发送
27 2
|
29天前
|
消息中间件 JSON 大数据
大数据-66 Kafka 高级特性 分区Partition 副本因子Replication Factor replicas动态修改 线上动态修改副本数
大数据-66 Kafka 高级特性 分区Partition 副本因子Replication Factor replicas动态修改 线上动态修改副本数
35 1
|
22天前
|
消息中间件 存储 运维
为什么说Kafka还不是完美的实时数据通道
【10月更文挑战第19天】Kafka 虽然作为数据通道被广泛应用,但在实时性、数据一致性、性能及管理方面存在局限。数据延迟受消息堆积和分区再平衡影响;数据一致性难以达到恰好一次;性能瓶颈在于网络和磁盘I/O;管理复杂性涉及集群配置与版本升级。
|
1月前
|
消息中间件 Java Kafka
Flink-04 Flink Java 3分钟上手 FlinkKafkaConsumer消费Kafka数据 进行计算SingleOutputStreamOperatorDataStreamSource
Flink-04 Flink Java 3分钟上手 FlinkKafkaConsumer消费Kafka数据 进行计算SingleOutputStreamOperatorDataStreamSource
41 1
|
3月前
|
消息中间件 Java Kafka
Kafka不重复消费的终极秘籍!解锁幂等性、偏移量、去重神器,让你的数据流稳如老狗,告别数据混乱时代!
【8月更文挑战第24天】Apache Kafka作为一款领先的分布式流处理平台,凭借其卓越的高吞吐量与低延迟特性,在大数据处理领域中占据重要地位。然而,在利用Kafka进行数据处理时,如何有效避免重复消费成为众多开发者关注的焦点。本文深入探讨了Kafka中可能出现重复消费的原因,并提出了四种实用的解决方案:利用消息偏移量手动控制消费进度;启用幂等性生产者确保消息不被重复发送;在消费者端实施去重机制;以及借助Kafka的事务支持实现精确的一次性处理。通过这些方法,开发者可根据不同的应用场景灵活选择最适合的策略,从而保障数据处理的准确性和一致性。
221 9
|
3月前
|
消息中间件 负载均衡 Java
"Kafka核心机制揭秘:深入探索Producer的高效数据发布策略与Java实战应用"
【8月更文挑战第10天】Apache Kafka作为顶级分布式流处理平台,其Producer组件是数据高效发布的引擎。Producer遵循高吞吐、低延迟等设计原则,采用分批发送、异步处理及数据压缩等技术提升性能。它支持按消息键值分区,确保数据有序并实现负载均衡;提供多种确认机制保证可靠性;具备失败重试功能确保消息最终送达。Java示例展示了基本配置与消息发送流程,体现了Producer的强大与灵活性。
65 3