Kafka生产者和消费者API详解

我正在参加「掘金·启航计划」

前言

• 本次运行的Kafka版本是2.8.0单机版；

• 在运行之前先要检查防火墙是否关闭，或者是否开启9092端口

查看防火墙状态命令

firewall-cmd --state

关闭防火墙命令

systemctl stop firewalld.service

PS:别问我为什么要强调这一点。

生产者API

一、消息发送流程

Kafka 的 Producer 发送消息采用的是异步发送的方式。

在消息发送的过程中，涉及到了两个线程——main线程和 Sender线程，以及一个线程共享变量——RecordAccumulator。

main 线程将消息发送给 RecordAccumulator，Sender 线程不断从 RecordAccumulator 中拉取消息发送到 Kafka broker。

main线程说明

• 消息通过main线程发送的时候会先经过 interceptors(拦截器)过滤掉一些不要的数据；
• 通过拦截器过滤以后在进行序列化操作，方便进行网络传输；
• 消息会进一步通过partitioner 来确定这个消息要放哪个partition里面，然后按照分区放到RecordAccumulator 容器里面；
• 在进入到RecordAccumulator容器之前消息就已经确定好了要去哪个分区。

Sender守护线程就负责从RecordAccumulator容器里面拉取数据,往对应的Topic的partition里面拷贝。

相关参数

• batch.size：只有数据积累到 batch.size 之后，sender 才会发送数据。
• linger.ms：如果数据迟迟未达到 batch.size，sender 等待 linger.time 之后就会发送数据。

二、生产者API操作基本步骤

2.1 引入Java依赖包

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

本次引入的是2.8.0版本对应的依赖包，可以根据自身Kafka版本进行修改为对应的依赖包。

2.2 创建生产者对象

• 使用KafkaProducer 创建kafka生产者对象，这时可以发现kafka不允许我们使用空构造来创建对象;
• 选用传入properties的方式创建kafka生产者
• 创建生产者的时候，跟控制台命令一样，我们需要指定集群名称以及序列化器,而这些相关设置都会存储在我们的配置文件中；
• kafka给我们提供了ProducerConfig类，并在其中已经给我们提前准备好了我们所需要的key，在向properties中put键值时，可以直接使用producerConfig的静态常量作为key；并传入相应value

2.3 向Kafka中发送信息

• 使用kafkaProducer向kafka中发送信息，可以使用其提供的**send()**方法 ；
• 使用时可以看到其需要传入ProducerRecord以及一个可选的Callback；

注：

ProducerRecord: 即为每条数据所封装成的对象；

CallBack：可选；获取函数的回调

2.4 close()

在真实生产环境中，我们可能不需要手动调用close方法关闭kafkaProducer,但是目前的测试阶段，如果不使用close关闭，可能会导致发送的信息在设置等待的时间内，不会被真正的发送；

流在关闭的时候会对数据进行回收操作

三、异步发送API

需要用到的类：

• KafkaProducer：需要创建一个生产者对象，用来发送数据
• ProducerConfig：获取所需的一系列配置参数
• ProducerRecord：每条数据都要封装成一个 ProducerRecord 对象

3.1 不带回调函数的API

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

import java.util.Properties;

/**
 * @author lilinchao
 * @date 2021/10/13
 * @description 不带回调函数的API
 **/
public class CustomProducer {
    public static void main(String[] args){

        Properties props = new Properties();
        //Kafka服务端的主机名（或IP）和端口号
        props.put("bootstrap.servers", "192.168.159.135:9092");
        //等待所有副本节点的应答
        props.put("acks", "all");
        //消息发送最大尝试次数
        props.put("retries", 0);
        //一批消息处理大小
        props.put("batch.size", 16384);
        //请求延时
        props.put("linger.ms", 1);
        //发送缓存区内存大小
        props.put("buffer.memory", 33554432);
        //key序列化
        props.put("key.serializer", "org.apache.kafka.common.serialization.StringSerializer");
        //value序列化
        props.put("value.serializer", "org.apache.kafka.common.serialization.StringSerializer");

        Producer<String,String> producer = new KafkaProducer<String, String>(props);
        for (int i = 0;i < 10;i++){
            producer.send(new ProducerRecord<String, String>("kafkaDemo", Integer.toString(i), "Producer-" + i));
            System.out.println("发送:"+i);
        }

        producer.close();
    }
}

在Kafka服务端开启消费者命令

[root@hadoopserver kafka_2.12-2.8.0]# bin/kafka-console-consumer.sh --bootstrap-server 192.168.159.135:9092 --topic kafkaDemo

运行结果

3.2 带回调函数的API

回调函数会在 producer 收到 ack 时调用，为异步调用。

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

import java.util.Properties;

/**
 * @author lilinchao
 * @date 2021/10/14
 * @description 带回调函数API
 **/
public class CallBackCustomProducer {
    public static void main(String[] args){

        Properties props = new Properties();
        //Kafka服务端的主机名和端口号
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.159.135:9092");
        //等待所有副本节点的应答
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        //消息发送最大尝试次数
        props.put(ProducerConfig.RETRIES_CONFIG, 0);
        //一批消息处理大小
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        //请求延时
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        //发送缓存区内存大小
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
        //key序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //value序列化
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        Producer<String,String> producer = new KafkaProducer<String, String>(props);
        for (int i = 0;i < 10;i++){
            producer.send(new ProducerRecord<String, String>("kafkaDemo", Integer.toString(i), "Producer-" + i),new Callback() {
                public void onCompletion(RecordMetadata metadata, Exception exception) {
                    if (exception == null) {
                        System.err.println(metadata.partition() + "---" + metadata.offset());
                    }else{
                        exception.printStackTrace();
                    }
                }
            });
        }
        producer.close();
    }
}

运行结果

Callback方法有两个参数：

• RecordMetadata：回调函数返回信息
• Exception：为null,说明消息发送成功，不为null,说明消息发送失败。

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

四、同步发送API

同步发送的意思就是，一条消息发送之后，会阻塞当前线程，直至返回 ack。

由于send方法返回的是一个Future对象，根据Future对象的特点，我们也可以实现同步发送的效果，只需在调用Future对象的get方发即可。

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

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

/**
 * @author lilinchao
 * @date 2021/10/14
 * @description 同步发送API
 **/
public class CustomProducer {
    public static void main(String[] args) throws ExecutionException, InterruptedException {

        Properties props = new Properties();
        //Kafka服务端的主机名和端口号
        props.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.159.135:9092");
        //等待所有副本节点的应答
        props.put(ProducerConfig.ACKS_CONFIG, "all");
        //消息发送最大尝试次数
        props.put(ProducerConfig.RETRIES_CONFIG, 0);
        //一批消息处理大小
        props.put(ProducerConfig.BATCH_SIZE_CONFIG, 16384);
        //请求延时
        props.put(ProducerConfig.LINGER_MS_CONFIG, 1);
        //发送缓存区内存大小
        props.put(ProducerConfig.BUFFER_MEMORY_CONFIG, 33554432);
        //key序列化
        props.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        //value序列化
        props.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        Producer<String,String> producer = new KafkaProducer<String, String>(props);
        for (int i = 0;i < 10;i++){
            producer.send(new ProducerRecord<String, String>("kafkaDemo", Integer.toString(i), "Producer-" + i)).get();
            System.out.println("发送:"+i);
        }

        producer.close();
    }
}

通过服务端消费者命令查看消费结果

Producer-0
Producer-1
Producer-2
Producer-3
Producer-4
Producer-5
Producer-6
Producer-7
Producer-8
Producer-9

Kafka消费者API

Consumer 消费数据时的可靠性是很容易保证的，因为数据在 Kafka 中是持久化的，故不用担心数据丢失问题。

由于consumer在消费过程中可能会出现断电宕机等故障，consumer恢复后，需要从故障前的位置的继续消费，所以consumer需要实时记录自己消费到了哪个offset，以便故障恢复后继续消费。

所以 offset 的维护是 Consumer 消费数据是必须考虑的问题。

导入依赖

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

五、自动提交offset

import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

/**
 * @author lilinchao
 * @date 2021/10/15
 * @description 自动提交offset
 **/
public class CustomConsumer {

    public static void main(String[] args){
        Properties props = new Properties();
        //连接信息
        props.put("bootstrap.servers","192.168.159.135:9092");
        //消费者组ID
        props.put("group.id","test");
        //是否自动提交offset（消费偏移量）
        props.put("enable.auto.commit","true");
        //自动提交时间间隔
        props.put("auto.commit.interval.ms", "1000");
        //Key反序列化
        props.put("key.deserializer","org.apache.kafka.common.serialization.StringDeserializer");
       //Value反序列化
        props.put("value.deserializer","org.apache.kafka.common.serialization.StringDeserializer");

        //创建消费者对象
        KafkaConsumer<String,String> consumer = new KafkaConsumer<String,String>(props);
        //订阅主题（可以订阅多个）
        consumer.subscribe(Arrays.asList("first","kafkaDemo"));
        while (true){
            //获取数据
            ConsumerRecords<String,String> records = consumer.poll(100);
            //解析数据
            for(ConsumerRecord<String,String> record:records){
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
        }
    }
}

先运行消费者，在运行生产者生产数据。

运行结果

说明

• KafkaConsumer：需要创建一个消费者对象，用来消费数据

• ConsuemrRecord：每条数据都要封装成一个 ConsumerRecord 对象，为了使我们能够专注于自己的业务逻辑，Kafka 提供了自动提交offset 的功能。

自动提交 offset 的相关参数：

enable.auto.commit：是否开启自动提交 offset 功能

auto.commit.interval.ms：自动提交 offset 的时间间隔

六、手动提交offset

6.1 概述

​ 虽然自动提交offset十分简介便利，但由于其是基于时间提交的，开发人员难以把握 offset 提交的时机。因此Kafka还提供了手动提交offset的 API。

手动提交offset的方法有两种：

• commitSync（同步提交）
• commitAsync（异步提交）

两种方式的异同

相同点：

都会将本次poll 的一批数据最高的偏移量提交

不同点：

• commitSync 阻塞当前线程，一直到提交成功，并且会自动失败重试（由不可控因素导致， 也会出现提交失败）；

• commitAsync 则没有失败重试机制，故有可能提交失败。

6.2 同步提交offset

由于同步提交offset有失败重试机制，故更加可靠。

代码示例

import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.KafkaConsumer;

import java.util.Arrays;
import java.util.Properties;

/**
 * @author lilinchao
 * @date 2021/10/15
 * @description 同步提交 offset
 **/
public class CommitSyncConsumer {
    public static void main(String[] args){
        Properties props = new Properties();
        //连接信息
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.159.135:9092");
        //消费者组ID
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //关闭自动提交offset
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //Key反序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        //Value反序列化
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");

        //创建消费者对象
        KafkaConsumer<String,String> consumer = new KafkaConsumer<String,String>(props);
        //订阅主题（可以订阅多个）
        consumer.subscribe(Arrays.asList("first","kafkaDemo"));
        while (true){
            //获取数据
            ConsumerRecords<String,String> records = consumer.poll(100);
            //解析数据
            for(ConsumerRecord<String,String> record:records){
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
            //同步提交，当前线程会阻塞直到 offset 提交成功
            consumer.commitSync();
        }
    }
}

运行结果

6.3 异步提交offset

虽然同步提交 offset 更可靠一些，但是由于其会阻塞当前线程，直到提交成功。因此吞 吐量会收到很大的影响。因此更多的情况下，会选用异步提交 offset 的方式。

代码示例

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;

import java.util.Arrays;
import java.util.Map;
import java.util.Properties;

/**
 * @author lilinchao
 * @date 2021/10/15
 * @description 异步提交offset
 **/
public class CommitAsyncConsumer {
    public static void main(String[] args){
        Properties props = new Properties();
        //连接信息
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.159.135:9092");
        //消费者组ID
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //关闭自动提交offset
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //Key反序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        //Value反序列化
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        //重置offset
        //earliest：从头开始消费，触发的条件1，换组；条件2：保留的offset指向的数据已经不存在
        //latest：默认值，消费最新的数据。
        props.put(ConsumerConfig.AUTO_OFFSET_RESET_CONFIG,"earliest");

        //创建消费者对象
        KafkaConsumer<String,String> consumer = new KafkaConsumer<String,String>(props);
        //订阅主题（可以订阅多个）
        consumer.subscribe(Arrays.asList("first","kafkaDemo"));
        while (true){
            //消费者拉取数据（每隔0.1秒拉取一次）
            ConsumerRecords<String,String> records = consumer.poll(100);
            //解析数据
            for(ConsumerRecord<String,String> record:records){
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
            }
            //异步提交
            consumer.commitAsync(new OffsetCommitCallback() {
                public void onComplete(Map<TopicPartition,OffsetAndMetadata> offsets, Exception exception) {
                    if (exception != null) {
                        System.err.println("Commit failed for" + offsets);
                    }
                }
            });
        }
    }
}

运行结果

6.4 数据漏消费和重复消费分析

无论是同步提交还是异步提交offset，都有可能会造成数据的漏消费或者重复消费。

• 先提交offset后消费，有可能造成数据的漏消费；

• 而先消费后提交offset，有可能会造成数据的重复消费。

七、自定义存储offset

7.1 概述

Kafka 0.9 版本之前，offset存储在 zookeeper，0.9 版本及之后，默认将 offset 存储在 Kafka 的一个内置的 topic 中。除此之外，Kafka 还可以选择自定义存储offset。

offset 的维护是相当繁琐的，因为需要考虑到消费者的 Rebalace。

当有新的消费者加入消费者组、已有的消费者推出消费者组或者所订阅的主题的分区发生变化，就会触发到分区的重新分配，重新分配的过程叫做 Rebalance。

消费者发生 Rebalance 之后，每个消费者消费的分区就会发生变化。因此消费者要首先获取到自己被重新分配到的分区，并且定位到每个分区最近提交的 offset 位置继续消费。

7.2 实现

要实现自定义存储 offset，需要借助 ConsumerRebalanceListener，以下为示例代码，其中提交和获取 offset 的方法，需要根据所选的 offset 存储系统自行实现。

import org.apache.kafka.clients.consumer.*;
import org.apache.kafka.common.TopicPartition;

import java.util.*;

/**
 * @author lilinchao
 * @date 2021/10/15
 * @description 自定义存储Offset
 **/
public class CustomizeOffset {
    private static Map<TopicPartition, Long> currentOffset = new HashMap<TopicPartition, Long>();

    public static void main(String[] args) {
        Properties props = new Properties();
        //连接信息
        props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"192.168.159.135:9092");
        //消费者组，只要 group.id 相同，就属于同一个消费者组
        props.put(ConsumerConfig.GROUP_ID_CONFIG,"test");
        //关闭自动提交offset
        props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG,"false");
        //Key反序列化
        props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");
        //Value反序列化
        props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,"org.apache.kafka.common.serialization.StringDeserializer");

        //创建一个消费者
        final KafkaConsumer<String, String> consumer = new KafkaConsumer<String, String>(props);
        //消费者订阅主题
        consumer.subscribe(Arrays.asList("first","kafkaDemo"), new ConsumerRebalanceListener() {
            //该方法会在 Rebalance 之前调用
            public void onPartitionsRevoked(Collection<TopicPartition> partitions) {
                commitOffset(currentOffset);
            }
            //该方法会在 Rebalance 之后调用
            public void onPartitionsAssigned(Collection<TopicPartition> partitions) {
                currentOffset.clear();
                for (TopicPartition partition : partitions) {
                    consumer.seek(partition, getOffset(partition));//定位到最近提交的 offset 位置继续消费
                }
            }
        });
        while (true) {
            //消费者拉取数据
            ConsumerRecords<String, String> records = consumer.poll(100);
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("offset = %d, key = %s, value = %s%n", record.offset(), record.key(), record.value());
                currentOffset.put(new TopicPartition(record.topic(),
                        record.partition()), record.offset());
            }
            //异步提交
            commitOffset(currentOffset);
        }
    }

    /**
     * 获取某分区的最新 offset
     * @param partition
     * @return
     */
    private static long getOffset(TopicPartition partition) {
        return 0;
    }

    /**
     * 提交该消费者所有分区的 offset
     * @param currentOffset
     */
    private static void commitOffset(Map<TopicPartition, Long> currentOffset) {
    }
}

运行结果