Kafka 生产者

一、生产者消息发送流程

1.1、发送原理

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

发送流程：

1.2、生产者重要参数列表

• bootstrap.servers
  生产者连接集群所需的 broker 地址清单。
  例如：hadoop102:9092,hadoop103:9092,hadoop104: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
  • O：生产者发送过来的数据，不需要等数据落盘应答。
  • 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。

二、异步发送 API

2.1、普通异步发送

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

2.2、带回调函数的异步发送

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

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

三、同步发送 API

同步发送流程：

四、生产者分区

4.1、分区好处

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

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

1）默认的分区器 DefaultPartitioner。

public class DefaultPartitioner implements Partitioner { 

Kafka 原则：
全局查找（ctrl +n）ProducerRecord 类，在类中可以看到如下构造方法：

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

public class CustomProducerCallbackPartitions {

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

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

        // 连接集群 bootstrap.servers
        properties.put (ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092,hadoop103: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 生产者对象
        // "" hello
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        // 2 发送数据
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send (new ProducerRecord<>("first", 1,"","hello" + i), new Callback () {
                @Override
                public void onCompletion (RecordMetadata metadata, Exception exception) {

                    if (exception == null){
                        System.out.println ("主题："+metadata.topic () + "分区："+ metadata.partition ());
                    }
                }
            });

            Thread.sleep (2);
        }

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

测试：
1、在 hadoop102 上开启 Kafka 消费者。

[atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh -bootstrap-server hadoop102:9092 --topic first 

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

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

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

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

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

public class CustomProducerCallback {

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

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

        // 连接集群 bootstrap.servers
        properties.put (ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092,hadoop103: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 生产者对象
        // "" hello
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        // 2 发送数据
        for (int i = 0; i < 500; i++) {
            kafkaProducer.send (new ProducerRecord<>("first", "atguigu" + i), new Callback () {
                @Override
                public void onCompletion (RecordMetadata metadata, Exception exception) {

                    if (exception == null){
                        System.out.println ("主题："+metadata.topic () + "分区："+ metadata.partition ());
                    }
                }
            });

            Thread.sleep (2);
        }

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

测试：
1、key="a" 时，在控制台查看结果。

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

2、key="b" 时，在控制台查看结果。

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

3、key="f" 时，在控制台查看结果。

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

4.3、自定义分区器

如果研发人员可以根据企业需求，自己重新实现分区器。
1）需求
例如我们实现一个分区器实现，发送过来的数据中如果包含 atguigu，就发往 0 号分区，不包含 atguigu，就发往 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) {

        // 获取数据 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）使用分区器的方法，在生产者的配置中添加分区器参数。

// 关联自定义分区器
properties.put (ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.atguigu.kafka.producer.MyPartitioner");

（4）测试
1、在 hadoop102 上开启 Kafka 消费者。

[atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh -bootstrap-server hadoop102:9092 --topic first 

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

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

五、生产经验 -- 生产者如何提高吞吐量

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

        // 连接 kafka 集群
        properties.put (ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092,hadoop103:9092");

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

        // 缓冲区大小
        properties.put (ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);

        // 批次大小
        properties.put (ProducerConfig.BATCH_SIZE_CONFIG,16384);

        //linger.ms
        properties.put (ProducerConfig.LINGER_MS_CONFIG, 1);

        // 压缩
        properties.put (ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");


        // 1 创建生产者
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

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

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

测试：
1、在 hadoop102 上开启 Kafka 消费者。

[atguigu@hadoop103 kafka]$ bin/kafka-console-consumer.sh -bootstrap-server hadoop102:9092 --topic first 

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

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

六、生产经验 -- 数据可靠性

6.1、回顾发送流程

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

6.2、ack 应答原理

• 0：生产者发送过来的数据，不需要等数据落盘应答。
• 1：生产者发送过来的数据，Leader 收到数据后应答。
• -1（all）：生产者发送过来的数据，Leader 和 ISR 队列里面 的所有节点收齐数据后应答。
  

思考：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 个，或者 ISR 里应答的最小副本数量 (min.insync.replicas 默认为 1) 设置为 1，和 ack=1 的效果是一 样的，仍然有丢数的风险（leader：0，isr:0）。
数据完全可靠条件：ACK 级别设置为 -1 + 分区副本大于等于 2 + ISR 里应答的最小副本数量大于等于 2。

可靠性总结：

• acks=0，生产者发送过来数据就不管了，可靠性差，效率高；
• acks=1，生产者发送过来数据 Leader 应答，可靠性中等，效率中等；
• acks=-1，生产者发送过来数据 Leader 和 ISR 队列里面所有 Follwer 应答，可靠性高，效率低；

在生产环境中，acks=0 很少使用；acks=1，一般用于传输普通日志，允许丢个别数据；acks=-1，一般用于传输和钱相关的数据， 对可靠性要求比较高的场景。

数据重复分析：
acks: -1（all）：生产者发送过来的数据，Leader 和 ISR 队列里面的所有节点收齐数据后应答。

6.3、代码配置

public class CustomProducerAcks {

    public static void main (String [] args) {

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

        // 连接集群 bootstrap.servers
        properties.put (ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop102:9092,hadoop103: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 生产者对象
        // "" hello
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

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

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

七、生产经验 -- 数据去重

7.1、数据传递语义

至少一次（AtLeast Once）= ACK 级别设置为 - 1 + 分区副本大于等于 2 + ISR 里应答的最小副本数量大于等于 2。
最多一次（AtMostOnce）= ACK 级别设置为 0。

总结：
At Least Once 可以保证数据不丢失，但是不能保证数据不重复；
At Most Once 可以保证数据不重复，但是不能保证数据不丢失。
精确一次（Exactly Once）：对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。
Kafka 0.11 版本以后，引入了一项重大特性：幂等性 和 事务。

7.2、幂等性

7.2.1、幂等性原理

幂等性就是指 Producer 不论向 Broker 发送多少次重复数据，Broker 端都只会持久化一条，保证了不重复。 精确一次（Exactly Once） = 幂等性 + 至少一次 (ack=-1 + 分区副本数 >=2 + ISR 最小副本数量 >=2) 。

重复数据的判断标准：具有 < PID, Partition, SeqNumber > 相同主键的消息提交时，Broker 只会持久化一条。其 中 PID 是 Kafka 每次重启都会分配一个新的；Partition 表示分区号；Sequence Number 是单调自增的。

所以幂等性只能保证的是在单分区单会话内不重复。

7.2.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，使用事务保证消息的仅一次发送

// 设置事务 id（必须），事务 id 任意起名         
properties.put (ProducerConfig.TRANSACTIONAL_ID_CONFIG, "transaction_id_0"); 

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

// 提交事务             
kafkaProducer.commitTransaction (); 
// 终止事务             
kafkaProducer.abortTransaction (); 

八、生产经验 -- 数据有序

九、生产经验 -- 数据乱序

max.in.flight.requests.per.connection 表示每个连接上最大的未完成请求数。具体来说，它限制了一个生产者在与代理节点（broker）建立的连接上能够有多少个未完成的请求。
将其设置为 1 意味着生产者在向代理节点发送请求时，必须等待之前的请求完成（即收到响应）后才能发送下一个请求。这可以确保请求按顺序进行处理，并且避免了一次性发送过多的请求，从而提高了系统的稳定性和可靠性。

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