Kafka入门（四）Consumer

最新推荐文章于 2024-05-11 07:19:19 发布
最新推荐文章于 2024-05-11 07:19:19 发布
阅读量739 收藏 1
点赞数
分类专栏： kafka 中间件 文章标签： kafka
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_36215047/article/details/117202530
版权

Consumer注意事项

◆单个分区的消息 只能由ConsumerGroup中某个Consumer消费

◆Consumer从Partition中消费消息 是顺序，默认从头开始消费

◆单个ConsumerGroup会消费所有Partition中的消息

 

Consumer : Producer=>1:1/1:n

一个Producer不能对应同一个Consumer Group 多个Consumer

代码示例以及说明

package com.item.kafka.consumer;

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.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.TopicPartition;

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

public class ConsumerSample {
    private final static String TOPIC_NAME = "demo1";

    public static void main(String[] args) {
        helloworld();
        // 手动提交offset
//        commitedOffset();
        // 手动对每个Partition进行提交
//        commitedOffsetWithPartition();
        // 手动订阅某个或某些分区，并提交offset
//        commitedOffsetWithPartition2();
        // 手动指定offset的起始位置，及手动提交offset
//        controlOffset();
    }

    /**
     * 工作里这种用法，有，但是不推荐
     *     最简单，上面都不用去配置
     */
    private static void helloworld() {
        Properties props = new Properties();
        //
        props.setProperty("bootstrap.servers", "127.0.0.1:9092");
        //消费分组
        props.setProperty("group.id", "test");
        //自动提交
        props.setProperty("enable.auto.commit", "true");
        //提交间隔
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);
        // 消费订阅哪一个Topic或者几个Topic
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            for (ConsumerRecord<String, String> record : records) {
                System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                        record.partition(), record.offset(), record.key(), record.value());
            }
        }
    }


    /**
     * 手动提交offset
     */
    private static void commitedOffset() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "127.0.0.1:9092");
        //消费分组
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);
        // 消费订阅哪一个Topic或者几个Topic
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            for (ConsumerRecord<String, String> record : records) {
                // 想把数据保存到数据库，成功就成功，不成功...
                System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                        record.partition(), record.offset(), record.key(), record.value());
                // 如果失败，则回滚， 不要提交offset
            }

            // 如果成功，手动通知offset提交 如果消费之后没有commitAsync，则下次启动还会消费上次数据
            consumer.commitAsync();
        }
    }


    /**
     * 手动提交offset,并且手动控制partition
     */
    private static void commitedOffsetWithPartition() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "127.0.0.1:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

        KafkaConsumer<String, String> consumer = new KafkaConsumer(props);
        // 消费订阅哪一个Topic或者几个Topic
        consumer.subscribe(Arrays.asList(TOPIC_NAME));
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理  =》好处   partition，从第二次开始循环partition 不会循环检查之前成功的
            for (TopicPartition partition : records.partitions()) {
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());

                }
                //本次获取offset的数量
                long lastOffset = pRecord.get(pRecord.size() - 1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                //服务器上记录的offset是我们下一次消费的起点。 所以必须+1.以免下次消费重复数据
                offset.put(partition, new OffsetAndMetadata(lastOffset + 1));//下一次
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - " + partition + " end================");
            }
        }
    }


    /**
     * 手动提交offset,并且手动控制partition,更高级
     */
    private static void commitedOffsetWithPartition2() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "127.0.0.1:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

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

        // jiangzh-topic - 0,1两个partition
        TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);
        TopicPartition p1 = new TopicPartition(TOPIC_NAME, 1);

        // 消费订阅哪一个Topic或者几个Topic
//        consumer.subscribe(Arrays.asList(TOPIC_NAME));

        // 消费订阅某个Topic的某个分区
        consumer.assign(Arrays.asList(p0));

        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理
            for (TopicPartition partition : records.partitions()) {
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());

                }
                long lastOffset = pRecord.get(pRecord.size() - 1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                offset.put(partition, new OffsetAndMetadata(lastOffset + 1));
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - " + partition + " end================");
            }
        }
    }


    /**
     *  手动指定offset的起始位置，及手动提交offset
     */
    private static void controlOffset() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "127.0.0.1:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

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

        // jiangzh-topic - 0,1两个partition
        TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);

        // 消费订阅某个Topic的某个分区
        consumer.assign(Arrays.asList(p0));

        while (true) {
            // 手动指定offset起始位置
            /*
                1、人为控制offset起始位置
                2、如果出现程序错误，重复消费一次
             */
            /*
                1、第一次从0消费【一般情况】
                2、比如一次消费了100条， offset置为101并且存入Redis
                3、每次poll之前，从redis中获取最新的offset位置
                4、每次从这个位置开始消费
             */
            consumer.seek(p0, 700);

            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理
            for (TopicPartition partition : records.partitions()) {
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.err.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());

                }
                long lastOffset = pRecord.get(pRecord.size() - 1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                offset.put(partition, new OffsetAndMetadata(lastOffset + 1));
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - " + partition + " end================");
            }
        }
    }


    /**
     *  流量控制 - 限流
     *  kafka的吞吐量很高，性能高，但是一台服务器不可能所有的字段按全给它。所以需要进行限流操作
     */
    private static void controlPause() {
        Properties props = new Properties();
        props.setProperty("bootstrap.servers", "127.0.0.1:9092");
        props.setProperty("group.id", "test");
        props.setProperty("enable.auto.commit", "false");
        props.setProperty("auto.commit.interval.ms", "1000");
        props.setProperty("key.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");
        props.setProperty("value.deserializer", "org.apache.kafka.common.serialization.StringDeserializer");

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

        // jiangzh-topic - 0,1两个partition
        TopicPartition p0 = new TopicPartition(TOPIC_NAME, 0);
        TopicPartition p1 = new TopicPartition(TOPIC_NAME, 1);

        // 消费订阅某个Topic的某个分区
        consumer.assign(Arrays.asList(p0, p1));
        long totalNum = 40;
        while (true) {
            ConsumerRecords<String, String> records = consumer.poll(Duration.ofMillis(10000));
            // 每个partition单独处理
            for (TopicPartition partition : records.partitions()) {
                List<ConsumerRecord<String, String>> pRecord = records.records(partition);
                long num = 0;
                for (ConsumerRecord<String, String> record : pRecord) {
                    System.out.printf("patition = %d , offset = %d, key = %s, value = %s%n",
                            record.partition(), record.offset(), record.key(), record.value());
                    /*
                        1、接收到record信息以后，去令牌桶中拿取令牌
                        2、如果获取到令牌，则继续业务处理
                        3、如果获取不到令牌， 则pause等待令牌
                        4、当令牌桶中的令牌足够， 则将consumer置为resume状态
                     */
                    num++;
                    if (record.partition() == 0) {
                        if (num >= totalNum) {
                            consumer.pause(Arrays.asList(p0));
                        }
                    }

                    if (record.partition() == 1) {
                        if (num == 40) {
                            consumer.resume(Arrays.asList(p0));
                        }
                    }
                }

                long lastOffset = pRecord.get(pRecord.size() - 1).offset();
                // 单个partition中的offset，并且进行提交
                Map<TopicPartition, OffsetAndMetadata> offset = new HashMap<>();
                offset.put(partition, new OffsetAndMetadata(lastOffset + 1));
                // 提交offset
                consumer.commitSync(offset);
                System.out.println("=============partition - " + partition + " end================");
            }
        }
    }


}

 

 

 

楚景然
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
kafka 主动消费_Kafka核心API——Consumer消费者
weixin_39908985的博客
12-20 300
Consumer之自动提交在上文中介绍了Producer API的使用，现在我们已经知道如何将消息通过API发送到Kafka中了，那么现在的生产者/消费者模型就还差一位扮演消费者的角色了。因此，本文将介绍Consumer API的使用，使用API从Kafka中消费消息，让应用成为一个消费者角色。还是老样子，首先我们得创建一个Consumer实例，并指定相关配置项，有了这个实例对象后我们才能进行其他...
Kafka之Consumer
jannal专栏
09-22 394
文章目录kafka版本声明基础消费组rebalance提交偏移量测试不提交情况 kafka版本声明 使用的是kafka 0.10.0.1版本 参考文献 《kafka权威指南》 基础 Push(推送)方式是broker接收到消息后，主动把消息推送到Consumer(消费者) 优点:实时性高 缺点: 加大broker的工作量，影响broker性能. Consumer(消费者)的处理能...
2024年Go最新Kafka学习 — 3 kafka消费者客户端，职场中的中年危机
最新发布
2401_84911559的博客
05-11 274
【代码】2024年Go最新Kafka学习 — 3 kafka消费者客户端，职场中的中年危机。
KafkaConsumer
sunning9001的专栏
03-27 602
KafkaConsumer 可以从Kafka集群中消费记录。KafkaConsumer 客户端明确的处理Kafka Brokers的失败,并且明确的在Kafka集群中获取topic分区信息。KafkaConsumer 同时与Broker进行交互,并且允许consumer中的KafkaConsumer实例来负载均衡的消费记录。KafkaConsumer 保持与Kafka 集群中的broker TCP...
Kafka多线程Consumer
大数据流动
08-18 136
多线程示例代码：这里要根据自身需求开发，我这里只举一个简单的例子，就是几个分区就启动几个consumer，一一对应。 三个类： Main： public static void main...
Qt学习系列之学习积累1
arriettyandray的博客
10-14 177
Qt学习系列之学习积累11-foreach2-Q_UNUSED3-TCP与DUPTCPDUP4-定时器使用5-QMessageBoxQuestion消息框Information消息框Warning消息框Critical消息框About消息框AboutQt消息框自定义QMessageBox6-删除 1-foreach foreach(variable ,container); foreach有点类似于for，container是包含了所有的可能，而variable是其中的一种。 QStringList sl
java kafka 入门
12-03
3. Consumer：消费者负责从 Kafka topic 中消费消息。 Kafka 的工作流程是：生产者将消息发送到 Kafka topic 中，Broker 负责存储和处理消息，而消费者则从 topic 中消费消息。 Kafka 的优点 Kafka 的优点包括： ...
Kafka入门教程与详解
08-15
Kafka入门教程与详解 Kafka是分布式发布-订阅消息系统，由 LinkedIn 公司开发，使用 Scala 语言编写，后成为 Apache 项目的一部分。Kafka 集群中没有“中心主节点”的概念，集群中所有的服务器都是对等的，因此，...
Kafka入门demo
09-01
Apache Kafka入门demo，用来理解Apache Kafka的基本原理，附带必要代码注释。基于maven的用Java api编写的Producer和Consumer；
kafka企业级入门
01-07
1.kafka概述 什么是kafka？ kafka是一个消息系统，消息中间件，是一个高吞吐量的分布式发布订阅消息系统。 2.kafka角色介绍 broker：kafka集群包含一个或多个...consumer：每个consumer属于一个特定的consumer group。
kafka入门介绍
03-06
kafka集群的概念以及基本原理的介绍，kafka的consumer
Kafka消费者深层讲解
m0_57126456的博客
10-25 319
一：消费方式 consumer 采用 pull（拉）模式从 broker 中读取数据。 push（推）模式很难适应消费速率不同的消费者，因为消息发送速率是由 broker 决定的。 它的目标是尽可能以最快速度传递消息，但是这样很容易造成 consumer 来不及处理消息， 典型的表现就是拒绝服务以及网络拥塞。而 pull 模式则可以根据 consumer 的消费能力以适 当的速率消费消息。 pull 模式不足之处是，如果 kafka 没有数据，消费...
Kafka消费者详解
yfy的博客
05-28 2190
一.基本概念 1.消费者和消费组 Kafka消费者是消费组的一部分，当多个消费者形成一个消费组来消费主题时，每个消费者会收到不同分区的消息。假设有一个T1主题，该主题有4个分区；同时我们有一个消费组G1，这个消费组只有一个消费者C1。那么消费者C1将会收到这4个分区的消息，如下所示： Kafka一个很重要的特性就是，只需写入一次消息，可以支持任意多的应用读取这个消息。换句话说，每个应用都可以读到全量的消息。为了使得每个应用都能读到全量消息，应用需要有不同的消费组。对于上面的例子，假如我们新增.
Kafka Consumer如何实现精确一次消费数据
大JAVA解决方案
10-28 2237
文章目录 简介 kafka消费机制 消费时出现几种异常情况 自动提交 手动提交 精确一次消费实现 总结 简介 在使用kafka时，大多数场景对于数据少量的不一致（重复或者丢失）并不关注，比如日志，因为不会影响最终的使用或者分析，但是在某些应用场景（比如业务数据），需要对任何一条消息都要做到精确一次的消费，才能保证系统的正确性，kafka并不提供准确一致的消费API，需要我们在实际使用时借用外部的一些手段来保证消费的精确性，下面我们介绍如何实现 ...
Kafka学习(3)-----消费者
zh328271057的博客
05-30 1342
思维导图： 引言 这篇文章的主要内容是介绍Kafka消费者的一般的使用流程以及比较特殊的操作，所以本文共分为以下两个部分： 基本流程 ： 主要包括创建实例，消息订阅，消息消费，位移提交，消费控制等内容。 其他处理 ： 主要是一些其他的处理，例如指定位移消费，消费者拦截器等操作。 一.基本流程 Kafka消费者的基本流程一般来说都是必要的。也代表着消费者的基本使用逻辑。...
Kafka 入门学习
10-27 789
1 初识KafKa 1.1基本概念 1.Producer:生产者，生产者负责创建消息，投递到Kafka中 2.Consumer:消费者，连接到KafKa上，并接收消息，进行处理。 3.Broker：独立的Kafka服务节点或者服务实例。 4.Topic: Kafka中消息以主题为单位进行归类。生产这将消息发送到特定的主题（每一个消息都需要指定主题），消费者负责订阅主题并进行消费。 5.Partition:主题是一个逻辑上的概念，他可以细分为多个分区。 同一主题下的不同分区包含的消息不同。分区在
SpringBoot+Kafka实现单条或批量消费
zhuchunyan_aijia的博客
11-24 2504
配置文件 # application.yml spring: kafka: bootstrap-servers: 192.168.1.117:9092 producer: # 重试次数 retries: 3 # 批量发送的消息数量 batch-size: 16384 # 32MB的批处理缓冲区 buffer-memory
编码技巧——@KafkaListener的使用
热门推荐
娜娜米的博客
08-08 1万+
最近在接手某个项目代码时，发现关于Kafka的consumer相关的代码写的很乱，consumer中写了大量的配置的代码，并且手动的拉取消息，并开启线程消费，不够优雅； 理想的做法是单独维护kafka的consumer配置，在定义consumer的bean时，指定topic和group，仅实现消费逻辑； 从kafka-clients的2.2.4版本开始，可以直接使用@KafkaListener注解来标记消费者，注解的属性将覆盖在消费者者工厂中配置的具有相同名称的所有属性，下面介绍使用方法；.........
kafka读书笔记-消费者-poll调用及返回
gaording的博客
04-29 2852
消费者订阅主题或者分区之后就会对主题和分区中的消息进行消费，Kafka中的消费是基于拉模式的，即客户端主动请求服务器拉取消息。与之对应的另一种常见消费模式是推模式，即服务端主动将消息推送给客户端。拉模式减少了服务端的压力，对于Kafka处理大数据量的时候能起到高效的作用。 简单的消费者消费代码如下: while (true){ //拉取消息 ConsumerRecords<Stri...
kafka从入门到精通
10-20
1.了解Kafka的基本概念，例如broker、topic、partition、producer、consumer等等。 2.学习如何安装和配置Kafka，包括修改broker.id、log.dir等参数。 3.学习如何创建topic、生产者和消费者程序，并了解它们之间的...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值