kafka消费者

一、kafka消费方式

二、kafka消费者工作流程

2.1 消费者总体工作流程

2.2 消费者组原理

Consumer Group(CG):消费者组，由多个consumer组成。形成一个消费者组的条件，是所有消费者的groupid相同。

• 消费者组内每个消费者负责消费不同分区的数据，一个分区只能由一个组内消费者消费。
• 消费者组之间互不影响。所有的消费者都属于某个消费者组，即消费者组是逻辑上的一个订阅者。

消费者初始化流程：

1. 每个consumer都发送JoinGroup请求
2. 选出一个consumer作为leader
3. 把要消费的topic情况发送给leader消费者
4. leader会负责制定消费方案
5. leader把消费方案发送给coordinator
6. coordinator把消费方案发送给每个消费者
7. 每个消费者都会和coordinator保持心跳(默认3s)，一旦超时 (session.timeout.ms=45s)，该消费者会被移除，并触发再平衡; 或者消费者处理消息的时间过长(max.poll.interval.ms 5分钟)，也会触发再平衡

消费者组详细消费流程：

2.3 消费者重要参数

• bootstrap.servers：向 Kafka 集群建立初始连接用到的 host/port 列表。

• key.deserializer：指定接收消息的 key 的反序列化类型。一定要写全 类名。

• value.deserializer：指定接收消息的 value 的反序列化类型。一定要写全 类名。

• group.id：标记消费者所属的消费者组。

• enable.auto.commit：默认值为 true，消费者会自动周期性地向服务器提交偏移 量。

• auto.commit.interval.ms：如果设置了 enable.auto.commit 的值为 true， 则该值定义了 消费者偏移量向 Kafka 提交的频率，默认 5s。

• auto.offset.reset：当 Kafka 中没有初始偏移量或当前偏移量在服务器中不存在 (如，数据被删除了)，该如何处理?

  • earliest: 自动重置偏移量到最早的偏移量。
  • latest: 默认，自动重置偏移量为最新的偏移量。
  • none: 如果消费组原来的(previous)偏移量不存在，则向消费者抛异常。
  • anything: 向消费者抛异常。

• offsets.topic.num.partitions：__consumer_offsets 的分区数，默认是 50 个分区。

• heartbeat.interval.ms：Kafka 消费者和 coordinator 之间的心跳时间，默认 3s。 该条目的值必须小于 session.timeout.ms ，也不应该高于 session.timeout.ms 的 1/3。

• session.timeout.ms：Kafka 消费者和 coordinator 之间连接超时时间，默认 45s。 超过该值，该消费者被移除，消费者组执行再平衡。

• max.poll.interval.ms：消费者处理消息的最大时长，默认是 5 分钟。超过该值，该消费者被移除，消费者组执行再平衡。

• fetch.min.bytes：默认 1 个字节。消费者获取服务器端一批消息最小的字节 数。

• fetch.max.wait.ms：默认 500ms。如果没有从服务器端获取到一批数据的最小字节数。该时间到，仍然会返回数据。

• fetch.max.bytes：默认Default: 52428800(50 m)。消费者获取服务器端一批消息最大的字节数。如果服务器端一批次的数据大于该值 (50m)仍然可以拉取回来这批数据，因此，这不是一个绝对最大值。一批次的大小受 message.max.bytes (broker config) or max.message.bytes (topic config) 影响。

• max.poll.records：一次 poll 拉取数据返回消息的最大条数，默认是 500 条。

三、消费者API

3.1 独立消费者——订阅主题

注意: 在消费者 API 代码中必须配置消费者组 id。命令行启动消费者不填写消费者组 id 会被自动填写随机的消费者组 id。

@Test
public void consumerMessage() throws InterruptedException {
    Properties properties = new Properties();
    // 指定kafka集群地址
    properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    // 指定key、value的反序列化器
    properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    // 指定消费者组
    properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");

    KafkaConsumer<String, String> consumer = new KafkaConsumer<>(properties);

    // 订阅topic，可以订阅多个
    List<String> topics = new ArrayList<>();
    topics.add("test-topic-0");
    consumer.subscribe(topics);

    while (true) {
        // 从kafka集群中拉取数据
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
        if (records.isEmpty()) {
            TimeUnit.SECONDS.sleep(1);
        }
        for (ConsumerRecord<String, String> record : records) {
            log.info("[kafka-consumer]topic={}, message={}", record.topic(), record.value());
        }
    }
}

3.2 独立消费者——订阅分区

@Test
public void consumerMessage() throws InterruptedException {
    Properties properties = new Properties();
    // 指定kafka集群地址
    properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    // 指定key、value的反序列化器
    properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    // 指定消费者组
    properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");

    KafkaConsumer<String, String> consumer = new KafkaConsumer<>(properties);
    // 订阅分区
    List<TopicPartition> topicPartitionList = new ArrayList<>();
    TopicPartition topicPartition = new TopicPartition("test-topic", 0);
    topicPartitionList.add(topicPartition);
    consumer.assign(topicPartitionList);

    while (true) {
        // 从kafka集群中拉取数据
        ConsumerRecords<String, String> records = consumer.poll(Duration.ofSeconds(1));
        if (records.isEmpty()) {
            TimeUnit.SECONDS.sleep(1);
        }
        for (ConsumerRecord<String, String> record : records) {
            log.info("[kafka-consumer]topic={}, message={}", record.topic(), record.value());
        }
    }
}

3.3 消费者组

复制消费者代码，启动多个消费者，设置相同的group.id

四、分区的分配以及再平衡

• heartbeat.interval.ms：Kafka 消费者和 coordinator 之间的心跳时间，默认 3s。 该条目的值必须小于 session.timeout.ms，也不应该高于 session.timeout.ms 的 1/3。
• session.timeout.ms：Kafka 消费者和 coordinator 之间连接超时时间，默认 45s。超 过该值，该消费者被移除，消费者组执行再平衡。
• max.poll.interval.ms：消费者处理消息的最大时长，默认是 5 分钟。超过该值，该 消费者被移除，消费者组执行再平衡。
• partition.assignment.strategy：消费者分区分配策略，默认策略是 Range + CooperativeSticky。Kafka 可以同时使用多个分区分配策略。 可以选择的策略包括:Range、RoundRobin、Sticky、 CooperativeSticky

4.1 Range以及再平衡

Range分区策略原理

4.2 RoundRobin以及再平衡

4.3 Sticky以及再平衡

粘性分区定义: 可以理解为分配的结果带有“粘性的”。即在执行一次新的分配之前， 考虑上一次分配的结果，尽量少的调整分配的变动，可以节省大量的开销。

粘性分区是 Kafka 从 0.11.x 版本开始引入这种分配策略，首先会尽量均衡的放置分区 到消费者上面，在出现同一消费者组内消费者出现问题的时候，会尽量保持原有分配的分区不变化。

五、offset位移

5.1 offset的默认维护位置

__consumer_offsets 主题里面采用 key 和 value 的方式存储数据。key 是 group.id+topic+partition.no ，value 就是当前 offset 的值。每隔一段时间，kafka 内部会对这个 topic 进行 compact，也就是每个 group.id+topic+partition.no就保留最新数据。

5.2 自动提交offset

• enable.auto.commit：默认值为 true，消费者会自动周期性地向服务器提交偏移量。
• auto.commit.interval.ms：如果设置了 enable.auto.commit 的值为 true， 则该值定义了消 费者偏移量向 Kafka 提交的频率，默认 5s。

5.3 手动提交offset

由于同步提交 offset 有失败重试机制，故更加可靠，但是由于一直等待提交结果，提交的效率比较低。

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

5.4 指定offset消费

auto.offset.reset = earliest | latest | none 默认是 latest。

• earliest: 自动将偏移量重置为最早的偏移量，--from-beginning。
• latest(默认值): 自动将偏移量重置为最新偏移量。
• none: 如果未找到消费者组的先前偏移量，则向消费者抛出异常。

5.5 指定时间消费

@Test
public void consumerMessage() {
    Properties properties = new Properties();
    // 指定kafka集群地址
    properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "kafka-21:9092,kafka-22:9092");
    // 指定key、value的反序列化器
    properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
    // 指定消费者组
    properties.put(ConsumerConfig.GROUP_ID_CONFIG, "test-group");

    KafkaConsumer<String, String> consumer = new KafkaConsumer<>(properties);
    // 订阅topic
    consumer.subscribe(Collections.singletonList("test-topic"));
    Set<TopicPartition> partitionSet = new HashSet<>();
    while (partitionSet.size() == 0) {
        consumer.poll(Duration.ofSeconds(1));
        partitionSet = consumer.assignment();
    }
    Map<TopicPartition, Long> timestampToSearch = new HashMap<>();
    for (TopicPartition topicPartition : partitionSet) {
        timestampToSearch.put(topicPartition, System.currentTimeMillis() - 24 * 3600 * 1000);
    }
    Map<TopicPartition, OffsetAndTimestamp> offsets = consumer.offsetsForTimes(timestampToSearch);
    for (TopicPartition topicPartition : partitionSet) {
        OffsetAndTimestamp offsetAndTimestamp = offsets.get(topicPartition);
        if (offsetAndTimestamp != null) {
            consumer.seek(topicPartition, offsetAndTimestamp.offset());
        }
    }

    while (true) {
        ConsumerRecords<String, String> consumerRecords = consumer.poll(Duration.ofSeconds(1));
        for (ConsumerRecord<String, String> record : consumerRecords) {
            log.info("[kafka-consumer]topic={}, message={}", record.topic(), record.value());
        }
    }
}

5.6 漏消费和重复消费

• 重复消费: 已经消费了数据，但是 offset 没提交。

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

六、消费者事务

七、数据积压——消费者如何提高吞吐量

• fetch.max.bytes：默认Default: 52428800(50m)。消费者获取服务器端一批 消息最大的字节数。如果服务器端一批次的数据大于该值 (50m)仍然可以拉取回来这批数据，因此，这不是一个绝 对最大值。一批次的大小受 message.max.bytes (broker config)or max.message.bytes (topic config)影响。
• max.poll.records：一次 poll 拉取数据返回消息的最大条数，默认是 500 条