Kafka producer 生产者

producer 生产者消息发送流程

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

producer生产者常用参数列表

参数	描述
bootstrap.servers	生产者连接集群所需的 broker 地址列表，例如host5:9092,host6:9092,host7: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	`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

异步发送API

普通异步发送

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

代码编写

创建工程 kafka-demo

导入依赖

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

创建packagezone.cong.kafka.producer

编写无回调函数的 API 代码

package zone.cong.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;

/**
 * @author congqing
 */
public class CustomProducer {
    public static void main(String[] args) {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

        // 1.2 配置 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");
        // 2. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        // 3. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("hello", "hello world " + i));
        }
        // 4. 关闭资源
        kafkaProducer.close();
    }
}

开始测试

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行上面的 producer 代码，查看host5 控制台变化。

带有回调函数的异步发送

回调函数会在 producer 收到 ack 时调用，为异步调用，该方法有两个参数，分别是元数据信息（RecordMetadata）和异常信息（Exception），如果Exception 为 null，说明消息发送成功，如果 Exception 不为 null，说明消息发送失败。
注意：消息发送失败会自动重试，不需要我们在回调函数中手动重试。

package zone.cong.kafka.producer;

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

import java.util.Properties;
import java.util.concurrent.Callable;

/**
 * @author congqing
 */
public class CustomProducerCallback {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

        // 1.2 配置 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");
        // 2. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        // 3. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            // 编写回调函数
            Callback callback = (recordMetadata, e) -> {
                // 该方法在 Producer 收到 ack 时被调用，为异步调用
                if (e == null) {
                    // 没有异常,输出信息到控制台
                    System.out.println("topic->" + recordMetadata.topic() + ":::" + "partitions->" + recordMetadata.partition());
                } else {
                    // 输出异常堆栈信息
                    e.printStackTrace();
                }
            };

            kafkaProducer.send(new ProducerRecord<>("hello",
                    "hello callback " + i), callback);
            // 延迟一会会看到数据发往不同分区
            Thread.sleep(2);
        }
        // 4. 关闭资源
        kafkaProducer.close();
    }
}

开始测试

调整hello topic 的 partitions 为 3

kafka-topics.sh --bootstrap-server host5:9092 --alter --topic hello --partitions 3

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行上面的 producer 代码，查看host5 控制台变化。

同步发送API

只需在普通异步发送的基础上，调用 get()即可。

package zone.cong.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;
import java.util.concurrent.ExecutionException;

public class CustomProducerSync {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

        // 1.2 配置 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");
        // 2. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);

        // 3. 调用 send 方法,发送消息
        for (int i = 0; i < 20; i++) {
            // 同步发送
            kafkaProducer.send(new ProducerRecord<>("hello", "hello world " + i)).get();
        }
        // 4. 关闭资源
        kafkaProducer.close();
    }
}

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行上面的 producer 代码，查看host5 控制台变化。

producer partition分区

分区的好处

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

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

默认的分区器 DefaultPartitioner

在 IDEA 中 ctrl +n，全局查找 DefaultPartitioner。

/**
 * The default partitioning strategy:
 * <ul>
 * <li>If a partition is specified in the record, use it
 * <li>If no partition is specified but a key is present choose a partition based on a hash of the key
 * <li>If no partition or key is present choose the sticky partition that changes when the batch is full.
 * 
 * See KIP-480 for details about sticky partitioning.
 */

指明partition的情况下，直接将指明的值作为partition值；
例如partition=0，所有数据写入分区0

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

抽取工具类复用KafkaProducer

创建zone.cong.kafka.utils包

package zone.cong.kafka.utils;

import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.common.protocol.types.Field;

import java.util.Properties;

/**
 * 生产者工具类
 */
public class ProducerUtils {

    public static KafkaProducer<String, String> creatProducer() {
        return ProducerUtils.creatProducer("host5", "9092");
    }

    public static KafkaProducer<String, String> creatProducer(String hostname, String port) {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, hostname + ":" + port);

        // 1.2 配置 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");
        // 2. 创建 kafka 生产者对象
        return new KafkaProducer<>(properties);
    }
}

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

package zone.cong.kafka.producer;

import org.apache.kafka.clients.producer.*;
import zone.cong.kafka.utils.ProducerUtils;

import java.util.Properties;

public class CustomProducerCallbackPartitions {
    public static void main(String[] args) {
        KafkaProducer<String, String> kafkaProducer = ProducerUtils.creatProducer();
        for (int i = 0; i < 5; i++) {

            // 编写回调函数
            Callback callback = (recordMetadata, e) -> {
                // 该方法在 Producer 收到 ack 时被调用，为异步调用
                if (e == null) {
                    // 没有异常,输出信息到控制台
                    System.out.println("topic->" + recordMetadata.topic() + ":::" + "partitions->" + recordMetadata.partition());
                } else {
                    // 输出异常堆栈信息
                    e.printStackTrace();
                }
            };

            // 指定数据发送到 1 号分区，key 为空（IDEA 中 ctrl + p 查看参数）
            kafkaProducer.send(new ProducerRecord<>("hello", 2, "",
                    "hello callback " + i), callback);
        }
        kafkaProducer.close();
    }
}

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行以上代码

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

package zone.cong.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.clients.producer.RecordMetadata;
import zone.cong.kafka.utils.ProducerUtils;

import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class CustomProducerSyncDifferentKeys {
    public static void main(String[] args) throws ExecutionException, InterruptedException {
        KafkaProducer<String, String> kafkaProducer = ProducerUtils.creatProducer();
        // 3. 调用 send 方法,发送消息
        // 同步发送
        // 依次指定 key 值为 a,b,f ，数据 key 的 hash 值与 3 个分区求余，分别发往 1、2、0
        RecordMetadata recordMetadata;
        recordMetadata = kafkaProducer.send(new ProducerRecord<>("hello", "a", "hello a ")).get();
        System.out.println("topic->" + recordMetadata.topic() + ":::" + "partitions->" + recordMetadata.partition());
        recordMetadata = kafkaProducer.send(new ProducerRecord<>("hello", "b", "hello b ")).get();
        System.out.println("topic->" + recordMetadata.topic() + ":::" + "partitions->" + recordMetadata.partition());
        recordMetadata = kafkaProducer.send(new ProducerRecord<>("hello", "f", "hello f ")).get();
        System.out.println("topic->" + recordMetadata.topic() + ":::" + "partitions->" + recordMetadata.partition());
        // 4. 关闭资源
        kafkaProducer.close();
    }
}

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行以上代码

自定义分区器
如果研发人员可以根据企业需求，自己重新实现分区器。
需求
例如我们实现一个分区器实现，发送过来的数据中如果包含 cong，就发往 0 号分区，
不包含 cong，就发往 1 号分区。
2）实现步骤
（1）定义类实现 Partitioner 接口。
（2）重写 partition()方法

package zone.cong.kafka.producer;

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
     * @param keyBytes   消息的 key 序列化后的字节数组
     * @param 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();
        // 判断消息是否包含 cong
        if (msgValue.contains("cong")) {
            // 返回 partition
            return 0;
        }
        // 返回 partition
        return 1;
    }

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

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

package zone.cong.kafka.producer;

import org.apache.kafka.clients.producer.Callback;
import org.apache.kafka.clients.producer.KafkaProducer;
import org.apache.kafka.clients.producer.ProducerConfig;
import org.apache.kafka.clients.producer.ProducerRecord;
import zone.cong.kafka.utils.ProducerUtils;

import java.util.Properties;

public class CustomProducerCallbackByMyPartitioner {
   public static void main(String[] args) {
       // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
       Properties properties = new Properties();
       // 1.1 配置服务地址
       properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

       // 1.2 配置 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");
       // 2. 创建 kafka 生产者对象
       // 添加自定义分区器
       properties.put(ProducerConfig.PARTITIONER_CLASS_CONFIG, "zone.cong.kafka.producer.MyPartitioner");
       KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
       // 3. 调用 send 方法,发送消息

       // 编写回调函数
       Callback callback = (recordMetadata, e) -> {
           // 该方法在 Producer 收到 ack 时被调用，为异步调用
           if (e == null) {
               // 没有异常,输出信息到控制台
               System.out.println("topic->" + recordMetadata.topic() + ":::" + "partitions->" + recordMetadata.partition());
           } else {
               // 输出异常堆栈信息
               e.printStackTrace();
           }
       };

       kafkaProducer.send(new ProducerRecord<>("hello", "cong"), callback);
       kafkaProducer.send(new ProducerRecord<>("hello", "hello MyPartitioner "), callback);

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

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行以上代码

挺高生产者吞吐量

一般生产环境配置

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

package zone.cong.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 CustomProducerParameters {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

        // 1.2 配置 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");
        // 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");
        // 2. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        // 3. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("hello", "hello CustomProducerParameters" + i));
        }
        // 4. 关闭资源
        kafkaProducer.close();
    }
}

在 host5机器上开启一个 Kafka consumer。

kafka-console-consumer.sh --bootstrap-server host5:9092 --topic hello

执行以上代码

数据可靠性

ACK应答级别

0生产者发送过来的数据，不需要等数据落盘应答
数据可靠性：丢数

1生产者发送过来的数据，Leader收到数据后应答。
数据可靠性：丢数

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

Leader收到数据后，所有的Follower开始同步数据，此时有一个Follower，因为某种故障，不能与Leader进行同步，会不会因此影响ack呢!

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，一般用于传输重要数据，应用在对可靠性要求比较高的场景。

代码测试

package zone.cong.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 CustomProducerAck {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

        // 1.2 配置 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");
        // 设置 acks
        properties.put(ProducerConfig.ACKS_CONFIG, "all");
        // 重试次数 retries，默认是 int 最大值，2147483647
        properties.put(ProducerConfig.RETRIES_CONFIG, 3);
        // 2. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new
                KafkaProducer<String, String>(properties);
        // 3. 调用 send 方法,发送消息
        for (int i = 0; i < 5; i++) {
            kafkaProducer.send(new ProducerRecord<>("hello", "hello ack " + i));
        }
        // 45. 关闭资源
        kafkaProducer.close();
    }
}

数据去重

数据传递语义

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

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

总结：

At Least Once可以保证数据不丢失，但是不能保证数据不重复；

At Most Once可以保证数据不重复，但是不能保证数据不丢失。

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

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，即使客户端挂掉了，它重启后也能继续处理未完成的事务

Kafka 的事务的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 zone.cong.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 CustomProducerTransactions {
    public static void main(String[] args) throws InterruptedException {
        // 1. 创建 kafka 生产者的配置对象 ，并注入配置信息
        Properties properties = new Properties();
        // 1.1 配置服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "host5:9092");

        // 1.2 配置 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");
        // 设置事务 id（必须），事务 id 任意起名
        properties.put(ProducerConfig.TRANSACTIONAL_ID_CONFIG,
                "transaction_id_0");
        // 3. 创建 kafka 生产者对象
        KafkaProducer<String, String> kafkaProducer = new KafkaProducer<>(properties);
        // 初始化事务
        kafkaProducer.initTransactions();
        // 开启事务
        kafkaProducer.beginTransaction();
        try {
            // 4. 调用 send 方法,发送消息
            for (int i = 0; i < 5; i++) {
                // 发送消息
                kafkaProducer.send(new ProducerRecord<>("hello", "hello Transaction" + i));
            }
            // int i = 1 / 0;
            // 提交事务
            kafkaProducer.commitTransaction();
        } catch (Exception e) {
            // 终止事务
            kafkaProducer.abortTransaction();
        } finally {
            // 5. 关闭资源
            kafkaProducer.close();
        }
    }
}

数据有序

单分区内，有序（需要一定条件，后面接受）
多分区，分区与分区间无序

数据乱序

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

小丛的知识窝

【Kafka】kafka producer

Kafka producer 生产者

producer 生产者消息发送流程

producer生产者常用参数列表

异步发送API

普通异步发送

代码编写

开始测试

带有回调函数的异步发送

开始测试

同步发送API

producer partition分区

分区的好处

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

默认的分区器 DefaultPartitioner

抽取工具类复用KafkaProducer

挺高生产者吞吐量

数据可靠性

ACK应答级别

可靠性总结

代码测试

数据去重

数据传递语义

幂等性

幂等性原理

如何使用幂等性

生产者事务

Kafka 事务原理

Kafka 的事务的API

单个 Producer，使用事务保证消息的仅一次发送

数据有序

数据乱序

kafka在1.x版本之前保证数据单分区有序

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

评论区