Kafka生产者概述

【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.kafkagroupId>
    <artifactId>kafka-clientsartifactId>
    <version>3.0.0version>
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 分区的好处

好处：

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

---

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号分区。

实现步骤：

1. 定义一个类实现 Partitioner 接口
2. 重写 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) {

    }
}

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

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接收了两份相同的数据，导致了数据重复。

  

数据完全可靠的条件=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.这样就造成了数据的乱序。

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

---