• kafka操作3

    kafka消费方式

    1. pull（拉）模式：consumer采用从broker中主动拉取数据。kafka采用这种方式。pull模式的不足之处是，如果kafka没有数据，消费者可能会陷入循环中，一直返回空数据。
    2. push（推）模式：kafka没有采用这种方式，因为由broker决定消息发送速率，很难适应所有消费者的消费速率。例如推送的速度为50m/s，低于这个处理速度的consumer就来不及处理消息。

    kafka消费者总体工作流程

    一个消费者可以消费多个分区数据。
    每个分区的数据只能由消费者组中的一个消费者消费。
    每个消费者的offset由消费者提交到系统主题保存。

    消费者组

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

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

    消费者组初始化流程

    1. coordinator：辅助实现消费者组的初始化和分区的分配。coordinator节点选择 = groupid的hashcode值 % 50 (__consumer_offsets的分区数量)，例如：groupid的hashcode值 = 1,1%50 = 1，那么__consumer_offsets主题的1号分区，在哪个broker上，就选择这个节点的coordinator作为这个消费者组的老大。消费者组下的所有的消费者提交offset的时候就往这个分区去提交offset。
    - 每个consumer都发送joinGrounp请求
- 选出一个consumer作为leader
- 把要消费的topic情况发送给leader消费者
- leader会负责制定消费方案
- 把消费方案发给coordinator
- coordinator就把消费方案发给各个consumer
- 每个消费者都会和coordinator保持心跳（默认3s） ，一旦超时（session.timeout.ms=45s），该消费者会被移除，并触发再平衡；或者消费者处理消息的时间过长（max.poll.interval.ms=5分钟），也会触发再平衡

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    消费者组详细消费流程

    consumer
Fech.min.bytes每批次最小抓取大小，默认为1字节
Fetch.max.wait.ms一批数据最小值未达到的超时时间，默认为500ms
Fetch.max.bytes每批次最大抓取大小，默认为50m
Max.poll.records一次拉取数据返回消息的最大条数，默认为500条

    • 1
    • 2
    • 3
    • 4
    • 5

    独立消费者案例（订阅主题）

    1. 需求：创建一个独立消费者，消费first主题中数据。注意：在消费者API代码中必须配置消费者组id。命令行 启动消费者不填写消费者组id会被自动填写随机的消费者组id。
    2. 实现步骤：首先创建com.thenema.kafka.consumer一个包，在其下面实现java代码
      消费某个主题的数据
    package com.thenema.kafka.consumer;

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 org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;

/**
 * @author 29467
 * @date 2022/10/17 21:44
 */
public class CustomConsumer {
    public static void main(String[] args) {
        // 0 配置
        Properties properties = new Properties();

        // 连接kafka集群
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop103:9092");
        // 反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        // 配置消费者组id
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"testGroup");

        // 1 创建一个消费者
        KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer<>(properties);
        // 2 定义主题first
        ArrayList<String> topics = new ArrayList<>();
        topics.add("first");
        kafkaConsumer.subscribe(topics);

        // 3 消费数据
        while(true){
            ConsumerRecords<String,String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));

            for(ConsumerRecord consumerRecord:consumerRecords){
                System.out.println(consumerRecord);
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46

    消费某个分区的数据

    package com.thenema.kafka.consumer;

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 org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;

/**
 * @author 29467
 * @date 2022/10/17 21:44
 */
public class CustomConsumer {
    public static void main(String[] args) {
        // 0 配置
        Properties properties = new Properties();

        // 连接kafka集群
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop103:9092");
        // 反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        // 配置消费者组id
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"testGroup");

        // 1 创建一个消费者
        KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer<>(properties);
        // 2 定义主题first
        ArrayList<TopicPartition> topicPartitions = new ArrayList<>();
        topicPartitions.add(new TopicPartition("first",0));
        kafkaConsumer.assign(topicPartitions);

        // 3 消费数据
        while(true){
            ConsumerRecords<String,String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));

            for(ConsumerRecord consumerRecord:consumerRecords){
                System.out.println(consumerRecord);
            }
        }
    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47

    消费者组案例

    1. 需求：测试同一个主题的分区数据，只能由一个消费者组中的一个消费。
    2. 案例实操：复制一份基础消费者的代码，在idea里同时启动，即可开启同一个消费者组中的两个消费者

    分区的分配以及再平衡

    1. 一个consumer group中有多个consumer组成，一个topic有多个partition组成，现在的问题是，到底由哪个consumer来消费哪个partition的数据。
    2. Kafka有四种主流的分区分配策略：Range、RoundRobin、Sticky、CooperativeSticky。可以通过配置参数partition.assignment.strategy，修改分区的分配策略。默认策略是Range + CooperativeSticky。Kafka可以同时使用多个分区分配策略。
    - 每个consumer都发送JoinGroup请求
- 选出一个consumer作为leader
- 把要消费的topic情况发送给leader消费者
- leader会负责制定消费方案
- 把消费方案发送给coordinator
- coordinator就把消费方案下发给各个consumer
-  每个消费者都会和coordinator保持心跳（默认3s） ，一旦超时（session.timeout.ms=45s），该消费者会被移除，并触发再平衡；或者消费者处理消息的时间过长（max.poll.interval.ms=5分钟），也会触发再平衡

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    在这里插入图片描述

    分区分配策略之Range

    1. Range是对每个topic而言的。首先对同一个topic里面的分区按照序号进行排序，并对消费者按照字母顺序进行排序。假如现在有7个分区，3个消费者，排序后的分区是0,1,2,3,4,5,6；消费者排序完之后将会是C0,C1,C2。通过partitions数/consumer数来决定每个消费者应该消费几个分区。如果除不尽，那么前面几个消费者将会多消费1个分区。partition过多时，容易产生数据倾斜。
    2. Range分区分配策略案例
    - 修改主题first为7个分区
bin/kafka-topics.sh --bootstrap-serverhadoop102:9092 --alter --topic first --partitions 7
分区数可以增加，但是不能减少
- 复制CustomConsumer类，创建CustomConsumer2，这样可以由三个消费者CustomConsumer、CustomConsumer1、CustomConsumer2组成消费者组，组名为“test”，同时启动三个消费者
- 启动CustomProducer生产者，发送300条消息，随机发送到不同的分区
- 结果为一个CustomConsumer消费0,1,2分区，另一个CustomConsumer消费3,4分区，最后一个消费5,6分区，如果一个CustomConsumer挂掉之后，其中一个CustomConsumer消费0,1,2,3分区，另外一个消费4,5,6分区

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6

    分区分配策略之RoundRobin

    1. RoundRobin针对集群中所有Topic而言。RoundRobin轮询分区策略，是把所有的partition和所有的consumer都列出来，然后按照hashcode进行排序，最后通过轮询算法来分配partition给到各个消费者。
    2. 依次在CustomConsumer、CustomConsumer1、CustomConsumer2三个消费者代码中修改分区分配策略为RoundRobin。
    properties.put (ConsumerConfig. PARTITION _ASSIGNMENT_ STRATEGY_CONFIG, "org.apache.kafka.clients.consumer.RoundRobinAssignor");

    • 1
    1. 重启三个消费者，重复发送消息的步骤，观看分区结果。
    2. 结果为CustomConsumer消费0,3,6，CustomConsumer消费1,4，CustomConsumer消费2,5
    3. 挂掉一个后，其中一个CustomConsumer消费0,1,4,6，另外一个消费3,2,5。
    4. 重启后，其中一个CustomConsumer消费0,2,4,6，另外一个消费1,3,5。

    Sticky以及再平衡

    粘性分区定义：可以理解为分配结果带有“粘性的”。即在执行一次新的分配之前，考虑上一次分配的结果，尽量少的调整分配的变动，可以节省大量的开销。
    粘性分区是kafka从0.11.x版本开始引入这种分配策略，首先会尽量均衡的放置分区到消费者上面，在出现同一消费者组内消费者出现问题的时候，会尽量保持原有分配的分区不变化。

    1. 需求：设置主题为first，7个分区；准备三个消费者，采用粘性分区策略，并进行消费，观察消费分配情况。然后在停止其中一个消费者，再次观察消费分配情况。
    2. 步骤
    - 修改分区分配策略为粘性。注意：3个消费者都应该注释掉，之后重启3个消费者，如果出现报错，全部停止等会再重启，或者修改为全新的消费者组。
ArrayList startegys = new ArrayList<>();
startegys.add("org.apache.kafka.clients.consumer.Stickyassignor");
pproperties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG,startegys);
- 使用同样的生产者发送500条消息。可以看到会尽量保持分区的个数近似划分分区。

    • 1
    • 2
    • 3
    • 4
    • 5

    offset的默认维护位置

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

    1. 思想：__consumer_offsets为kafka中的topic，那就可以通过消费者进行消费
    2. 在配置文件config/consumer.properties中添加配置exclude.internal.topics=false，默认是true，表示不能消费系统主题。为了查看该系统的主题数据，所以该参数修改为false。
    3. 采用命令行方式，创建一个新的topic
    bin/kafka-topics.sh --bootstrap-server hadoop101:9092 --create --topic thenema --partitions 2 replication-factor 2

    • 1
    1. 启动生产者，往thenema生产数据
    bin/kafka-console-producer.sh --topic thenema --bootstrap-server hadoop101:9092

    • 1
    1. 确定消费者消费thenema数据
    bin/kafka-console-consumer.sh --bootstarp-server hadoop101:9092 --topic thenema --group test
注意：指定消费者组名称，更好的观察数据存储位置（key是group.id+topic+分区号）

    • 1
    • 2
    1. 查看消费者消费主题__consumer_offsets

    自动提交offset

    为了使我们能够专注于自己的业务逻辑，kafka提供了自动提交offset的功能。自动提交offset的相关参数。

    • enable.auto.commit：是否开启自动提交offset功能，默认为true
    • auto.commit.interval.ms：自动提交offset的时间间隔，默认是5s

    手动提交offset

    虽然自动提交offset十分简单便利，但由于其是基于时间提交的，开发人员难以把握offset提交的时机，因此kafka还提供了手动提交offset的api。
    手动提交offset的方法有两种：分别是commitSync（同步提交）和commitAsync（异步提交）。两者的相同点是，都会将本次提交的偏移量提交；不通电是，同步提交阻塞当前线程，一直到提交成功，并且会自动失败重试（由不可控因素导致，也会出现提交失败）；而异步提交则没有失败重试机制，故有可能提交失败。

    • commitSync（同步提交）：必须等待offset提交完毕，再去消费下一批数据
    • commitAsync（异步提交）：发送完提交offset请求后，就开始消费下一批数据了
    1. 同步提交offset，由于同步提交offset有失败重试机制，故更加可靠，但是由于一直等待提交结果，提交的效率比较低。以下为同步提交offset的示例。
    // 同步提交	
kafkaConsumer.commitSync();
// 异步提交
kafkaConsumer.commitAsync()

    • 1
    • 2
    • 3
    • 4

    指定offset消费

    auto.offset.reset = earliest | latest | none 默认为latest
    当kafka中没有初始偏移量（消费者组第一次消费）或服务器上不再存在当前偏移量时（例如该数据已被删除），该怎么办

    1. earlier：自动将偏移量重置为最早的偏移量，–from-beginning。
    2. latest（默认值）：自动将偏移量重置为最新偏移量。
    3. none：如果未找到消费者组的先前偏移量，则向消费者抛出异常。
    4. 任意指定offset位移开始消费
      参考java代码
    package com.thenema.kafka.consumer;

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 org.apache.kafka.common.TopicPartition;
import org.apache.kafka.common.serialization.StringDeserializer;

import java.time.Duration;
import java.util.ArrayList;
import java.util.Properties;
import java.util.Set;

/**
 * @author 29467
 * @date 2022/10/18 17:47
 */
public class CustomConsumerSeek {
    public static void main(String[] args) {
        // 配置信息
        Properties properties = new Properties();

        // 连接kafka集群
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG,"hadoop101:9092,hadoop103:9092");
        // 反序列化
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, StringDeserializer.class.getName());
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,StringDeserializer.class.getName());
        // 组id
        properties.put(ConsumerConfig.GROUP_ID_CONFIG,"test2");
        // 创建消费者
        KafkaConsumer<String,String> kafkaConsumer = new KafkaConsumer<>(properties);
        // 订阅主题
        ArrayList<String> topics = new ArrayList<>();
        topics.add("first");
        kafkaConsumer.subscribe(topics);

        // 指定位置进行消费
        Set<TopicPartition> assignment = kafkaConsumer.assignment();

        // 保证分区分配方案已经制定完毕
        while(assignment.size()==0){
            kafkaConsumer.poll(Duration.ofSeconds(1));
            assignment = kafkaConsumer.assignment();
        }

        //指定消费的offset
        for(TopicPartition topicPartition:assignment){
            kafkaConsumer.seek(topicPartition,100);
        }

        // 消费数据
        while(true){
            ConsumerRecords<String,String> consumerRecords = kafkaConsumer.poll(Duration.ofSeconds(1));
            for(ConsumerRecord consumerRecord : consumerRecords){
                System.out.println(consumerRecord);
            }
        }

    }
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61

    指定时间消费

    需求：在生产环境中，会遇到最近消费的几个小时数据异常，想重新按照时间消费。例如要求按照时间消费前一天的数据，怎么处理？

    // 希望把时间转换为对应的offset
HashMap<TopicPartition, Long> topicPartitionLongHashMap = new HashMap<>();
// 封装对应集合
for(TopicPartition topicPartition : assignment){
	topicPartitionLongHashMap.put(topicPartition,System.currentTimeMillis() - 1 * 24 * 3600 * 1000);
}
Map<TopicPartition, OffsetAndTimestamp> topicPartitionOffsetAndTimestampMap = kafkaConsumer.offsetsForTimes(topicPartitionLongHashMap);

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7

    重复消费与漏消费

    1. 场景1：重复消费。自动提交offset引起。
    - Consumer每5s提交offset
- 如果提交offset后的2s，consumer挂了
- 再次重启consumer，则从上一次提交的offset处继续消费，导致重复消费

    • 1
    • 2
    • 3
    1. 场景1：漏消费。设置offset为手动提交，当offset被提交时，数据还在内存中未落盘，此时刚好消费者在线程中被kill掉，那么offset已经提交，但是数据未处理，导致这部分内存中的数据丢失。

    消费者事务

    如果想完成Consumer端的精准一次性消费，那么需要kafka消费端将消费过程和提交offset过程做原子绑定。此时我们需要将kafka的offset保存到支持事务的自定义介质（比如mysql）。

    数据积压（消费者如何提高吞吐量）

    1. 如果是kafka消费能力不足，则可以考虑增加Topic的分区数，并且同时提升消费组的消费者数量，消费者=分区数。（两者缺一不可）
    2. 如果是下游的数据处理不及时：提高每批次拉取的数量。批次拉取数据过少（拉取数据/处理时间 < 生产速度），使处理的数据小于生产的数据，也会造成数据积压。
  • 相关阅读:
    C语言第入门——第十六课
    vue返回上一页(后退)的几种方法与区别
    Linux安装MySQL(超详细)
    Oracle 19c 安装（Linux）
    【性能测试】Action.c(6): Error -26612
    社交APP的核心功能都有哪些
    面试宝典-Mysql篇
    Java版本spring cloud + spring boot企业电子招投标系统源代码
    Java SE 15 新增特性
    【Flink】Flink on Yarn 翻译 使用 hdfs jar yarn.provided.lib.dirs
  • 原文地址：https://blog.csdn.net/weixin_51343683/article/details/127366381