生产者消息发送流程

发送原理

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

• batch.size：只有数据积累到batch.size之后，sender才会发送数据。默认16k
• linger.ms：如果数据迟迟未达到batch.size，sender等待linger.ms设置的时间到了之后就会发送数据。单位ms，默认值是0ms，表示没有延迟。
• 应答acks
  • 0:生产者发送过来的数据，不需要等数据落盘应答。
  • 1:生产者发送过来的数据，Leader收到数据后应答。
  • -1(all):生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答。-1和all等价。

生产者重要参数列表

异步发送API

普通异步发送

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

代码编写

1. 创建工程kafka

2. 导入依赖

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

3. 创建包名：com.zh.kafka.producer

4. 编写不带回调函数的API代码 ```java package com.zh.kafka.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;

/**

• author: zhanghui
• project: big-data-learning
• package: com.zh.kafka.producer
• filename: CustomProducer
• date: 2022/3/30 14:16

• description: 普通异步发送 */ public class CustomProducer {

  public static void main(String[] args) {

   // 0. 配置
   Properties properties = new Properties();
  
   // 连接集群
   properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103: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 kafkaProducer = new KafkaProducer<String, String>(properties);
  
   // 2. 发送数据
   for (int i = 0; i < 10; i++) {
       kafkaProducer.send(new ProducerRecord("first", "yixia" + i));
   }
  
   // 3. 关闭资源
   kafkaProducer.close();
  

  } } ```

1. 测试：

   1. 在linux102上开启kafka消费者。

      [linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first
      

   2. 在IDEA中执行代码，观察linux102控制台中是否接收到消息。

      [linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first 
      yixia0
      yixia1
      yixia2
      yixia3
      yixia4
      yixia5
      yixia6
      yixia7
      yixia8
      yixia9
      

      带回调函数的异步发送

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

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

package com.zh.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducer
 * date: 2022/3/30 14:16
 * description: 带回调的异步发送
 */
public class CustomProducerCallback {

    public static void main(String[] args) throws InterruptedException {

        // 0. 配置
        Properties properties = new Properties();

        // 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103: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 kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2. 发送数据
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord("first", "yixia" + 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);
        }

        // 3. 关闭资源
        kafkaProducer.close();
    }
}

测试：

1. 在linux102上开启Kafka消费者。

   [linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first
   

2. 在IDEA中执行代码，观察linux102控制台中是否接收到消息。

   [linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first 
   yixia0
   yixia1
   yixia2
   yixia3
   yixia4
   yixia5
   yixia6
   yixia7
   yixia8
   yixia9
   

3. 在IDEA控制台观察回调信息。

   主题：first->分区：0
   主题：first->分区：0
   主题：first->分区：0
   主题：first->分区：0
   主题：first->分区：2
   主题：first->分区：2
   主题：first->分区：2
   主题：first->分区：2
   主题：first->分区：2
   主题：first->分区：2
   

同步发送API

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

package com.zh.kafka.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;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducer
 * date: 2022/3/30 14:16
 * description: 同步发送
 */
public class CustomProducerSync {

    public static void main(String[] args) throws ExecutionException, InterruptedException {

        // 0. 配置
        Properties properties = new Properties();

        // 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103: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 kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2. 发送数据
        for (int i = 0; i < 10; i++) {
            kafkaProducer.send(new ProducerRecord("first", "yixia" + i)).get();
        }

        // 3. 关闭资源
        kafkaProducer.close();
    }
}

测试：

1. 在linux102上开启Kafka消费者。

   [linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first
   

2. 在IDEA中执行代码，观察linux102控制台中是否接收到消息。

   [linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first 
   yixia0
   yixia1
   yixia2
   yixia3
   yixia4
   yixia5
   yixia6
   yixia7
   yixia8
   yixia9
   

   生产者分区

分区好处

1. 便于合理使用存储资源，每个Partition在一个Broker上存储，可以把海量的数据按照分区切割一块一块数据存储在多台Broker上。合理控制分区的任务，可以实现负载均衡的效果。
2. 提高并行度，生产者可以以分区为单位发送数据：消费者可以以分区为单位进行消费数据。

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

默认的分区器DefaultPartitoner

1. 指明partition的情况下，直接将指明的值作为partition值；例如partition=0，所有数据写入分区0.

• public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value, Iterable<Header> headers) {...}
• public ProducerRecord(String topic, Integer partition, Long timestamp, K key, V value) {...}
• public ProducerRecord(String topic, Integer partition, K key, V value, Iterable<Header> headers) {...}
• public ProducerRecord(String topic, Integer partition, K key, V value) {...}

1. 没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值；例如：key1的hash值=5，key2的hash值=6，topic的partition数=2，那么key1对应的value1写入1号分区，key2对应的value2写入0号分区。

• public ProducerRecord(String topic, K key, V value) {...}

1. 既没有partition值又没有key值的情况下，Kafka采用Sticky Partition（黏性分区器），会随机选择一个分区，并尽可能一直使用该分区，待该分区的batch已满或者已完成，Kafka再随机一个分区进行使用（和上一次的分区不同）。例如：第一次随机选择0号分区，等0号分区当前批次满了（默认16K）或者linger.ms设置的时间到，Kafka再随机一个分区进行使用（如果还是0会继续随机）。

• public ProducerRecord(String topic, V value) {...}

案例一

将数据发往指定partition的情况下，例如，将所有数据发往分区1中。

package com.zh.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducer
 * date: 2022/3/30 14:16
 * description: 异步发送至指定分区（分区器）
 */
public class CustomProducerCallbackPartitions {

    public static void main(String[] args) throws InterruptedException {

        // 0. 配置
        Properties properties = new Properties();

        // 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103: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 kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2. 发送数据
        for (int i = 0; i < 10; i++) {
            // 指定数据发送到1号分区，key为空
            kafkaProducer.send(new ProducerRecord("first", 1, "", "yixia" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        // 没有异常，输出信息到控制台
                        System.out.println("主题：" + metadata.topic() + "->分区：" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });
        }

        // 3. 关闭资源
        kafkaProducer.close();
    }
}

测试
①在linux102上开启Kafka消费者。

[linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first

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

[linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first

③在IDEA控制台观察回调信息。

主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1

案例二

没有指明partition值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值。

package com.zh.kafka.producer;

import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducer
 * date: 2022/3/30 14:16
 * description: 异步发送至指定分区（分区器）
 */
public class CustomProducerCallbackPartitions {

    public static void main(String[] args) throws InterruptedException {

        // 0. 配置
        Properties properties = new Properties();

        // 连接集群
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103: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 kafkaProducer = new KafkaProducer<String, String>(properties);

        // 2. 发送数据
        for (int i = 0; i < 10; i++) {
            // value中嵌入相关的值
            kafkaProducer.send(new ProducerRecord("first", "", "yixia" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        // 没有异常，输出信息到控制台
                        System.out.println("主题：" + metadata.topic() + "->分区：" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });
        }

        // 3. 关闭资源
        kafkaProducer.close();
    }
}

测试

①key=”a”时，在控制台查看结果。

主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1
主题：first->分区：1

②key=”b”时，在控制台查看结果。

主题：first->分区：2
主题：first->分区：2
主题：first->分区：2
主题：first->分区：2
主题：first->分区：2

③key=”f”时，在控制台查看结果。

主题：first->分区：0
主题：first->分区：0
主题：first->分区：0
主题：first->分区：0
主题：first->分区：0

自定义分区器

如果研发人员可以根据企业需求，自己重新实现分区器。

需求

例如我们实现一个分区器实现，发送过来的数据中如果包含zh，就发往0号分区，不包含zh，就发往1号分区。

实现步骤

1. 定义类实现Partitioner接口。
2. 重写partition()方法。 ```java package com.zh.kafka.producer;

import org.apache.kafka.clients.producer.Partitioner; import org.apache.kafka.common.Cluster;

import java.util.Map;

/**

• author: zhanghui
• project: big-data-learning
• package: com.zh.kafka.producer
• filename: MyPartitioner
• date: 2022/4/22 23:52

• description: 自定义分区器 */ public class MyPartitioner implements Partitioner { @Override public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {

   // 获取消息
   String msgValue = value.toString();
  
   // 创建partition
   int partition;
  
   // 判断消息是否包含yixia
   if (msgValue.contains("yixia")) {
       partition = 0;
   } else {
       partition = 1;
   }
   return partition;
  

  }

  @Override public void close() {

  }

  @Override public void configure(Map configs) {

  } } ```

1. 使用分区器的方法，在生产者的配置中添加分区器参数。 ```java package com.zh.kafka.producer;

import org.apache.kafka.clients.producer.*; import org.apache.kafka.common.serialization.StringSerializer;

import java.util.Properties;

/**

• author: zhanghui
• project: big-data-learning
• package: com.zh.kafka.producer
• filename: CustomProduverCallbackPartitions
• date: 2022/4/22 23:53

• description: 使用自定义分区器 */ public class CustomProducerCallbackPartitions {

  public static void main(String[] args) {

   // 0 配置
   Properties properties = new Properties();
  
   properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103: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, "com.zh.kafka.producer.MyPartitioner");
  
   KafkaProducer<Object, Object> kafkaProducer = new KafkaProducer<>(properties);
  
   for (int i = 0; i < 5; i++) {
       kafkaProducer.send(new ProducerRecord<>("first", "yixia " + i), new Callback() {
           @Override
           public void onCompletion(RecordMetadata metadata, Exception exception) {
               if (exception == null) {
                   System.out.println("主题：" + metadata.topic() + "->分区：" + metadata.partition());
               } else {
                   exception.printStackTrace();
               }
           }
       });
   }
  
   kafkaProducer.close();
  

  }

}

4. 测试
   1. 在linux102上开启kafka消费者。
```shell
[linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first

1. 在IDEA控制台观察回调信息。

   主题：first->分区：0
   主题：first->分区：0
   主题：first->分区：0
   主题：first->分区：0
   主题：first->分区：0
   

生产经验——生产者如何提高吞吐量

默认，来一次运送一个，可以增加缓冲区大小，一次运走多个。

• batch.size：批次大小，默认16K
• linger.ms：等待时间，修改为5-100ms
• compression.type：压缩snappy
• RecordAccumulator：缓冲区大小，修改为64M

package com.zh.kafka.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;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducerParameters
 * date: 2022/4/23 0:09
 * description: 生产者提高吞吐率
 */
public class CustomProducerParameters {
    public static void main(String[] args) {

        // 1. 创建Kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 给kafka配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092,linux103:9092");

        // key, value序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // 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<>(properties);

        // 4. 调用send方法，发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first", "yixia " + i));
        }

        // 5. 关闭资源
        kafkaProducer.close();

    }
}

测试：
①在linux102上开启Kafka消费者。

[linux@linux102 kafka]$ bin/kafka-console-consumer.sh --bootstrap-server linux102:9092 --topic first

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

yixia 0
yixia 1
yixia 2
yixia 3
yixia 4

生产经验——数据可靠性

回顾发送流程

ack应答原理

可靠性总结：

• acks=0，生产者发送过来数据就不管了，可靠性差，效率高；
• acks=1，生产者发送过来数据Leader应答，可靠性中等，效率中等；
• acks=-1，生产者发送过来数据Leader和ISR队列里面所有Follower应答，可靠性高，效率低。
• 在生产环境中，acks=0很少使用；acks=1，一般用于传输普通日志，允许丢个别数据，acks=-1，一般用于传输和钱相关的数据，对可靠性要求比较高的场景。

代码配置

package com.zh.kafka.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;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducerAck
 * date: 2022/4/23 0:18
 * description: 数据可靠性
 */
public class CustomProducerAck {
    public static void main(String[] args) {
        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092");

        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<>(properties);

        // 4. 调用send方法，发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first", "yixia " + i));
        }

        // 5. 关闭资源
        kafkaProducer.close();
    }
}

生产经验——数据去重

数据传递语义

• 至少一次（At Least Once）= ACk级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2
• 最多一次（At Most Once）= ACK几倍设置为0
• 总结：
  • At Least Once可以保障数据不丢失，但是不能保证数据不重复。
  • At Most Once可以保证数据不重复，但是不能保证数据不丢失。
• 精确一次（Exactly Once）：对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。Kafka 0.11版本以后，引入了一项重大特性：幂等性和事务。

幂等性

幂等性原理

• 幂等性就是指Producer不论向Broker发送多少次重复数据，Broker端都只会持久化一条，保证了不重复。
• 精确一次（Exactly Once）= 幂等性 + 至少一次（ack=-1 + 分区副本数 >= 2 + ISR最小副本数量 >= 2）
• 重复数据的判断标准，具有<PID，Partition，SeqNumber>相同主键的消息提交时，Broker只会持久化一条。其中PID是Kafka每次重启都会分配一个新的；Partition表示分区号；Sequence Number是单调递增的。
• 所以幂等性只能保证的是在单分区单会话内不重复。

如何使用幂等性

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

生产者事务

Kafka事务原理

说明：开启事务，必须开启幂等性。

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;

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

package com.zh.kafka.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;

/**
 * author: zhanghui
 * project: big-data-learning
 * package: com.zh.kafka.producer
 * filename: CustomProducerTransactions
 * date: 2022/4/23 0:24
 * description: Kafka事务
 */
public class CustomProducerTransactions {
    public static void main(String[] args) {
        // 1. 创建kafka生产者的配置对象
        Properties properties = new Properties();

        // 2. 添加配置
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "linux102:9092");

        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<>(properties);

        // 初始化事务
        kafkaProducer.initTransactions();
        // 开启事务
        kafkaProducer.beginTransaction();

        try {
            // 4. 调用send方法，发送消息
            for (int i = 0; i < 5; i++) {
                kafkaProducer.send(new ProducerRecord<>("first", "yixia " + i));
            }

            int i = 1 / 0;

            // 提交事务
            kafkaProducer.commitTransaction();

        } catch (Exception e) {
            // 终止事务
            kafkaProducer.abortTransaction();
        } finally {
            // 5. 关闭资源
            kafkaProducer.close();
        }
    }
}

生产经验——数据有序

生产经验——数据乱序

1. Kafka在1.x版本之前保证单分区有序，条件如下：
   1. max.in.flight.requests.per.connection=1（不需要考虑是否开启幂等性）。
2. kafka在1.x及以后版本保证数据单分区有序，条件如下：
   1. 未开启幂等性
      1. max.in.flight.requests.per.connection需要设置为1
   2. 开启幂等性
      1. max.in.flight.requests.per.connection需要设置小于等于5
      2. 原因说明：因为在Kafka1.x以后，启用幂等性后，kafka服务端会缓存Producer发来的最近5个request的元数据，故无论如何，都可以保证最近5个request的数据都是有序的。