kafka学习（二）生产者

生产者消息发送流程

发送原理

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

生产者重要参数列表

bootstrap.servers
生产者连接集群所需的 broker 地址清单，可以设置 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

异步发送

允许用户把一个消息放入队列，但并不立即处理它，然后在需要的时候再去处理它们。

普通异步发送

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

带回调函数的API

首先开启消费者
./kafka-console-consumer.sh --bootstrap-server 146.56.246.156:9092 --topic test

编写生产者程序

import org.apache.kafka.clients.producer.*;

import java.util.Properties;

public class Producer {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建 kafka 生产者的配置对象
        Properties properties = new Properties();
        // 2. 给 kafka 配置对象添加配置信息：bootstrap.servers
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG,
                "146.56.246.156: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 < 5; i++) {
            // 添加回调
            kafkaProducer.send(new ProducerRecord<>("test",
                    "mofumofu " + i), new Callback() {// 该方法在 Producer 收到 ack 时调用，为异步调用
                @Override
                public void onCompletion(RecordMetadata metadata,
                                         Exception exception) {
                    if (exception == null) {
                        // 没有异常,输出信息到控制台
                        System.out.println(" 主题： " +
                                metadata.topic() + "->" + "分区：" + metadata.partition());
                    } else {
                        // 出现异常打印
                        exception.printStackTrace();
                    }
                }
            });
            //延迟一会会看到数据发往不同分区
            Thread.sleep(200);
        }
        // 5. 关闭资源
        kafkaProducer.close();
    }
}

消费者可以收到五条消息

ide的console

不带回调的API

for (int i = 0; i < 5; i++) {
 kafkaProducer.send(new 
	ProducerRecord<>("test","message: " + i));
 }

同步发送

要求消息处理并立即响应
只需在异步发送的基础上，再调用一下 get()方法即可。

		// 4. 调用 send 方法,发送消息
        for (int i = 0; i < 10; i++) {
            // 异步发送 默认
            // kafkaProducer.send(newProducerRecord<>("test","kafka" + i));
            // 同步发送
            kafkaProducer.send(new
                    ProducerRecord<>("test", "kafka" + i)).get();
        }

生产者分区

分区好处

每个Partition在一个Broker上存储，可以把海量的数据按照分区切割成一块一块数据存储在多台Broker上。

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

IDEA 中 ctrl +n，全局查找 DefaultPartitioner，默认的分区器

如果在记录中指定了分区，请使用它

如果未指定分区，但存在密钥，请根据密钥的哈希值选择一个分区

如果没有分区或密钥，请选择批次已满时更改的粘性分区。有关粘性分区的详细信息，请参见KIP-480。

---

在IDEA中全局查找（ctrl +n）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会继续随机）。

例子

自定义分区器

需求
例如我们实现一个分区器实现，发送过来的数据中如果包含 aaa，就发往 0 号分区，
不包含 aaa，就发往 1 号分区。

实现步骤
（1）定义类实现 Partitioner 接口。 （2）重写 partition()方法

import org.apache.kafka.clients.producer.Partitioner;
import org.apache.kafka.common.Cluster;

import java.util.Map;

/**
 * 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) {
        // 获取消息
        String msgValue = value.toString();
        // 创建 partition
        int partition;
        // 判断消息是否包含 atguigu
        if (msgValue.contains("aaa")) {
            partition = 0;
        } else {
            partition = 1;
        }
        // 返回分区号
        return partition;
    }

    // 关闭资源
    @Override
    public void close() {
    }

    // 配置方法
    @Override
    public void configure(Map<String, ?> configs) {
    }
}

使用分区器的方法，在生产者的配置中添加分区器参数。

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

生产者如何提高吞吐量

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

// linger.ms：等待时间，默认 0
properties.put(ProducerConfig.LINGER_MS_CONFIG, 1);
// compression.type：压缩，默认 none，可配置值 gzip、snappy、lz4 和 zstd
properties.put(ProducerConfig.COMPRESSION_TYPE_CONFIG,"snappy");
// RecordAccumulator：缓冲区大小，默认 32M：buffer.memory
 properties.put(ProducerConfig.BUFFER_MEMORY_CONFIG,33554432);

数据可靠性

ACK应答级别

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)。
这样就不用等长期联系不上或者已经故障的节点。

数据完全可靠条件 = ACK级别设置为-1 + 分区副本大于等于2 + ISR里应答的最小副本数量大于等于2

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

数据传递语义

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

最多一次（At Most Once）= ACK级别设置为0

精确一次（Exactly Once）：对于一些非常重要的信息，比如和钱相关的数据，要求数据既不能重复也不丢失。

Kafka 0.11版本以后，引入了一项重大特性：幂等性和事务

数据去重

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

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

类似计网中的seq和ack的应答机制

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

使用幂等性

开启参数 enable.idempotence 默认为 true，false 关闭

生产者事务

说明：开启事务，必须开启幂等性。

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;

数据有序

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

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