【kafka3.0】生产者producer

kafka生产者

生产者消息发送流程

发送原理

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

普通的异步发送

package com.lihw.kafka.producer;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;

import java.util.Properties;
public class CustomProducer {

    public static void main(String[] args) {

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

        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.61.121: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 < 10; i++) {
            kafkaProducer.send(new ProducerRecord<>("first","lihw " + i));
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }
}

消费first主题

crbt@node2:/home/crbt/local/kafka_2.13-2.7.1/bin>./kafka-console-consumer.sh --bootstrap-server localhost:9092  --topic first
lihw 0
lihw 1
lihw 2
lihw 3
lihw 4

带回调函数的异步发送

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

package com.lihw.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;

public class CustomProducerCallback {

    public static void main(String[] args){

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

        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.61.121:9092,10.1.61.122: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");

        // request.timeout.ms = 3000ms
        properties.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);

        // 3. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

       try{
           // 4. 调用 send 方法,发送消息
           for (int i = 0; i < 10; i++) {
               kafkaProducer.send(new ProducerRecord<>("first", "lihw " + i), new Callback() {
                   @Override
                   public void onCompletion(RecordMetadata metadata, Exception e) {
                       if (e == null) {
                           // 没有异常,输出信息到控制台
                           System.out.println(" 主题： " +
                                   metadata.topic() + " ->" + " 分区：" + metadata.partition());
                       } else {
                           // 出现异常打印
                           e.printStackTrace();
                       }
                   }
               });
               // 延迟一会会看到数据发往不同分区
            Thread.sleep(2);
           }
       }catch (Exception e){
           e.printStackTrace();
       }finally {
           // 5. 关闭资源
           kafkaProducer.close();
       }
    }
}

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

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

同步发送API

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

kafkaProducer.send(new ProducerRecord<>("first","kafka" + i)).get();

生产者重要参数列表

生产者分区

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

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

• 指定partition的，发送消息时直接发送到指定的分区中
• 未指定partition但有key的，对key进行hash，然后对partition数进行取余，得出该发往哪个分区
• 没有key，也未指定partition的，采用粘性分区器，选择一个分区开始存储，待该分区的batch已满或者已完成，Kafka再随机一个分区进行使用（和上一次的分区不同）

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) {
  ...
}

/*
 * 没有指明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) {
  ...
}

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

案例一：指定分区发送消息

package com.lihw.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;

public class CustomProducerCallbackPartitions {

    public static void main(String[] args) {

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

        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.61.121:9092,10.1.61.122: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());

        // request.timeout.ms = 3000ms
        properties.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);

        // 3. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        for (int i = 0; i < 5; i++) {
            // 指定数据发送到 1 号分区，key 为空（IDEA 中 ctrl + p 查看参数）
            kafkaProducer.send(new ProducerRecord<>("first",
                    0,"","NBA " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata,
                                         Exception e) {
                    if (e == null){
                        System.out.println(" 主题： " +
                                metadata.topic() + " -> " + "分区：" + metadata.partition()
                        );
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }
        kafkaProducer.close();
    }
}

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

案例二：自定义分区器

自定义分区器，实现Partitioner接口，重写partition方法，方法返回的是分区数

package com.lihw.kafka.producer;
import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;
import java.util.Map;

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("lihw")){
            partition = 0;
        }else {
            partition = 1;
        }
        // 返回分区号
        return partition;
    }

    @Override
    public void close() {

    }

    @Override
    public void configure(Map<String, ?> configs) {

    }
}

发送消息测试，最终消息全部打在0号分区

package com.lihw.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;

public class CustomProducerCallbackPartitions {

    public static void main(String[] args) {

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

        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.61.121:9092,10.1.61.122: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());

        // request.timeout.ms = 3000ms
        properties.put(ProducerConfig.REQUEST_TIMEOUT_MS_CONFIG,3000);

        // 3.添加自定义分区器
        properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG,"com.lihw.kafka.producer.MyPartitioner");

        // 4. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        for (int i = 0; i < 10; i++) {
            // 指定数据发送到 0 号分区，key 为空,根据自定义分区器进行分区
            kafkaProducer.send(new ProducerRecord<>("first","lihw " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata,
                                         Exception e) {
                    if (e == null){
                        System.out.println(" 主题： " +
                                metadata.topic() + " -> " + "分区：" + metadata.partition()
                        );
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }
        kafkaProducer.close();
    }
}

结果：消息全部发到了0号分区（121节点）

crbt@node1:/home/crbt/local/kafka_2.13-2.7.1/bin>./kafka-console-consumer.sh --bootstrap-server localhost:9092  --topic first
lihw 0
lihw 1
lihw 2
lihw 3
lihw 4
lihw 5
lihw 6
lihw 7
lihw 8
lihw 9

生产者如何提高吞吐量

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

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

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, "10.1.61.121:9092,10.1.61.122: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());

        // 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<String, String>(properties);
        // 4. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("first",1,"","lihewei777 " + i));
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }
}

数据可靠性【ACK】

ACK应答级别

• 0：生产者发送过来的数据，不需要等数据落盘应答。生产者发送过来数据就不管了，可靠性差，效率高；
• 1：生产者发送过来的数据，Leader收到数据后应答。可靠性中等，效率中等；
• -1（all）：生产者发送过来的数据，Leader和ISR队列里面的所有节点收齐数据后应答。可靠性高，效率低；

ISR队列

​ 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)。

重复数据分析

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

leader收到消息并落盘后，返回adc之前挂掉，此时会重新选选举出新的leader，producer重新发送相同的消息，导致数据重复。

代码配置

 // 设置 acks
 properties.put(ProducerConfig.ACKS_CONFIG, "all");

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

案例

package com.lihw.kafka.producer;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;

public class CustomProducerAck {

    public static void main(String[] args) {
        // 1. 创建 kafka 生产者的配置对象
        Properties properties = new Properties();

        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.61.121:9092,10.1.61.122: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. 设置 acks
        properties.put(ProducerConfig.ACKS_CONFIG, "all");
        // 4. 重试次数 retries，默认是 int 最大值，2147483647
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);

        // 4. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<String, String>(properties);

        for (int i = 0; i < 10; i++) {
            // 指定数据发送到 0 号分区，key 为空,根据自定义分区器进行分区
            kafkaProducer.send(new ProducerRecord<>("first","lili " + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata metadata,
                                         Exception e) {
                    if (e == null){
                        System.out.println(" 主题： " +
                                metadata.topic() + " -> " + "分区：" + metadata.partition()
                        );
                    }else {
                        e.printStackTrace();
                    }
                }
            });
        }
        kafkaProducer.close();
    }
}

数据去重

数据传递的意义

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

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事务

开启事务，必须开启幂等性，Producer 在使用事务功能前，必须先自定义一个唯一的 transactional.id。有了 transactional.id，即使客户端挂掉了，它重启后也能继续处理未完成的事务。

默认有50个分区，每个分区负责一部分事务。事务划分是根据transactional.id的hashcode值%50，计算出该事务属于哪个分区。该分区Leader副本所在的broker节点即为这个transactional.id对应的Transaction Coordinator节点。

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.lihw.kafka.producer;

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

import java.util.Properties;

public class CustomProducerTransactions {

    public static void main(String[] args) {
        // 1. 创建 kafka 生产者的配置对象
        Properties properties = new Properties();

        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "10.1.61.121:9092,10.1.61.122: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());

        // 设置事务 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 < 10; i++) {
                // 发送消息
                kafkaProducer.send(new ProducerRecord<>("first",
                        "transaction " + i), new Callback() {
                    @Override
                    public void onCompletion(RecordMetadata metadata, Exception e) {
                        if (e == null){
                            System.out.println(" 主题： " +
                                    metadata.topic() + " -> " + "分区：" + metadata.partition()
                            );
                        }else {
                            e.printStackTrace();
                        }
                    }
                });
            }
            int i = 1 / 0;
            // 提交事务
            kafkaProducer.commitTransaction();
        } catch (Exception e) {
            // 终止事务
            kafkaProducer.abortTransaction();
        } finally {
            // 5. 关闭资源
            kafkaProducer.close();
        }
    }
}

如果发生异常，则终止事务

org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted
org.apache.kafka.common.errors.TransactionAbortedException: Failing batch since transaction was aborted

数据有序

数据无序

1）kafka在1.x版本之前保证数据单分区有序，条件如下：max.in.flight.requests.per.connection=1（不需要考虑是否开启幂等性）。

2）kafka在1.x及以后版本保证数据单分区有序，条件如下：

• 开启幂等性max.in.flight.requests.per.connection需要设置小于等于5。
• 未开启幂等性max.in.flight.requests.per.connection需要设置为1。

原因说明：因为在kafka1.x以后，启用幂等后，kafka服务端会缓存producer发来的最近5个request的元数据，故无论如何，都可以保证最近5个request的数据都是有序的

本栏目推荐文章
• 第二章 Spring Boot 整合 Kafka消息队列 生产者
• ClickHouse(21)ClickHouse集成Kafka表引擎详细解析
• org.springframework.kafka.listener.ListenerExecutionFailedException: Listener method could not be invoked with the incoming message
• ogg-kafka
• kafka 服务开机自启动
• TiDB 在单机上模拟部署生产环境集群
• Kafka - 面试题
• java生产环境下性能监控与调优
• 40 个 SpringBoot 常用注解：让生产力爆表！
• 12-Helm Chart：如何在生产环境中释放部署

生产者 producer kafka3 kafka生产者producer kafka3 kafka producer consumer kafka3 broker kafka3 kafka3 kafka zookeeper模式kafka3 kafka windows kafka3 kafka cmak kafka-producer kafka-producer-perf-test 过程grafana kafka3 kafka consumer消费者kafka3 kafka