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

数据完全可靠的条件=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及以后版本保证数据单分区有序，条件如下：
1. 未开启幂等性
  - max.in.flight.requests.per.connection 需要设置为1
2. 开启幂等性
  - max.in.flight.requests.per.connection 需要设置小于等于5
  - 原因说明：在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的5个request的元数据，所以无论如何，都可以保证最近的5个request的数据都是有序的。

Kafka生产者概述

【Kafka】Kafka生产者概述

文章目录

1. 生产者

1.1 生产者消息发送流程

1.1.1 发送原理

1.1.2 生产者重要参数列表

1.2 异步发送 API

1.2.1 普通异步发送

1.2.2 带回调函数的异步发送

1.3 同步发送 Api

2. 生产者分区

2.1 分区的好处

2.2 分区策略

2.3 自定义分区器

3. 生产者提高吞吐量

4. 生产数据可靠性

5. 生产数据去重

5.1 数据传递语义

5.2 幂等性

5.3 生产者事务

6. 数据有序

7. 数据乱序

猜你喜欢