Kafka：Consumer暂停与恢复从Partition拉取消息

已于 2022-02-15 09:06:20 修改
阅读量3.3k 收藏 8
点赞数 2
分类专栏： Kafka 文章标签： kafka 分布式 zookeeper
于 2022-02-14 17:16:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37960603/article/details/122928140
版权

测试代码

pom.xml：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>com.kaven</groupId>
    <artifactId>kafka</artifactId>
    <version>1.0-SNAPSHOT</version>

    <properties>
        <maven.compiler.source>8</maven.compiler.source>
        <maven.compiler.target>8</maven.compiler.target>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.apache.kafka</groupId>
            <artifactId>kafka-clients</artifactId>
            <version>3.0.0</version>
        </dependency>
    </dependencies>
</project>

创建Topic：

package com.kaven.kafka.admin;

import org.apache.kafka.clients.admin.*;
import org.apache.kafka.common.KafkaFuture;

import java.util.Collections;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.CountDownLatch;
import java.util.concurrent.ExecutionException;

public class Admin {

    // 基于Kafka服务地址与请求超时时间来创建AdminClient实例
    private static final AdminClient adminClient = Admin.getAdminClient(
            "192.168.1.9:9092,192.168.1.9:9093,192.168.1.9:9094",
            "40000");

    public static void main(String[] args) throws InterruptedException, ExecutionException {
        Admin admin = new Admin();
        // 创建Topic，Topic名称为topic1，分区数为1，复制因子为1
        admin.createTopic("topic1", 1, (short) 1);
        // 创建Topic，Topic名称为topic2，分区数为2，复制因子为1
        admin.createTopic("topic2", 2, (short) 1);
        // 创建Topic，Topic名称为topic3，分区数为2，复制因子为1
        admin.createTopic("topic3", 2, (short) 1);
        Thread.sleep(10000);
    }

    public static AdminClient getAdminClient(String address, String requestTimeoutMS) {
        Properties properties = new Properties();
        properties.setProperty(AdminClientConfig.BOOTSTRAP_SERVERS_CONFIG, address);
        properties.setProperty(AdminClientConfig.REQUEST_TIMEOUT_MS_CONFIG, requestTimeoutMS);
        return AdminClient.create(properties);
    }

    public void createTopic(String name, int numPartitions, short replicationFactor) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        CreateTopicsResult topics = adminClient.createTopics(
                Collections.singleton(new NewTopic(name, numPartitions, replicationFactor))
        );
        Map<String, KafkaFuture<Void>> values = topics.values();
        values.forEach((name__, future) -> {
            future.whenComplete((a, throwable) -> {
                if(throwable != null) {
                    System.out.println(throwable.getMessage());
                }
                System.out.println(name__);
                latch.countDown();
            });
        });
        latch.await();
    }
}

Producer发布消息：

package com.kaven.kafka.producer;

import org.apache.kafka.clients.producer.*;
import java.util.Properties;
import java.util.concurrent.ExecutionException;

public class ProducerTest {

    public static void main(String[] args) throws ExecutionException, InterruptedException {
        send("topic1");
        send("topic2");
        send("topic3");
    }

    public static void send(String name) throws ExecutionException, InterruptedException {
        Producer<String, String> producer = ProducerTest.createProducer();
        for (int i = 0; i < 7; i++) {
            ProducerRecord<String, String> producerRecord = new ProducerRecord<>(
                    name,
                    "key-" + i,
                    "value-" + i
            );
            // 异步发送并回调
            producer.send(producerRecord, (metadata, exception) -> {
                if(exception == null) {
                    System.out.printf("topic: %s, partition: %s, offset: %s\n", name, metadata.partition(), metadata.offset());
                }
                else {
                    exception.printStackTrace();
                }
            });
        }
        // 要关闭Producer实例
        producer.close();
    }

    public static Producer<String, String> createProducer() {
        // Producer的配置
        Properties properties = new Properties();
        // 服务地址
        properties.put(ProducerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.1.9:9092,192.168.1.9:9093,192.168.1.9:9094");
        // KEY的序列化器类
        properties.put(ProducerConfig.KEY_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");
        // VALUE的序列化器类
        properties.put(ProducerConfig.VALUE_SERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringSerializer");

        return new KafkaProducer<>(properties);
    }
}

暂停从Partition拉取消息

Consumer订阅程序：

package com.kaven.kafka.consumer;

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

import java.time.Duration;
import java.util.*;

public class ConsumerTest {

    public static void main(String[] args) throws InterruptedException {
        pausePartition(Arrays.asList("topic1", "topic2", "topic3"));
    }

    public static void pausePartition(List<String> topicList) throws InterruptedException {
        KafkaConsumer<String, String> consumer = createConsumer();
        consumer.subscribe(topicList);
        
        while (true) {
            // 拉取消息
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            records.partitions().forEach((partition) -> {
                // 从该分区拉取的消息
                List<ConsumerRecord<String, String>> recordsWithPartition = records.records(partition);
                recordsWithPartition.forEach((record) -> {
                    System.out.printf("topic: %s, partition: %s, offset: %s, key: %s, value: %s\n",
                            record.topic(), record.partition(), record.offset(), record.key(), record.value());
                });
                // 暂停拉取分区1的消息
                if(partition.partition() == 1) {
                    consumer.pause(Collections.singleton(partition));
                }
            });
        }
    }

    public static KafkaConsumer<String, String> createConsumer() {
        // Consumer的配置
        Properties properties = new Properties();
        // 服务地址
        properties.put(ConsumerConfig.BOOTSTRAP_SERVERS_CONFIG, "192.168.1.9:9092,192.168.1.9:9093,192.168.1.9:9094");
        // 组ID，用于标识此消费者所属的消费者组
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, "kaven-test");
        // 开启offset自动提交
        properties.put(ConsumerConfig.ENABLE_AUTO_COMMIT_CONFIG, "true");
        // 消费者offset自动提交到Kafka的频率（以毫秒为单位）
        properties.put(ConsumerConfig.AUTO_COMMIT_INTERVAL_MS_CONFIG, "1000");
        // KEY的反序列化器类
        properties.put(ConsumerConfig.KEY_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");
        // VALUE的反序列化器类
        properties.put(ConsumerConfig.VALUE_DESERIALIZER_CLASS_CONFIG, "org.apache.kafka.common.serialization.StringDeserializer");

        return new KafkaConsumer<>(properties);
    }
}

暂停拉取分区1的消息：

                // 暂停拉取分区1的消息
                if(partition.partition() == 1) {
                    consumer.pause(Collections.singleton(partition));
                }

由于是先拉取消息后再暂停拉取分区1的消息，因此开始会拉取分区1的消息，之后就只会拉取分区0（测试的Topic最多只有两个分区）的信息。

先创建Topic，然后运行Consumer订阅程序，再使用Producer发布两次消息，之后Consumer就可以订阅到消息了，输出如下所示：

// 第一次发布的消息
topic: topic1, partition: 0, offset: 147, key: key-0, value: value-0
topic: topic1, partition: 0, offset: 148, key: key-1, value: value-1
topic: topic1, partition: 0, offset: 149, key: key-2, value: value-2
topic: topic1, partition: 0, offset: 150, key: key-3, value: value-3
topic: topic1, partition: 0, offset: 151, key: key-4, value: value-4
topic: topic1, partition: 0, offset: 152, key: key-5, value: value-5
topic: topic1, partition: 0, offset: 153, key: key-6, value: value-6
topic: topic2, partition: 0, offset: 84, key: key-1, value: value-1
topic: topic2, partition: 0, offset: 85, key: key-2, value: value-2
topic: topic2, partition: 0, offset: 86, key: key-5, value: value-5
topic: topic2, partition: 0, offset: 87, key: key-6, value: value-6
topic: topic2, partition: 1, offset: 63, key: key-0, value: value-0
topic: topic2, partition: 1, offset: 64, key: key-3, value: value-3
topic: topic2, partition: 1, offset: 65, key: key-4, value: value-4
topic: topic3, partition: 0, offset: 84, key: key-1, value: value-1
topic: topic3, partition: 0, offset: 85, key: key-2, value: value-2
topic: topic3, partition: 0, offset: 86, key: key-5, value: value-5
topic: topic3, partition: 0, offset: 87, key: key-6, value: value-6
topic: topic3, partition: 1, offset: 63, key: key-0, value: value-0
topic: topic3, partition: 1, offset: 64, key: key-3, value: value-3
topic: topic3, partition: 1, offset: 65, key: key-4, value: value-4

// 第二次发布的消息
topic: topic1, partition: 0, offset: 154, key: key-0, value: value-0
topic: topic1, partition: 0, offset: 155, key: key-1, value: value-1
topic: topic1, partition: 0, offset: 156, key: key-2, value: value-2
topic: topic1, partition: 0, offset: 157, key: key-3, value: value-3
topic: topic1, partition: 0, offset: 158, key: key-4, value: value-4
topic: topic1, partition: 0, offset: 159, key: key-5, value: value-5
topic: topic1, partition: 0, offset: 160, key: key-6, value: value-6
topic: topic2, partition: 0, offset: 88, key: key-1, value: value-1
topic: topic2, partition: 0, offset: 89, key: key-2, value: value-2
topic: topic2, partition: 0, offset: 90, key: key-5, value: value-5
topic: topic2, partition: 0, offset: 91, key: key-6, value: value-6
topic: topic3, partition: 0, offset: 88, key: key-1, value: value-1
topic: topic3, partition: 0, offset: 89, key: key-2, value: value-2
topic: topic3, partition: 0, offset: 90, key: key-5, value: value-5
topic: topic3, partition: 0, offset: 91, key: key-6, value: value-6

输出符合预期。

恢复从Partition拉取消息

修改Consumer订阅程序：

    public static void pausePartition(List<String> topicList) throws InterruptedException {
        KafkaConsumer<String, String> consumer = createConsumer();
        consumer.subscribe(topicList);
        // 恢复被暂停拉取消息的分区
        resume(consumer);
        while (true) {
            // 拉取消息
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            records.partitions().forEach((partition) -> {
                // 从该分区拉取的消息
                List<ConsumerRecord<String, String>> recordsWithPartition = records.records(partition);
                recordsWithPartition.forEach((record) -> {
                    System.out.printf("topic: %s, partition: %s, offset: %s, key: %s, value: %s\n",
                            record.topic(), record.partition(), record.offset(), record.key(), record.value());
                });
            });
        }
    }

    // 用于恢复被暂停拉取消息的分区
    public static void resume(KafkaConsumer<String, String> consumer) {
        consumer.resume(consumer.paused());
    }

下面这行代码会恢复所有被暂停拉取的分区。

consumer.resume(consumer.paused());

运行Consumer订阅程序，Producer不发布消息，而Consumer也可以订阅到消息，输出如下所示（可能需要等一会）：

topic: topic3, partition: 1, offset: 66, key: key-0, value: value-0
topic: topic3, partition: 1, offset: 67, key: key-3, value: value-3
topic: topic3, partition: 1, offset: 68, key: key-4, value: value-4
topic: topic2, partition: 1, offset: 66, key: key-0, value: value-0
topic: topic2, partition: 1, offset: 67, key: key-3, value: value-3
topic: topic2, partition: 1, offset: 68, key: key-4, value: value-4

很显然这些消息是之前被暂停拉取的分区中的消息，现在恢复拉取了，消息就又可以被消费了，因此，可以基于暂停与恢复从Partition拉取消息来实现Kafka的限流逻辑。Consumer暂停与恢复从Partition拉取消息就介绍到这里，如果博主有说错的地方或者大家有不同的见解，欢迎大家评论补充。

ITKaven
关注
  • 2
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
【kafka】Kafka consumer处理大消息数据过大导致消费停止问题
九师兄
07-18 3157
1.概述 转载：https://www.cnblogs.com/wynjauu/articles/9409686.html 昨天线上发现一个现象：kafka一个topic有数据生产，但是没有消费了，各种排查es集群、内存使用情况等都正常，但是就是消费线程死了一样，重启jboss也没有用，最后发现是因为消费该topic的kafka八的partition因为遇到了大数据超过1M而都被堵塞（我们是四台机器每个机器两个partation消费）。 下面是网上看到到一个解释博客： 2.案例分析 处理kafka con.
Spring整合Kafka（十三）----暂停和恢复监听器容器&暂停和恢复监听器容器上的分区
Gabriel Wang的博客
01-18 410
当容器暂停时，它会继续poll() consumer，避免在使用组管理的情况下进行再平衡（rebalance），容器暂停的时候不拉取任何记录。你可以通过在监听器容器中使用pausePartition(TopicPartition topicPartition)和resumePartition(TopicPartition topicPartition)方法暂停和恢复分配给该consumer的特定分区消费。暂停和恢复分别发生在poll()之前和之后，类似于pause（）和resume（）方法。
Kafka问题排查（消费者自动关闭）
weixin_33725272的博客
07-04 2712
问题描述： 在消费端能够正常消费到Kafka数据并成功生产到producer topic 中，当将kafka的一台机器关机之后，正常情况下应该是 消费端是不受影响的。因为有还有两台的负载机器。问题就是一台机器停止运行之后，消费端酒 shutdown 而无法重新starting 解决方式 ： 在如下代码中。 1 public void run...
spring-kafka-消费者暂停与恢复
booynal的博客
12-11 3159
原生Kafka可以很容易的控制消费者线程暂停与恢复，但是Spring-Kafka中我一直不太清楚如何暂停恢复，直到我在工作中遇到了适当的业务场景，于是我在百度上搜索了一下，再结合看源码，总结出了如下3个步骤： 1: 自动注入KafkaListenerEndpointRegistry @Autowired private KafkaListenerEndpointRegistry kafkaListenerEndpointRegistry; 2: 在KafkaListener上指定id和gr
记一次kafka Consumer线程停止消费过程分析
huangdi1309的博客
12-21 7687
前言 kafka消息队列在项目开发中经常被使用，尤其是在大数据领域经常见到它的身影。spring集成了kafka方便我们使用，只要引入spring-kafka即可。 问题描述 有一天我们后台版本发布，虽然改动很大，但是大家还是自信满满，因为经过了好几轮测试验证都没有问题，但是很不幸结果还是出现问题了，上线后发现kafka消费线程只拉取了一次就莫名其妙停止了(kafka消费者是不同的从服务端poll拉取消息来消费的)连线程异常堆栈信息都没有抛出，于是大家都陷入了沉思，最后迫不得已只能回滚。 这里使用的是spr
Apache Kafka - 灵活控制Kafka消费_动态开启/关闭监听实现
热门推荐
小工匠
05-31 1万+
在实际应用中，往往需要根据业务需求动态开启/关闭Kafka消费者监听。例如，在某些时间段内，可能需要暂停对某个Topic的消费，或者在某些条件下才开启对某个Topic的消费。在Spring Boot中，要实现动态的控制或关闭消费以及动态开启或关闭监听，可以使用Spring Kafka提供的一些功能。
Kafka 消息队列（高清版）深入理解Kafka：核心设计与实践原理.zip
05-15
Kafka 消息队列（高清版）深入理解Kafka：核心设计与实践原理。 高清版
深入理解Kafka：核心设计与实践原理_朱忠华著_带目录.rar
06-12
本书秉承能用文字表述的就不贴源码、能用图形辅助的就不乏味陈述;既要让新手能够快速入门，也要让老手有所启发，从基础概念入手，再到原理深入，让读者能够由浅入深地理解 Kafka
消息中间件Kafka：基本概念和基本使用(经典)
01-07
最近做项目时使用到了Kafka，翻自己博客居然没有相关文章，这时写点文章复习复习，顺便深入理解...从图中可以看到Producer负责向broker发送消息，而Consumer负责从broker拉取消息，从而完成整个消息的生产消费。另外还
springboot-kafka:springboot整合kafka实现消息的发送与消费学习
05-13
springboot-kafkaspringboot整合kafka实现消息的发送与消费学习csdn博客地址--
KafkaConsumer分析
happy19870612's blog
06-01 6011
一 重要的字段 String clientId：Consumer唯一标识 ConsumerCoordinator coordinator： 控制Consumer与服务器端GroupCoordinator之间的通信逻辑 Fetcher fetcher： 负责从服务器端获取消息的组件，并且更新partition的offset ConsumerNetworkClient client:  负责和
Kafka Consumer编程一
tom_fans的博客
07-19 415
之前提到过Consumer消费通常有2种方式，一种是获取消息然后保存offset，之后处理，这种如果出现问题，会导致at-most-once, 还有一种是获取消息，处理消息，保存offset，这种出现问题为at-least-once.  这里暂时不介绍exactly once的处理。 at-most-once:  通过设置enable.auto.commit，以及auto.commit
Kafka使用篇 - 暂停/恢复 监听器容器
The Secret
07-21 3144
前言 2.1.3之前的版本，可以在ConsumerAwareMessageListener中暂停一个消费者，通过监听ListenerContainerIdleEvent来恢复该消费者。这种方式存在安全问题，不能保证事件监听器由消费者线程调用。为了安全的暂停、恢复消费者，应当使用监听器容器的pause()、resume()方法。 正言 2.1.3版本，对于监听器容器增加了pause()、resume()方法。pause()方法在下一次poll()之前生效，而resume()方法在当前的poll()之后生效。当
Kafka消费者
qi531621028的博客
12-14 258
基本概念 消费者（Consumer）负责订阅Kafka中的主题（Topic），并且从订阅的主题上拉取消息。与其他一些消息中间件不同的是：在Kafka的消费理念中还有一层消费组（Consumer Group）的概念，每个消费者都有一个对应的消费组。当消息发布到主题后，只会被投递给订阅它的每个消费组中的一个消费者。每个消费者只能消费所分配到的分区中的消息。换言之，每一个分区只能被一个消费组中的一个消费者所消费 订阅主题与分区 在创建好消费者之后，我们就需要为该消费者订阅相关的主题了。一个消费者可以订阅一个或多个
kafka shutdown停止关闭很慢问题的解决方案
zollty的专栏
12-31 2910
kafka shutdown停止很慢问题 在数据量大的时候，consumer一次抓取数据的数据很多，进入到业务处理的数据可能有很多， 假设一次poll有1万条数据进入业务程序，而且业务程序是和poll绑定在一起线程同步执行的，假设平均每条数据，执行业务程序花费100ms， 那么poll一次的数据，至少要执行 1w*0.1s = 1000s = 16.67分钟。
Kafka消费者组和Rebalance
沉下心来，戒骄戒躁
08-18 1031
消费者组 Consumer Group 是 Kafka 提供的可扩展且具有容错性的消费者机制 特性： 1.一个组下可以包含多个消费者实例。可以是消费者进程，也可以是消费者线程。 2.GroupID是个字符串，标识唯一的group。 3.Topic下的分区只能被某个Group的一个Consumer消费。一个Consumer可以消费多个分区，即分区和消费者是多对一的关...
Kafka线上集群部署方案怎么做？no.6
飘然渡沧海的博客
05-27 700
最后是社区的支持度。这一点虽然不是什么明显的差别，但如果不了解的话可能比前两个因素对你的影响更大。简单来说就是，社区目前对Windows平台上发现的Kafka Bug不做任何承诺。虽然口头上依然保证尽力去解决，但根据我的经验，Windows上的Bug一般是不会修复的。
Kafka 集群部署（CentOS 单机模拟版）
花想云的博客
05-27 594
由于我们手里只有一台Linux机器，所以我们实现的是简单的单机模拟的集群部署，通过修改配置文件，启动3个kafka时用到3个不同的端口（9091，9092，9093）。
如何修改 Kafka 消息保留时长：经验总结
最新发布
weixin_44976692的博客
05-28 2053
Apache Kafka 是一种高性能的分布式消息系统，用于处理实时数据流。在实际使用中，我们可能需要根据业务需求调整 Kafka 消息的保留时长。本文将介绍如何修改 Kafka 消息保留时长，并分享在实际操作中的一些经验。修改 Kafka 消息保留时长是优化 Kafka 系统性能和资源使用的重要手段。通过合理的配置，可以满足不同业务场景的需求，同时确保系统的稳定性和高效性。希望本文的介绍和经验总结能帮助你更好地管理 Kafka 集群，提升业务处理能力。
c++ KAFKA按时间戳存储消息消费时如何消费
05-19
在 Kafka 中，消息可以通过时间戳来进行查询和消费。在消费时，可以使用 Kafka 提供的 `seek()` 方法来指定消费的时间戳，具体步骤如下： 1. 创建 Kafka 消费者对象，并设置消费者属性。 2. 调用 `assign()` 方法，指定消费者消费的分区。 3. 调用 `seekToBeginning()` 或 `seekToEnd()` 方法，将消费者定位到分区的起始位置或末尾位置。 4. 调用 `seek()` 方法，将消费者定位到指定时间戳的位置。 5. 调用 `poll()` 方法，从 Kafka 中拉取消息并进行消费。 下面是一个简单的 C++ 代码示例： ```c++ rdkafka::Consumer *consumer; rdkafka::TopicPartition *partition; rdkafka::Message *message; rdkafka::ErrorCode err; // 创建 Kafka 消费者对象 consumer = rdkafka::Consumer::create(config, err); if (!consumer) { // 处理错误 } // 指定消费者消费的分区 partition = rdkafka::TopicPartition::create(topic, partition_id, timestamp); err = consumer->assign({partition}); if (err != rdkafka::ErrorCode::ERR_NO_ERROR) { // 处理错误 } // 将消费者定位到指定时间戳的位置 err = consumer->seek(*partition, timeout_ms); if (err != rdkafka::ErrorCode::ERR_NO_ERROR) { // 处理错误 } // 从 Kafka 中拉取消息并进行消费 while (true) { message = consumer->consume(timeout_ms); if (!message) { // 处理超时 continue; } if (message->err() != rdkafka::ErrorCode::ERR_NO_ERROR) { // 处理错误 continue; } // 处理消息 } ```

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

ITKaven

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值