kafka生产者实现细节

生产者的基本实现

• 引入依赖

<dependency>
    <groupId>org.apache.kafka</groupId>
        <artifactId>kafka-clients</artifactId>
    <version>2.4.1</version>
</dependency>

• 具体实现

package com.qf.kafka;
import org.apache.kafka.clients.producer.*;
import org.apache.kafka.common.serialization.StringSerializer;
import java.util.Properties;
import java.util.concurrent.ExecutionException;
public class MySimpleProducer {
    private final static String TOPIC_NAME = "my-replicated-topic";
        public static void main(String[] args) throws ExecutionException, InterruptedException {
            //1.设置参数
            Properties props = new Properties();
            props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
                    "172.16.253.38:9092,172.16.253.38:9093,172.16.253.38:9094");
            //把发送的key从字符串序列化为字节数组
            props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG,
                    StringSerializer.class.getName());
            //把发送消息value从字符串序列化为字节数组
            props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG,
                    StringSerializer.class.getName());
            //2.创建⽣产消息的客户端，传⼊参数
            Producer<String,String> producer = new KafkaProducer<String,
                    String>(props);
            //3.创建消息
            //key：作⽤是决定了往哪个分区上发，value：具体要发送的消息内容
            ProducerRecord<String,String> producerRecord = new ProducerRecord<>
                    (TOPIC_NAME,"mykeyvalue","hellokafka");
            //4.发送消息,得到消息发送的元数据并输出
            RecordMetadata metadata = producer.send(producerRecord).get();
            System.out.println("同步方式发送消息结果：" + "topic-" +
                    metadata.topic() + "|partition-"
                    + metadata.partition() + "|offset-" + metadata.offset());
        }
}

生产者同步发送消息

如果⽣产者发送消息没有收到ack，⽣产者会阻塞，阻塞到3s的时间，如果还没有收到消息，会进⾏重试。重试的次数3次。

RecordMetadata metadata = producer.send(producerRecord).get();
System.out.println("同步⽅式发送消息结果：" + "topic-" + metadata.topic() + "|partition-" + metadata.partition() + "|offset-" + metadata.offset());

生产者异步发送消息

异步发送，生产者发送完消息后就可以执行之后的业务，broker在收到消息后异步调用生产者提供的callback回调方法。

//5.异步发送消息
producer.send(producerRecord, new Callback() {
    public void onCompletion(RecordMetadata metadata, Exception exception) {
        if (exception != null) {
            System.err.println("发送消息失败：" +
            exception.getStackTrace());
        }
        if (metadata != null) {
            System.out.println("异步⽅式发送消息结果：" + "topic-" +
            metadata.topic() + "|partition-"
            + metadata.partition() + "|offset-" + metadata.offset());
        }
    }
});

生产者中ack的配置

在同步发送的前提下，⽣产者在获得集群返回的ack之前会⼀直阻塞。那么集群什么时候返回
ack呢？此时ack有3个配置：

• ack = 0 kafka-cluster不需要任何的broker收到消息，就立即返回ack给生产者，最容易丢消息，但效率是最⾼的。

• ack=1（默认）： 多副本之间的leader已经收到消息，并把消息写⼊到本地的log中，才会返回ack给生产者，性能和安全性是最均衡的。

• ack=-1/all。⾥⾯有默认的配置min.insync.replicas=2(默认为1，推荐配置大于等于2)， 此时就需要leader和⼀个follower同步完后，才会返回ack给生产者（此时集群中有2个broker已完成数据的接收），这种方式最安全，但性能最差。

下面是关于ack和重试（如果没有收到ack，就开启重试）的配置

props.put(ProducerConfig.ACKS_CONFIG, "1");
 /*
 发送失败会重试，默认重试间隔100ms，重试能保证消息发送的可靠性，但是也可能造
成消息重复发送，⽐如⽹络抖动，所以需要在
 接收者那边做好消息接收的幂等性处理
 */
props.put(ProducerConfig.RETRIES_CONFIG, 3);
//重试间隔设置
props.put(ProducerConfig.RETRY_BACKOFF_MS_CONFIG, 300);

关于消息发送的缓冲区

• kafka默认会创建⼀个消息缓冲区，用来存放要发送的消息，缓冲区是32m。

 props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);

• kafka本地线程会去缓冲区中⼀次拉16k的数据，发送到broker。

props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384); 

• 如果线程拉不到16k的数据，间隔10ms也会将已拉到的数据发到broker。

props.put(ProducerConfig.LINGER_MS_CONFIG, 10);

kafka知识点目录

1.Linux环境部署kafka
2.Win10环境部署kafka
3.docker部署kafka
4.kafka的简单使用
5.kafka消息的细节
6.kafka主题和分区的概念
7.kafka集群操作
8.kafka生产者实现细节
9.kafka消费者实现细节
10.kafka集群中的controller、rebalance、HW
11.kafka中的优化问题
12.Kafka-eagle监控平台
13.kafka错误汇总