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

Kafka 生产者

1. 生产者消息发送流程

1.1 发送原理

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

1.2 生产者重要参数列表

2.异步发送 API

2.1 普通异步发送

1）需求：创建 Kafka 生产者，采用异步的方式发送到 Kafka Broker

异步发送流程

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）提高并行度，生产者可以以分区为单位发送数据；消费者可以以分区为单位进行消费数据。

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

1）默认的分区器 DefaultPartitioner

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

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. 生产者如何提高吞吐量

// 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 应答原理

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

7. 数据去重

7.1 数据传递语义

7.2 幂等性

1）幂等性原理

2）如何使用幂等性

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

7.3 生产者事务

1）Kafka 事务原理

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. 数据有序

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的数据都是有序的