Spring Kafka消费模式（single, batch）及确认模式（自动、手动）示例

已于 2022-03-06 09:29:37 修改
阅读量2.1w 收藏 72
点赞数 22
分类专栏： mq # kafka # springboot 文章标签： kafka spring 消息队列
于 2022-01-03 12:01:43 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/luo15242208310/article/details/122285689
版权

目录

Spring Kafka消费消息的模式分为2种模式（对应spring.kafka.listener.type配置）：

  • single - 每次消费单条记录
  • batch - 批量消费消息列表

且每种模式都分为2种提交已消费消息offset的ack模式：

  • 自动确认
  • 手动确认

接下来依次讲解这两种消费模式及其对应的ack模式的示例配置及代码。

1. 单记录消费listener.type=single

本章节先来讲讲record模式 - 单记录消费，且分为自动确认和手动确认2种方式来提交已消费消息offset。

1.1 单记录消费 - 自动确认

即由Spring Kafak框架按照配置规则自动提交已消费消息offset，无需程序手动编码控制。

需注意如下对应配置：

# ============ 方式1：定时自动提交[不推荐] =====================
# 开启自动提交（按周期）已消费offset
spring.kafka.consumer.enable-auto-commit: true
# 自动提交已消费offset时间价格（配置enable-auto-commit=true时使用）
spring.kafka.consumer.auto-commit-interval: 1s


# ========= 方式2：通过ack-mode设置自动提交[推荐] =============
# 禁用自动提交（按周期）已消费offset
spring.kafka.consumer.enable-auto-commit: false
# listener类型为单条记录single类型（默认为single单条消费模式）
spring.kafka.listener.type: single
# offset提交模式为record
spring.kafka.listener.ack-mode: record

注：
关于消费者提交已消费消息offset的相关配置说明：

  • spring.kafka.consumer.enbable-auto-commit
    • true 自动提交已消费消息offset
      • auto-commit-interval 设置自动提交间隔
    • fasle 由程序控制已消费消息offset提交
      • spring.kafka.listener.ack-mode 已消费offset提交模式

spring.kafka.listener.ack-mode列表（详细说明参见：SpringKafka - Committing Offsets）

ack-mode模式说明自动提交
RECORD
单记录		当每一条记录被消费者监听器（ListenerConsumer）处理之后提交✔️
BATCH（默认）
批量		当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后提交✔️
TIME
超时		当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，距离上次提交时间大于TIME时提交
(通过spring.kafka.listener.ack-time设置触发时间)		✔️
COUNT
超过消费数量		当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，被处理record数量大于等于COUNT时提交
(通过spring.kafka.listener.ack-count设置触发数量)		✔️
COUNT_TIME
超时或超数量		TIME或COUNT　有一个条件满足时提交✔️
MANUAL
手动提交（ack）后同BATCH		当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交❌
需要手动使用
Acknowledgment参数提交
MANUAL_IMMEDIATE
手动立即提交		手动调用Acknowledgment.acknowledge()后立即提交❌
需要手动使用
Acknowledgment参数提交

消费端配置示例1 - 定时自动提交[不推荐]

spring:
  kafka:
    # 逗号分隔的集群broker列表
    bootstrap-servers: localhost:9092
    # ====================================================
    # ================== 消费者配置 ========================
    # ====================================================
    consumer:
      # 自动提交（按周期）已消费offset
      enable-auto-commit: true
      # 自动提交已消费offset时间价格（配置enable-auto-commit=true时使用）
      auto-commit-interval: 1s
      ...
    # ====================================================
    # ============= 消费者监听器（及线程池）配置 ==============
    # ====================================================
    listener:
      # listener类型
      # single | batch
      type: single
    # ====================================================
    # ============= 具体业务Kafka定义=======================
    # ====================================================
    biz1:
      topic: topic1
      consumer:
        group: group1

消费端配置示例2 - 通过ack-mode设置自动提交[推荐]
listener自动提交offsetd的ack-mode模式包括：RECORD | BATCH | TIME | COUNT | COUNT_TIME ，
且使用相关自动模式不可在@KafkaListener标注方法中使用Acknowledgment参数。

spring:
  kafka:
    # 逗号分隔的集群broker列表
    bootstrap-servers: localhost:9092
    # ====================================================
    # ================== 消费者配置 ========================
    # ====================================================
    consumer:
      # 禁用自动提交（按周期）已消费offset
      enable-auto-commit: false
      ...
    # ====================================================
    # ============= 消费者监听器（及线程池）配置 ==============
    # ====================================================
    listener:
      # listener类型
      # single | batch
      type: single
      # 已消费offset提交模式（仅在enable-auto-commit=false时才需明确指定）
      # 单记录  | 批量         | 超时  | 超过消费数量 | 超时或超过数量 | 手动提交（ack）后同BATCH | 手动立即提交
      # RECORD | BATCH（默认） | TIME | COUNT      | COUNT_TIME   | MANUAL                | MANUAL_IMMEDIATE
      # https://docs.spring.io/spring-kafka/docs/current/reference/html/#committing-offsets
      # 注：listener自动提交offset模式包括：RECORD | BATCH | TIME | COUNT | COUNT_TIME ，
      #    且使用相关自动模式不可在@KafkaListener标注方法中使用Acknowledgment参数
      ack-mode: record
    # ====================================================
    # ============= 具体业务Kafka定义=======================
    # ====================================================
    biz1:
      topic: topic1
      consumer:
        group: group1

消费端代码示例

/**
 * 定义biz1消息接收者
 *
 * @param message
 * @rabbit.exhange exchange1
 * @rabbit.aueue queue1
 * @rabbit.bindingKey #
 */
@KafkaListener(
        id = "biz1-${spring.kafka.biz1.consumer.group}",
        groupId = "${spring.kafka.biz1.consumer.group}",
        topics = "${spring.kafka.biz1.topic}")
public void biz1Consumer(String message) {
    log.info("[biz1Consumer] RECV MSG: {}", message);
}

1.2 单记录消费 - 手动确认

需注意如下对应配置：

# 禁用自动提交（按周期）已消费offset
spring.kafka.consumer.enable-auto-commit: false
# listener类型为单条记录single类型（默认为single单条消费模式）
spring.kafka.listener.type: single
# offset提交模式为manual_immediate
spring.kafka.listener.ack-mode: manual_immediate

消费端配置示例
手动提交offset的ack-mode模式包括：MANUAL | MANUAL_IMMEDIATE，
且使用相关手动模式需在@KafkaListener标注方法中使用Acknowledgment参数。

spring:
#  profiles:
#    active: kafka-origin
  kafka:
    # 逗号分隔的集群broker列表
    bootstrap-servers: localhost:9092
    # ====================================================
    # ================== 消费者配置 ========================
    # ====================================================
    consumer:
      # 禁用自动提交（按周期）已消费offset
      enable-auto-commit: false
      ...
    # ====================================================
    # ============= 消费者监听器（及线程池）配置 ==============
    # ====================================================
    listener:
      # listener类型
      # single | batch
      type: single
      # 已消费offset提交模式（仅在enable-auto-commit=false时才需明确指定）
      # 单记录  | 批量   | 超时  | 超过消费数量 | 超时或超过数量 | 手动提交（ack）后同BATCH | 手动立即提交
      # RECORD | BATCH | TIME | COUNT      | COUNT_TIME   | MANUAL                | MANUAL_IMMEDIATE
      # https://docs.spring.io/spring-kafka/docs/current/reference/html/#committing-offsets
      # 注：手动提交offset模式包括：MANUAL | MANUAL_IMMEDIATE
      #    且使用相关手动模式需在@KafkaListener标注方法中使用Acknowledgment参数
      ack-mode: manual_immediate

消费端代码示例
参考：SpringKafka - Manual Acknowledgment

/**
 * 定义biz1消息接收者
 *
 * @param message
 * @kafka.topic topic1
 * @kafka.group group1
 */
@KafkaListener(
        id = "biz1-${spring.kafka.biz1.consumer.group}",
        groupId = "${spring.kafka.biz1.consumer.group}",
        topics = "${spring.kafka.biz1.topic}")
public void biz1Consumer(String message, Acknowledgment ack) {
    log.info("[biz1Consumer] RECV MSG: {}", message);
    //确认单当前消息（及之前的消息）offset均已被消费完成
    ack.acknowledge();
    //拒绝当前消息（此方法仅适用于listener.type=single）
    //当前poll查询出的剩余消息记录均被抛弃，
    //且当前消费线程在阻塞指定sleep（如下3000毫秒）后重新调用poll获取待消费消息（包括之前poll被抛弃的消息）
    //ack.nack(3000)
}

2. 批量消费listener.type=batch

在一些需要通过批量处理消息的场景中，SpringKafka支持使用Batch Listeners，即批量处理消息列表。
本章节主要讲解batch模式 - 批量消费，且同样分为自动确认和手动确认2种方式来提交已消费消息offset。

2.1 批量消费 - 自动确认

需注意如下对应配置：

# 禁用自动提交（按周期）已消费offset
spring.kafka.consumer.enable-auto-commit: false
# 批量消费的单次最大消费记录数
spring.kafka.consumer.max-poll-reocrds: 50
# listener类型为批量batch类型（默认为single单条消费模式）
spring.kafka.listener.type: batch
# offset提交模式为batch（不可使用record - 启动报错）
spring.kafka.listener.ack-mode: batch

配置示例如下

spring:
  kafka:
    # 逗号分隔的集群broker列表
    bootstrap-servers: localhost:9092
    # ====================================================
    # ================== 消费者配置 ========================
    # ====================================================
    consumer:
      # 禁用自动提交（按周期）已消费offset
      enable-auto-commit: false
      # 单次poll()调用返回的记录数
      max-poll-records: 50
    # ====================================================
    # ============= 消费者监听器（及线程池）配置 ==============
    # ====================================================
    listener:
      # listener类型
      # single | batch
      type: batch
      # 已消费offset提交模式（仅在enable-auto-commit=false时才需明确指定）
      # 单记录  | 批量   | 超时  | 超过消费数量 | 超时或超过数量 | 手动提交（ack）后同BATCH | 手动立即提交
      # RECORD | BATCH | TIME | COUNT      | COUNT_TIME   | MANUAL                | MANUAL_IMMEDIATE
      # https://docs.spring.io/spring-kafka/docs/current/reference/html/#committing-offsets
      ack-mode: batch
    # ====================================================
    # ============= 具体业务Kafka定义=======================
    # ====================================================
    biz1:
      topic: topic1
      consumer:
        group: group1
    biz2:
      topic: topic2
      consumer:
        group: group2
        # 分区格式示例：0 | 0,1,2 | 0-3 
        partitions: 0

消费端代码示例

/**
 * 定义biz1消息接收者
 * 自动模式（无需手动ack）：
 * 1. listener.type=batch
 * 2. ack-mode=batch
 *
 * @param messages
 * @kafka.topic topic1
 * @kafka.group group1
 */
@KafkaListener(
        id = "biz1-${spring.kafka.biz1.consumer.group}",
        groupId = "${spring.kafka.biz1.consumer.group}",
        topics = "${spring.kafka.biz1.topic}")
public void biz1Consumer(List<String> messages) {
    log.info("[biz1Consumer] RECV MSG COUNT: {}", messages.size());
    log.info("[biz1Consumer] RECV MSG[0]: {}", messages.get(0));
}

/**
 * 定义biz2消息接收者
 * 自动模式（无需手动ack）：
 * 1. listener.type=batch
 * 2. ack-mode=batch
 * 
 * @param messages
 * @kafka.topic topic2
 * @kafka.group group2
 */
@KafkaListener(
        id = "biz2-${spring.kafka.biz2.consumer.group}",
        groupId = "${spring.kafka.biz2.consumer.group}",
        //消费指定分区
        topicPartitions = {
                @TopicPartition(topic = "${spring.kafka.biz2.topic}", partitions = "${spring.kafka.biz2.consumer.partitions}")
        })
public void biz2Consumer(List<Message> messages) {
    log.info("[biz2Consumer] RECV MSG COUNT: {}", messages.size());
    log.info("[biz2Consumer] RECV MSG[0]: {}", messages.get(0));
}

在这里插入图片描述

2.2 批量消费 - 手动确认

需注意如下对应配置：

# 禁用自动提交（按周期）已消费offset
spring.kafka.consumer.enable-auto-commit: false
# 批量消费的单次最大消费记录数
spring.kafka.consumer.max-poll-reocrds: 50
# listener类型为批量batch类型（默认为single单条消费模式）
spring.kafka.listener.type: batch
# offset提交模式为batch（不可使用record - 启动报错）
spring.kafka.listener.ack-mode: manual

配置示例如下

spring:
  kafka:
    # 逗号分隔的集群broker列表
    bootstrap-servers: localhost:9092
    # ====================================================
    # ================== 消费者配置 ========================
    # ====================================================
    consumer:
      # 禁用自动提交（按周期）已消费offset
      enable-auto-commit: false
      # 单次poll()调用返回的记录数
      max-poll-records: 50
    # ====================================================
    # ============= 消费者监听器（及线程池）配置 ==============
    # ====================================================
    listener:
      # listener类型
      # single | batch
      type: batch
      # 已消费offset提交模式（仅在enable-auto-commit=false时才需明确指定）
      # 单记录  | 批量   | 超时  | 超过消费数量 | 超时或超过数量 | 手动提交（ack）后同BATCH | 手动立即提交
      # RECORD | BATCH | TIME | COUNT      | COUNT_TIME   | MANUAL                | MANUAL_IMMEDIATE
      # https://docs.spring.io/spring-kafka/docs/current/reference/html/#committing-offsets
      ack-mode: manual
    # ====================================================
    # ============= 具体业务Kafka定义=======================
    # ====================================================
    biz1:
      topic: topic1
      consumer:
        group: group1
    biz2:
      topic: topic2
      consumer:
        group: group2
        partitions: 0

消费端代码示例

/**
 * 定义biz1消息接收者
 * 手动模式（需手动ack）：
 * 1. listener.type=batch
 * 2. ack-mode=manual
 *
 * @param messages
 * @kafka.topic topic1
 * @kafka.group group1
 */
@KafkaListener(
        id = "biz1-${spring.kafka.biz1.consumer.group}",
        groupId = "${spring.kafka.biz1.consumer.group}",
        //仅在多partition单个消费者时，用于多线程消费消息（concurrency <= partition数量）
        //当存在多个消费者时，即便设置concurrency > 1也仅有唯一消费线程生效
        concurrency = "${spring.kafka.biz1.consumer.concurrency}",
        topics = "${spring.kafka.biz1.topic}")
public void biz1Consumer(List<String> messages, Acknowledgment ack) {
    log.info("[biz1Consumer] RECV MSG COUNT: {}", messages.size());
    log.info("[biz1Consumer] RECV MSG[0]: {}", messages.get(0));
    //确认单当前消息（及之前的消息）offset均已被消费完成
    ack.acknowledge();

    //拒绝消息列表中指定index（发生错误的消息index）对应的消息（此方法仅适用于listener.type=batch），
    //当前指定index之前的消息会被成功提交，
    //当前poll查询出的剩余消息记录（包括当前指定的index）均被抛弃，
    //且当前消费线程在阻塞指定sleep（如下3000毫秒）后重新调用poll获取待消费消息（包括当前index及之前poll抛弃的消息）
    //如下即确认当前list中前5条消息（0-4），抛弃当前list中后续消息，3秒后再次poll查询未消费消息
    //ack.nack(5, 3000);
}


/**
 * 定义biz2消息接收者
 * 手动模式（需手动ack）：
 * 1. listener.type=batch
 * 2. ack-mode=manual
 * 
 * @param messages
 * @kafka.topic topic2
 * @kafka.group group2
 */
@KafkaListener(
        id = "biz2-${spring.kafka.biz2.consumer.group}",
        groupId = "${spring.kafka.biz2.consumer.group}",
        //消费指定分区
        topicPartitions = {
                @TopicPartition(topic = "${spring.kafka.biz2.topic}", partitions = "${spring.kafka.biz2.consumer.partitions}")
        })
public void biz2Consumer(List<Message> messages, Acknowledgment ack) {
    log.info("[biz2Consumer] RECV MSG COUNT: {}", messages.size());
    log.info("[biz2Consumer] RECV MSG[0]: {}", messages.get(0));
    //确认单当前消息（及之前的消息）offset均已被消费完成
    ack.acknowledge();
}

3. 手动模式下的acknowledge和nack方法

在手动确认模式下，除了支持ack.acknowledge()方法用于确认单条记录（对应record模式）或者批次记录（对应batch模式），
还支持nack方法用于拒绝消息，关于acknowledge和nack方法的详细使用见下表：

方法说明适用listener.type
acknowledge()确认单条消息 或 整批消息single
batch
nack(sleepMills)拒绝确认当前消息，
当前poll查询出的剩余消息记录均被抛弃，
且当前消费线程在阻塞指定sleepMills时间后
会重新调用poll获取待消费消息（包括之前poll被抛弃的消息）		single
nack(index, sleepMills)拒绝消息列表中指定index（发生错误的消息index）及其之后index对应的消息，
当前指定index之前的消息会被成功提交，
当前poll查询出的剩余消息记录（包括当前指定的index）均被抛弃，
且当前消费线程在阻塞指定sleepMills时间后
会重新调用poll获取待消费消息（包括当前index及之前poll抛弃的消息）		batch
SpringBoot 集成 Kafka消息中间件，Docker安装Kafka环境
yunnuo的博客
12-28 855
提供kafka、zooker在docker环境下进行安装的示例，springBoot集成kafka实现producer-生产者和consumer-消费者(监听消费：single模式和batch模式)的功能实现。下面示例是采用API方式进行调用发送kafka消息，进行模拟生产者。
Kafka中的enable-auto-commit和auto-commit-interval配置
北辰
12-16 6620
Kafka中的enable-auto-commit和auto-commit-interval配置
超详细讲解Kafka消费者，让你看完就懂！（概念、消息接收）
热门推荐
Java_Yhua的博客
12-10 1万+
目录第1章 消费者详解1.1 概念入门1.1.1 消费者和消费组1.2 消息接收1.2.1 必要参数设置1.2.2 订阅主题和分区1.2.2 反序列化1.2.3 位移提交1.2.4 指定位移消费1.2.4 再均衡监听器1.2.5 消费者拦截器1.2.6 消费者参数补充总结 第1章 消费者详解 tips 学完这一章你可以、 深入学习Kafka数据消费大致流程 如何创建并使用Kafka消费者 Kafka消费者常用配置 1.1 概念入门 1.1.1 消费者和消费组 Kafka消费者是消费组的一部分，当多个消费
SpringBoot 集成 Kafka
最新发布
weixin_46668257的博客
03-12 4390
Kafka 也是是我们在开发过程中经常会使用的一种消息队列Kafka的核心概念包括Producer、Consumer、Broker、Topic、Partition和Offset。Producer：生产者，负责将数据发送到Kafka集群。Consumer：消费者，从Kafka集群中读取数据。Broker：Kafka服务器实例，Kafka集群通常由多个Broker组成。Topic：主题，数据按主题进行分类。Partition：分区，每个主题可以有多个分区，用于实现并行处理和提高吞吐量。
RocketMQ入门
qq_43050847的博客
09-10 1033
文章目录什么是MQ为何用消息队列linux下安装RocketMQRocketMQ监控平台springboot整合同步发送对象异步消息单向消息顺序消息延时消息批量消息事务消息消息过滤RocketMQ集群实战场景（逾期订单的状态修改）实战场景（rpc下的异步处理） 什么是MQ 消息队列（Message Queue），是一种应用程序对应用程序的通信方法，是分布式系统的重要组件。 为何用消息队列 可以解决一些应用场景的高并发问题。 当不需要立即获得结果，但是并发量又需要进行控制的时候，差不多就是需要使用MQ来处
SpringBoot集成kafka-监听器手动确认接收消息（主要为了保证业务完成后再确认接收）
qq_46112274的博客
08-24 1247
SpringBoot集成kafka-监听器手动确认接收消息（主要为了保证业务完成后再确认接收）
Kafka源码分析之RecordBatch
weixin_33725722的博客
04-10 272
RecordBatch是Kafka中Producer中对批量记录的一个封装，它表示正在或将要被发送的一批记录。这个类不是线程安全的，当修改它时必须使用外部同步。RecordBatch中的成员变量如下： // 记录数目recordCount public int recordCount = 0; // ...
【Kafka精进系列004】Spring Boot + Kafka消息生产与消费代码示例
noaman_wgs的博客
12-29 3788
通过本文，你可以学到： (1)Kafka生产者异步发送API介绍； (2)Kafka生产者消息发送的代码实现； (3)Kafka生产者发送的消息不丢失的配置参数； (4)Kafka消费者常见的两种消费方案设计（单实例与多实例以及多线程消费）； (5)Spring Boot整合Kafka实现Kafka生产与消费的完整过程
kafka 示例（spring boot）批量消费
weixin_43931625的博客
10-25 3653
springbootkafka 批量消费 ************************************************ 使用示例 ********************************** application.yml spring: kafka: bootstrap-servers: 172.18.0.12:9092 ...
spring-kafka 多线程消费
weixin_41614713的博客
06-09 2651
引入依赖 dependencies { testCompile group: 'junit', name: 'junit', version: '4.12' // https://mvnrepository.com/artifact/org.springframework.boot/spring-boot-starter-web compile group: 'org.springframework.boot', name: 'spring-boot-starter-web' .
Spring Boot Kafka概览、配置及优雅地实现发布订阅
易名
12-26 2007
本文属于翻译，转载注明出处，欢迎关注微信小程序小白AI博客 微信公众号小白AI或者网站 https://xiaobaiai.net 文章目录1 前言2 Spring Kafka功能概览2.1 自动创建主题2.2 发送消息2.3 接收消息2.3.1 消息监听器2.3.1.1 消息监听器容器2.3.1.2 使用KafkaMessageListenerContainer2.3.1.3 使用 Concu...
spring-kafka-batch-listener.zip
10-08
spring-kafka顺序消费。 kafka顺序消费。 主要是为博客上传完整代码
大数据（三十二）：kafka消费过程
敲代码的旺财的博客
11-20 1158
一、kafka在zookeeper中的存储结构 producer不在zk中注册，消费者在zk中注册。   二、kafka消费过程分析 kafka提供了两套consumer API：高级Consumer Api和低级Api 1.高级Api 优点： 编写简单，不需要自行管理offset，系统通过zookeeper自行管理 不需要管理分区，副本等情况，系统自...
三.Kafka入门到精通-SpringBoot整合Kafka(同步&异步消息&事务消息&手动确认)
墨家巨子@俏如来
06-12 5636
前面两个章节我们把Kafka给安装起来然后使用命令演示是生产和消费的过程，以及Kafka的架构原理，接下来就是Kafka的实战使用，顺应如今企业流行的开发模式，当然要使用SpringBoot和Kafka进行整合。第一步：我们基于SpringBoot来快速入门Kafka，我这里使用的SpringBoot版本是2.2.5.RELEASE ，对应spring-kafka的版本是2.3.6，具体依赖如下： 第二步：导入依赖之后需要为SpringBoot创建启动类，在启动类中我们通过注解的方式创建一个Topic，如下
关于Kafka 的 consumer 消费者手动提交详解
weixin_34409822的博客
02-08 2279
前言 在上一篇 Kafka使用Java实现数据的生产和消费demo 中介绍如何简单的使用kafka进行数据传输。本篇则重点介绍kafka中的 consumer 消费者的讲解。 应用场景 在上一篇kafka的consumer消费者，我们使用的是自动提交offset下标。 但是offset下标自动提交其实在很多场景都不适用，因为自动提交是在kafka拉取到数据之后就直接提交，这样很容易丢失数据，尤其是...
Kafka（四）【Kafka 消费者】
功不唐捐，玉汝于成
01-25 6101
Kafka 消费者
聊聊Kafka的生产者消费者确认机制
Z__7Gk的博客
09-07 1119
消息从生产者客户端发送至broker服务端topic，需要ack确认。acks与min.insync.replicas是两个配置参数.其中acks是producer的配置参数，min.insync.replicas是Broker端的配置参数，这两个参数对于生产者不丢失数据起到了很大的作用
springkafka消费源码
09-03
Spring Kafka是Spring Framework的一个扩展模块，它为Kafka消息队列提供了更简单的集成方式。Spring Kafka对于消费者端的源码实现主要集中在以下几个方面： 1. 消息监听器容器：Spring Kafka通过`KafkaListenerContainer`接口定义了一个消息监听器容器，用于管理消息监听器的注册、启动、停止和管理消费者的线程池。消息监听器容器在初始化时会根据配置创建一个或多个`KafkaMessageListenerContainer`实例，并使用`ConcurrentMessageListenerContainer`作为默认实现。 2. 消息监听适配器：Spring Kafka提供了`KafkaMessageListenerContainer`和`MessageListenerAdapter`两个主要的接口来实现消息监听器的适配。`KafkaMessageListenerContainer`用于接收Kafka消息并将其传递给监听器方法进行处理。`MessageListenerAdapter`用于将接收到的Kafka消息转换为Java对象，并将其传递给实际的监听器方法进行处理。 3. 消息消费者的配置：Spring Kafka支持通过`@KafkaListener`注解或手动配置`KafkaMessageListenerContainer`来实现消费者的配置。通过注解方式，可以在方法上添加`@KafkaListener`注解，并指定要消费的Kafka主题、分区和消费者组。通过手动配置方式，可以通过`KafkaMessageListenerContainer`的相关配置来自定义消费者的一些属性，比如主题、分区、消费者组、消息过滤器等。 4. 消息消费的实现：在消息监听器方法中，可以通过`ConsumerRecord`参数接收到Kafka消息记录，并在方法内部对消息进行处理。根据业务需求可以对消息进行转换、存储、分析等操作。另外，Spring Kafka还提供了一些内置的类和工具，比如`KafkaTemplate`、`KafkaHeaders`等，用于简化消息的发送和处理。 总之，Spring Kafka通过对消息监听器容器、消息监听适配器和消息消费者的配置以及消息消费的实现等方面的源码实现，提供了一种简单、灵活的方式来集成和消费Kafka消息。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

罗小爬EX

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

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

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

打赏作者

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

抵扣说明：

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

余额充值