kafka源码分析之consumer的源码

最新推荐文章于 2024-02-11 11:50:24 发布
最新推荐文章于 2024-02-11 11:50:24 发布
阅读量9.8k 收藏 8
点赞数 4
文章标签： kafka0.9.0源码分析 kafka-consumer源码分析
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u014393917/article/details/52043317
版权
本文深入探讨了Kafka Consumer的客户端实现，包括如何创建KafkaConsumer实例、订阅主题、读取消息以及消费者组协调。详细分析了配置参数、网络客户端、元数据管理和心跳机制，展示了Consumer如何处理分配、重试、心跳与offset提交等核心功能。
摘要由CSDN通过智能技术生成

Consumer的client端

示例代码

Properties props = new Properties();
props.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "localhost:9092");
props.put(ConsumerConfig.GROUP_ID_CONFIG, "DemoConsumer");
props.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "false");
props.put(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG, "30000");
props.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, 

        "org.apache.kafka.common.serialization.ByteArrayDeserializer");
props.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, 

        "org.apache.kafka.common.serialization.ByteArrayDeserializer");

 

 

consumer = new KafkaConsumer<>(props);
this.topic = topic;

 

consumer.subscribe(Collections.singletonList(this.topic));

//下面的传入一个listener这个部分的注释如果需要对partition在当前的consumer中分配或者取消分配时做一定的操作时（比如取消分配时提交offset），可以实现这个接口。

//subscribe(List<String> topics, ConsumerRebalanceListener listener)

while(true) {
   ConsumerRecords<Integer, String> records = consumer.poll(1000);
   for (ConsumerRecord<Integer, String> record : records) {
     System.out.println("Received message: (" + record.key() + ", " + record.value() 

         + ") at offset " + record.offset());

      
   }

 

   consumer.commitSync()

}

 

生成KafkaConsumer实例


@SuppressWarnings("unchecked")
private KafkaConsumer(ConsumerConfig config,
                      Deserializer<K> keyDeserializer,
                      Deserializer<V> valueDeserializer) {
    try {
        log.debug("Starting the Kafka consumer");

 

根据配置信息，得到如下三个配置的配置值，并检查配置的合法：

1,读取request.timeout.ms配置项的值，默认值为40秒。用于配置请求的超时时间。

2,读取session.timeout.ms配置项的值，默认值为30秒，用于配置当前的consumer的session的超时时间，也就是client端多长时间不给server发送心跳就表示这个client端超时。

3,读取fetch.max.wait.ms配置项的值，默认值为500ms。用于配置从server中读取数据最长的等待时间。
        this.requestTimeoutMs = config.getInt(

                ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG);
        int sessionTimeOutMs = config.getInt(

                ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG);
        int fetchMaxWaitMs = config.getInt(

                ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG);

 

如果请求超时时间不是一个大于session的超时时间的值或者请求超时时间不是一个大于fetch的最大等待时间的值时，表示requestTimeoutMs的配置不合法，直接throw exception.
        if (this.requestTimeoutMs <= sessionTimeOutMs ||

                this.requestTimeoutMs <= fetchMaxWaitMs)
            throw new ConfigException(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG 

               + " should be greater than " + ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG 

               + " and " + ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG);

 

        this.time = new SystemTime();

        MetricConfig metricConfig = new MetricConfig().samples(

                    config.getInt(ConsumerConfig.METRICS_NUM_SAMPLES_CONFIG))
                .timeWindow(config.getLong(

                        ConsumerConfig.METRICS_SAMPLE_WINDOW_MS_CONFIG),
                        TimeUnit.MILLISECONDS);

 

这里得到对应的consumer的client端id的client.id配置，如果这个值没有配置时，默认随机生成一个。
        clientId = config.getString(ConsumerConfig.CLIENT_ID_CONFIG);
        if (clientId.length() <= 0)
            clientId = "consumer-" + CONSUMER_CLIENT_ID_SEQUENCE.getAndIncrement();


        List<MetricsReporter> reporters = config.getConfiguredInstances(

                ConsumerConfig.METRIC_REPORTER_CLASSES_CONFIG,
                MetricsReporter.class);
        reporters.add(new JmxReporter(JMX_PREFIX));
        this.metrics = new Metrics(metricConfig, reporters, time);

 

读取retry.backoff.ms配置的值，默认值为100ms，用于配置重试的间隔周期。

        this.retryBackoffMs = config.getLong(

              ConsumerConfig.RETRY_BACKOFF_MS_CONFIG);

 

根据重试的间隔周期加上metadata.max.age.ms配置项的值生成Metadata实例，

配置metadata.max.age.ms项默认值为5分钟，用于设置metadata定期重新读取的生命周期。
        this.metadata = new Metadata(retryBackoffMs, 

              config.getLong(ConsumerConfig.METADATA_MAX_AGE_CONFIG));

 

读取bootstrap.servers配置的要读取的kafka brokers的配置列表，并根据broker的连接信息，生成Cluster实例,并把Cluster实例更新到metadata的实例。
        List<InetSocketAddress> addresses = ClientUtils.parseAndValidateAddresses(

              config.getList(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG));
        this.metadata.update(Cluster.bootstrap(addresses), 0);


        String metricGrpPrefix = "consumer";
        Map<String, String> metricsTags = new LinkedHashMap<String, String>();
        metricsTags.put("client-id", clientId);

 

生成NetworkClient的实例，生成实例需要如下几个配置文件：

1,配置项connections.max.idle.ms，默认值9分钟，用于配置连接最大的空闲时间（每个连接的最大连接队列为100）。

2,配置项reconnect.backoff.ms，默认值50ms,用于配置连接断开后重新连接的间隔时间。

3,配置项send.buffer.bytes，默认值128kb，用于配置SOCKET的SO_SNDBUF发送数据的缓冲区大小。

4,配置项receive.buffer.bytes，默认值32kb，用于配置SOCKET的SO_RCVBUF接收数据的缓冲区大小。

5,读取request.timeout.ms配置项的值，默认值为40秒。用于配置请求的超时时间。
        ChannelBuilder channelBuilder = ClientUtils.createChannelBuilder(

               config.values());
        NetworkClient netClient = new NetworkClient(

                new Selector(config.getLong(

                   ConsumerConfig.CONNECTIONS_MAX_IDLE_MS_CONFIG),

                   metrics, time, metricGrpPrefix, metricsTags, channelBuilder),
                this.metadata,
                clientId,
                100, // a fixed large enough value will suffice
                config.getLong(ConsumerConfig.RECONNECT_BACKOFF_MS_CONFIG),
                config.getInt(ConsumerConfig.SEND_BUFFER_CONFIG),
                config.getInt(ConsumerConfig.RECEIVE_BUFFER_CONFIG),
                config.getInt(ConsumerConfig.REQUEST_TIMEOUT_MS_CONFIG), time);

 

根据retry.backoff.ms配置的值，生成一个ConsumerNetworkClient的实例。
        this.client = new ConsumerNetworkClient(netClient, metadata, time, 

                 retryBackoffMs);

 

读取auto.offset.reset配置项的值，默认值为latest。可配置("latest", "earliest", "none")，这个配置用于在读取partition的offset超出范围时，对offset进行重置的规则。
        OffsetResetStrategy offsetResetStrategy = OffsetResetStrategy.valueOf(

                    config.getString(

                    ConsumerConfig.AUTO_OFFSET_RESET_CONFIG).toUpperCase());

 

生成用于管理订阅的topic的partition的状态管理的组件，用于管理partition的状态与当前的offset的信息。
        this.subscriptions = new SubscriptionState(offsetResetStrategy);

 

生成用于管理相同的一个groupId下的多个client端的partition的分区控制，

通过partition.assignment.strategy配置，默认实例为RangeAssignor。
        List<PartitionAssignor> assignors = config.getConfiguredInstances(
                ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG,
                PartitionAssignor.class);

 

生成用于对consumer进行协调的实例，这个实例依赖如下配置：

1,配置项group.id，用于配置consumer对应的订阅的组名称，相同的组的多个client端进行协调消费处理。

2,读取session.timeout.ms配置项的值，默认值为30秒，用于配置当前的consumer的session的超时时间，也就是client端多长时间不给server发送心跳就表示这个client端超时。

3,配置项heartbeat.interval.ms，默认值3秒，用于定时向server发送心跳的时间间隔。

4,根据retry.backoff.ms配置的值来设置读取信息失败的重试间隔。

5,配置项enable.auto.commit，默认值true,设置是否自动提交消费过的offset的值的设置。

5,配置项auto.commit.interval.ms，默认值5秒，如果设置有自动提交offset时，自动提交的间隔时间。
        this.coordinator = new ConsumerCoordinator(this.client,
                config.getString(ConsumerConfig.GROUP_ID_CONFIG),
                config.getInt(ConsumerConfig.SESSION_TIMEOUT_MS_CONFIG),
                config.getInt(ConsumerConfig.HEARTBEAT_INTERVAL_MS_CONFIG),
                assignors,
                this.metadata,
                this.subscriptions,
                metrics,
                metricGrpPrefix,
                metricsTags,
                this.time,
                retryBackoffMs,
                new ConsumerCoordinator.DefaultOffsetCommitCallback(),
                config.getBoolean(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG),
                config.getLong(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG));

 

根据key.deserializer配置与value.deserializer配置的key,value的反序列化的配置，生成反序列化消息的实例。这个类必须是实现Deserializer接口的类。
        if (keyDeserializer == null) {
            this.keyDeserializer = config.getConfiguredInstance(

                    ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG,
                    Deserializer.class);
            this.keyDeserializer.configure(config.originals(), true);
        } else {
            config.ignore(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG);
            this.keyDeserializer = keyDeserializer;
        }


        if (valueDeserializer == null) {
            this.valueDeserializer = config.getConfiguredInstance(

                    ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG,
                    Deserializer.class);
            this.valueDeserializer.configure(config.originals(), false);
        } else {
            config.ignore(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG);
            this.valueDeserializer = valueDeserializer;
        }

 

生成用于具体读取消息的读取实例，这个实例依赖如下几个配置信息：

1,配置项fetch.min.bytes，默认值1,用于设置每次读取的最小byte数。

2,配置项fetch.max.wait.ms，默认值500ms，用于设置每次读取的最大等待时间。

3,配置项max.partition.fetch.bytes，默认值1MB,用于设置每个partition每次读取的最大的数据量。

4,配置项check.crcs，默认值true,用于设置是否校验数据的完整性。

根据retry.backoff.ms配置的值来设置读取信息失败的重试间隔。
        this.fetcher = new Fetcher<>(this.client,
                config.getInt(ConsumerConfig.FETCH_MIN_BYTES_CONFIG),
                config.getInt(ConsumerConfig.FETCH_MAX_WAIT_MS_CONFIG),
                config.getInt(ConsumerConfig.MAX_PARTITION_FETCH_BYTES_CONFIG),
                config.getBoolean(ConsumerConfig.CHECK_CRCS_CONFIG),
                this.keyDeserializer,
                this.valueDeserializer,
                this.metadata,
                this.subscriptions,
                metrics,
                metricGrpPrefix,
                metricsTags,
                this.time,
                this.retryBackoffMs);

        config.logUnused();
        AppInfoParser.registerAppInfo(JMX_PREFIX, clientId);

        log.debug("Kafka consumer created");
    } catch (Throwable t) {
        // call close methods if internal objects are already constructed
        // this is to prevent resource leak. see KAFKA-2121
        close(true);
        

最低0.47元/天 解锁文章
隔壁老杨hongs
关注
专栏目录
kafka 0.10.0.1 consumer源码解析
qq_32854205的博客
01-03 1191
消费者源码解析，基于0.10.0.1版本 初始化 consumer 对象 // 主要初始化的几个组件：new几个对象，NetworkClient、ConsumerCoordinator、Fetcher new KafkaConsumer<String, String>(properties); 拉取数据 ConsumerRecords<String, String> records = kafkaConsumer.poll(5000); // 核心方法： org.a
Kafka源码之KafkaConsumer分析之Fetcher
m0_37343985的博客
10-28 1403
对于KafkaConsumer，我们最后来看一下消费者是符合从服务端获取消息的，它是用Fetcher来实现此功能。Fetcher的主要工作就是发送FetchRequest请求，获取指定的消息集合，处理FetchResponse，更新消费位置。 我们先来看一下它的核心字段： client：负责网络通信 minBytes：在服务端收到FetchRequest之后并不是立即响应，而是当可返回的消息数据积...
【原创】Kafka console consumer源代码分析(一)
weixin_34370347的博客
07-26 205
上一篇中分析了Scala版的console producer代码，这篇文章为读者带来一篇console consumer工作原理分析的随笔。其实不论是哪个consumer，大部分的工作原理都是类似的。本文利用console consumer作为切入点，既容易理解又不失一般性。   本文使用的Kafka环境是0.8.2.1版本，这也是当前最新的版本。(注：Kafka 0.9版本据说会用Java重...
kafka：Consumer源码分析
ScorpC的博客
03-01 668
上传一篇，之前看kafka Consumer源码做的笔记。 正文如下： kafka版本：2.2 首先，kafka消费模型的要点： Kafka 的每个 Consumer(消费者)实例属于一个 ConsumerGroup(消费组); 在消费时，ConsumerGroup 中的每个 Consumer 独占一个或多个 Partition(分 区); 对于每个 ConsumerGroup，在任意时刻，每个 Partition 至多有 1 个 Consumer 在消费; 每个 ConsumerG.
读Kafka Consumer源码
weixin_33962621的博客
12-04 98
最近一直在关注阿里的一个开源项目：OpenMessaging OpenMessaging, which includes the establishment of industry guidelines and messaging, streaming specifications to provide a common framework for finance, e-commerce, ...
KafkaConsumer源码解析
weixin_34117211的博客
03-03 168
为什么80%的码农都做不了架构师？>>> ...
Kafka源码之KafkaConsumer分析之poll方法分析
热门推荐
m0_37343985的博客
10-28 2万+
我们获取消息都是通过poll方法，现在我们从整体上看一下消费的流程： public ConsumerRecords&lt;K, V&gt; poll(long timeout) { //防止并发操作 acquire(); try { if (timeout &lt; 0) throw new Illegal...
Kafka源码之KafkaConsumer分析之offset操作
m0_37343985的博客
10-28 2917
当消费者正常消费过程中以及Rebalance操作开始之前，都会提交一次Offset记录Consumer当前的消费位置。在SubscriptionState中使用TopicPartitionState记录了每个TopicPartition的消费状况，TopicPartitionState.position字段则记录了消费者下次要从服务端获取的消息的offset。 public void commit...
kafka源码分析
08-15
kafka源码分析， Introduction kafka-Intro kafka-Unix kafka-Producer kafka-Producer-Scala kafka-SocketServer kafka-LogAppend kafka-ISR kafka-Consumer-init-Scala
kafka系列——KafkaConsumer源码分析
linxiaorui的博客
11-26 5463
实例化过程 与KafkaProduer类似,只是初始化的组件有所差异,看KafkaConsumer构造函数 消费者实例化的主要组件介绍 ConsumerConfig：消费者级别的配置,将相应配置传递给其他组件 ConsumerCoodinator：负责消费者与服务端 GroupCoordinator 通信 ConsumerNetworkClient：对网络层通信 NetworkClien...
Kafka Consumer源码讲解
an13654067079的博客
08-31 772
Kafka Consumer源码讲解
【原创】kafka consumer源代码分析
weixin_34334744的博客
06-09 148
顾名思义，就是kafka的consumer api包。 一、ConsumerConfig.scala Kafka consumer的配置类，除了一些默认值常量及验证参数的方法之外，就是consumer的配置参数了，比如group.id, consumer.id等，详细列表见官网。 二、ConsumerIterator.scala     KafkaStream的迭代器类，当stream底层...
Kafka中Consumer源码解读
weixin_43875870的博客
09-09 739
extends 类AbstractPartitionAssignor，然后在消费者端增加参数：properties.put(ConsumerConfig.PARTITION_ASSIGNMENT_STRATEGY_CONFIG,类.class.getName());即可。
Kafka-Consumer 源码解析 -- 数据消费
qq_38245668的博客
06-26 434
Kafka-Consumer 源码解析 -- 数据消费
kafka源码分析---kafkaconsumer分析
wjandy0211的博客
04-28 253
从图中可以看出Consumer和ConsumerGroup之间的关系，即一个Consumer对应一个ConsumerGroup，一个ConsumerGroup包含多个Consumer。另外，一个ConsumerGroup中的不同Consumer只能消费不同的Partition，跨ConsumerGroup中的Consumer则没有这个限制，即ConsumerA1和ConsumerB1可以消费同...
21 | Kafka Consumer源码分析：消息消费的实现过程
最新发布
qq_37756660的博客
02-11 1266
我们在上节中提到过，用于解决消息队列一些常见问题的知识和原理，最终落地到代码上，都包含在收、发消息这两个流程中。对于消息队列的生产和消费这两个核心流程，在大部分消息队列中，它实现的主要流程都是一样的，所以，通过这两节的学习之后，掌握了这两个流程的实现过程。无论你使用的是哪种消息队列，遇到收发消息的问题，都可以用同样的思路去分析和解决问题。
Kafka源码分析Consumer
weixin_34075268的博客
03-12 121
原文:http://zqhxuyuan.github.io/2016/02/22/2016-02-22-Kafka-Consumer-new/ Kafka new Consumer 0.9+ 5.1 消费者重新实现的细节上一章分析的消费者高级API使用ConsumerGroup的语义管理多个消费者，但是在消费者或者Partition发...
【Apache Kafka3.2】KafkaConsumer源码分析
mashaokang1314的博客
10-24 954
与KafkaProducer不同的是，KafkaConsumer不是一个线程安全的类。为了便于分析，我们认为下面介绍的所有操作都是在同一线程中完成的，所以不需要考虑锁的问题。这种设计将实现多线程处理消息的逻辑转移到了调用KafkaConsumer的代码中，可以根据业务逻辑使用不同的实现方式。例如，可以使用“线程封闭”的方式，每个业务线程拥有一个KafkaConsumer对象，这种方式实现简单、快速。还可以使用两个 线程池实现“生产者—消费者”模式，解耦消息消费和消息处理的逻辑。
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值