kafka的Produce生产者(四)

  Producer 对应的脚本是 kafka-console-producer.sh，直接运行同样的会显示相关的参数

参数	描述
–bootstrap-server <String: server to connect to>	连接的Kafka broker 主机名称和端口
–topic <String: topic>	操作的topic名称
–batch-size <Integer: size>	消息在单机中批量发送的数量如果它们没有同步发送，默认值200
–max-block-ms <Long: max block on send>	在发送请求期间生产者将阻塞的最长时间
–max-memory-bytes <Long: total memory in bytes>	生产者用来缓冲等待发送的记录的总内存
–max-partition-memory-bytes <Long: memory in bytes per partition>	为分区分配的缓冲区大小。默认值：16384
–message-send-max-retries	生产者放弃并丢弃此消息之前的重试次数。默认值：3
–metadata-expiry-ms <Long: metadata expiration interval>	元数据强制刷新时间。默认值：300000毫秒
–request-required-acks <String: request required acks>	生产者的请求是否需要被确认。默认值：1(收到后应答)，0-不需要等待应答，-1-leader和ISR所有的节点收齐后应答
–request-timeout-ms <Integer: request timeout ms>	生产者请求的确认超时时间。值必须为非负且非零（默认值：1500毫秒）
–retry-backoff-ms	生产者在刷新元数据之前等待的时间。（默认值：100毫秒）
–socket-buffer-size <Integer: size>	socket缓存大小，默认值：102400
–sync	同步发送
–timeout <Integer: timeout_ms>	异步模式下消费者消费的超时时间，默认值：1000毫秒

  在使用生产者之前，需要先了解的相关知识。

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

2. 异步发送
  将外部的数据发送到队列里面，而不管队列是否将数据发送到Kafka里面。

  接下来通过Java代码来演示异步发送流程，演示demo基于普通maven进行演示
  1). 导入jar包

<!-- kafka 客户端-->
<dependency>
    <groupId>org.apache.kafka</groupId>
    <artifactId>kafka-clients</artifactId>
    <version>3.1.0</version>
</dependency>

  2.). 没有回调函数的异步发送测试demo

    public static void main(String[] args) {
        // kafka属性配置
        Properties properties = new Properties();
        // 连接kafka
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
        // k-v序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

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

        // 发送数据
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("first", "hello world" + i)); // 不带回调参数的发送
        }

        // 关闭资源
        producer.close();
    }

  3). 带回调函数的异步发送测试demo
  回调函数会在producer收到ack时调用，为异步调用，该方法有两个参数：元数据信息(RecordMetadata) 和 异常信息(Exception)，若果Exception为null，说明发送成功，否则发送失败。注意：消息发送失败会自动重试，不用手动设置

public static void main(String[] args) {
    // kafka属性配置
    Properties properties = new Properties();
    // 连接kafka
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
    // k-v序列化
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

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

    // 发送数据
    for (int i = 0; i < 10; i++) {
        producer.send(new ProducerRecord<String, String>("first", "hello world" + i), new Callback() {
            @Override
            public void onCompletion(RecordMetadata data, Exception e) {
                if (e == null) {
                    System.out.println("发送成功");
                    System.out.println("主题：" + data.topic());
                    System.out.println("分区：" + data.partition());
                    System.out.println("-----------------------------------------------------");
                } else {
                    System.err.println("发送失败");
                    System.err.println(e);
                }
            }
        }); // 不带回调参数的发送
    }

    // 关闭资源
    producer.close();
}

3. 同步发送

public static void main(String[] args) throws ExecutionException, InterruptedException {
    // kafka属性配置
    Properties properties = new Properties();
    // 连接kafka
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
    // k-v序列化
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

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

    // 发送数据
    for (int i = 0; i < 10; i++) {
        producer.send(new ProducerRecord<String, String>("first", "CustomProducerNotWithCallbackSync" + i)).get(); // 不带回调参数的发送
    }

    // 关闭资源
    producer.close();
}

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

  2.) 分区策略
  在Java中，默认使用DefaultPartitioner分区策略，而在发送的方法中，可以分为三种情况去实现了分区策略

  第一种：直接指明需要使用的partition
  第二种：在没有指明partition的值但有key的情况下，将key的hash值与topic的partition数进行取余得到partition值
  第三种：既没有partition值有没有key值的情况下，kafka采用Stickey Partition(黏性分区器)，会随机选择一个分区，并尽可能一直使用该分区，待该分区的batch已满或已完成，kafka在随机一个分区进行使用
示例：

public class PartitionTestDemo {
    public static void main(String[] args) {
        // kafka属性配置
        Properties properties = new Properties();
        // 连接kafka
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
        // k-v序列化
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

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

        // 发送数据
        for (int i = 0; i < 10; i++) {
            // 发送到指定分区
//            designPartition(producer, i);
            // 不指定分区发送
            notDesignPartition(producer, i);
        }

        // 关闭资源
        producer.close();
    }

    /**
     * 指定分区发送
     */
    public static void designPartition(KafkaProducer<String, String> producer, int i) {
        producer.send(new ProducerRecord<String, String>("first", 0, "", "测试发送到指定的分区" + i), new Callback() {
            @Override
            public void onCompletion(RecordMetadata data, Exception e) {
                if (e == null) {
                    System.out.println("发送成功");
                    System.out.println("主题：" + data.topic());
                    System.out.println("分区：" + data.partition());
                    System.out.println("-----------------------------------------------------");
                } else {
                    System.err.println("发送失败");
                    System.err.println(e);
                }
            }
        }); // 不带回调参数的发送
    }

    /**
     * 不指定分区发送
     */
    public static void notDesignPartition(KafkaProducer<String, String> producer, int i) {
        producer.send(new ProducerRecord<String, String>("first", "b", "测试发送不指定分区" + i), new Callback() {
            @Override
            public void onCompletion(RecordMetadata data, Exception e) {
                if (e == null) {
                    System.out.println("发送成功");
                    System.out.println("主题：" + data.topic());
                    System.out.println("分区：" + data.partition());
                    System.out.println("-----------------------------------------------------");
                } else {
                    System.err.println("发送失败");
                    System.err.println(e);
                }
            }
        }); // 不带回调参数的发送
    }
}

  3). 自定义分区
  kafka的jar默认提供了三种分区策略，我们也可以根据自己的需求自定义分区器，需要去实现Partitioner类

/**
 * 自定义分区器
 */
 public class MyPartitioner implements Partitioner {
    /**
     * @param topic      主题
     * @param key        键
     * @param keyBytes   序列化后的键
     * @param value      值
     * @param valueBytes 序列化后的值
     * @return int
     * @desc 实现自定义分区
     * @author 華小灼
     * @date 2022-03-21 20:58
     */
    @Override
    public int partition(String topic, Object key, byte[] keyBytes, Object value, byte[] valueBytes, Cluster cluster) {
        /**
         * 需求：
         *   如果数据包含"dev"就发往0号分区，包含"prod"发往1号分区，其余的发往2号分区
         */
        String str = value.toString();
        if (str.contains("dev")) {
            return 0;
        }
        if (str.contains("prod")) {
            return 1;
        }
        return 2;
    }

    @Override
    public void close() {

    }

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

    }
}


/**
 * 测试
 */
public static void main(String[] args) {
    // kafka属性配置
    Properties properties = new Properties();
    // 连接kafka
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
    // k-v序列化
    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, MyPartitioner.class);

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

    // 发送数据
    for (int i = 0; i < 10; i++) {
        producer.send(new ProducerRecord<String, String>("first", (i % 2 == 0 ? "dev开发环境" : "prod生产环境") + i), new Callback() {
            @Override
            public void onCompletion(RecordMetadata data, Exception e) {
                if (e == null) {
                    System.out.println("发送成功");
                    System.out.println("主题：" + data.topic());
                    System.out.println("分区：" + data.partition());
                    System.out.println("-----------------------------------------------------");
                } else {
                    System.err.println("发送失败");
                    System.err.println(e);
                }
            }
        });
    }

    producer.send(new ProducerRecord<String, String>("first", "看看你发送到哪儿"), new Callback() {
        @Override
        public void onCompletion(RecordMetadata data, Exception e) {
            if (e == null) {
                System.out.println("发送成功");
                System.out.println("主题：" + data.topic());
                System.out.println("分区：" + data.partition());
                System.out.println("-----------------------------------------------------");
            } else {
                System.err.println("发送失败");
                System.err.println(e);
            }
        }
    });

    // 关闭资源
    producer.close();
}

5. 生产者提高吞吐量
  默认情况下生产者接收到一个外部的数据，就将这个数据发送到kafka中，但是我们可以通过 batch.size 和 linger.ms 这两个参数去调节，batch.size表示每一次发送数据量的大小，默认16K，即当数据量达到16K时才发送，linger.ms表示发送等待的时间，默认0毫秒，范围在5-100毫秒之间，这两个参数是同时使用的，注意：linger.ms=0 时表示不等待立即发送，即来一个发送一个，batch.size 参数就会失效；也可以使用 compression.type 对数据进行压缩传送，默认none，可配置：gzip snappy lz4 zstd；RecordAccumlator 修改缓冲区大小，默认32M
示例：

public static void main(String[] args) {
    Properties properties = new Properties();
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124: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, 64 * 1024 * 1024);
    // 批次大小
    properties.put(ProducerConfig.BATCH_SIZE_CONFIG, 32 * 1024);
    // linger.ms
    properties.put(ProducerConfig.LINGER_MS_CONFIG, 10);
    // 压缩,默认none，可配置：gzip snappy lz4 zstd
    properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG, "snappy");
    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    for (int i = 0; i < 10; i++) {
        producer.send(new ProducerRecord<String, String>("first", i + ""));
    }
    producer.close();
}

6. 数据可靠性
  主要是通过 ack 应答机制实现，kafka在接收到生产者数据后进行应答，应答的级别主要有三级：0、1、-1(all)
  0： 生产者发送的数据不需要等待数据落盘应答，可靠性差，效率高
  1： 生产者发送的数据leader收到数据后应答，可靠性中等，效率中等
  -1(all)： 生产者发送的数据leader和isr队列里面的所有节点收齐数据后应答，可靠性高，效率低
  但是得注意，leader维护了一个动态的in-sync replica set （ISR）,意味着和leader保持同步的Follower+Leader集合(leader：0，isr：0,1，2)。如果Follower长时间未向leader发送通信请求或同步数据，则该Follwer将被剔除ISR。该时间阈值由 replica.lag.time.max.ms 参数设置，默认值30s，这样就不用等待长期联系不上或已经故障的节点。但是如果分区副本只设置了一个，或者ISR里应答的最小副本数量(min.insync.replicas 默认1)设置为1，和ack=1的效果是一样的，仍有丢数的风向。
所有从上面的描述，我们可以得到一个数据完成可靠的公式：ACK级别设置-1 + 分区副本大于等于2 + ISR里应答的最小副本数大于等于2
  在生产环境中，ack=0 很少使用；ack=1 一般用于传输普通日志，允许丢失个别数据；ack=-1 一般用于传输和钱相关的数据，对可靠性要求比较高的场景。当然ack的值还是得根据自己的实际业务需求去设置。
示例：

public static void main(String[] args) {
        Properties properties = new Properties();
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());

        // ack配置,默认-1(all)
        properties.put(ProducerConfig.ACKS_CONFIG, "1");
        // 重试次数
        properties.put(ProducerConfig.RETRIES_CONFIG, 10);

        KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("first", "ACK测试" + i), new Callback() {
                @Override
                public void onCompletion(RecordMetadata data, Exception e) {
                    if (e == null) {
                        System.out.println("分区：" + data.partition());
                    } else {
                        System.err.println("发送失败");
                        System.err.println(e);
                    }
                }
            });
        }

        // 关闭资源
        producer.close();
    }

7. 数据重复
  kafka 0.11版本后引入了 幂等性和事务，可以有效的解决数据重复的问题
  幂等性是Producer不论向Broker发送多少重复的数据，Broker端都只会持久化一条，保证了不重复
  重复数据判断标准：具有<PID, Partition, SeqNumber> 相同主键的消息提交时，Broker只会持久化一条，其中PID是kafka每次重启都会分配一个新的，Partition表示分区号，Sequence Number 是单调递增的，所以幂等性只能保证的是在单分区单会话内不重复

  使用时可以通过 enable.idempotence 开启或关闭，默认为true开启。
  kafka的事务开启前，必须的开启幂等性

示例：

public static void main(String[] args) {
    Properties properties = new Properties();
    properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.0.124:9092");
    properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, StringSerializer.class.getName());
    // ack应答机制必须是-1或all
    properties.put(ProducerConfig.ACKS_CONFIG, "-1");
    properties.put(ProducerConfig.RETRIES_CONFIG, 10);
    // 幂等性
    properties.put(ProducerConfig.ENABLE_IDEMPOTENCE_CONFIG, true);
    // 指定事务ID,保证全局唯一
    properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG, "trasation_id_001");

    KafkaProducer<String, String> producer = new KafkaProducer<>(properties);
    // 初始化事务
    producer.initTransactions();
    // 启动事务
    producer.beginTransaction();

    try {
        // 发送数据
        for (int i = 0; i < 10; i++) {
            producer.send(new ProducerRecord<String, String>("first", 0, "", "事务测试"));
        }
        // 模拟失败
//            int i = 10 / 0;
        // 提交事务
        producer.commitTransaction();
    } catch (Exception e) {
        // 发送失败，终止事务
        producer.abortTransaction();
    } finally {
        // 关闭资源
        producer.close();
    }
}

8. 数据乱序

源码地址：https://gitee.com/peachtec/hxz-study