Spring Boot 整合——kafka消费模式AckMode以及手动消费

最新推荐文章于 2024-08-15 14:40:49 发布
最新推荐文章于 2024-08-15 14:40:49 发布
阅读量3.5w 收藏 75
点赞数 50
分类专栏： # Java异常 # Spring Boot常用组件 文章标签： kafka java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-NC-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq330983778/article/details/105937689
版权

Spring Boot 整合之前的内容

项目名称描述地址
base-data-mybatis整合mybatis-plus（实际上官方教程已经很多，只做了自定义插件）未完成
base-jpaJPA基础使用JPA 数据模型定义
base-jpa-queryJPA多表关联使用JPA 数据模型关联操作
base-log日志配置SpringBoot日志配置
base-rabbitrabbitMQ简单使用RabbitMQ基础使用
base-rabbit3rabbitMQ一些自定义配置消息确认回调、消息转换以及消息异常处理
base-rabbit-delayrabbitMQ延时队列延时队列和消息重试
base-redisredis简单使用RedisTemplate基础使用;Redis实现简单的发布订阅以及配置序列化方式
base-redis-lockredis分布式锁Redis分布式锁的简单实现
base-redis-delay基于有赞的延时消息方案的简单实现延时队列的简单实现
base-swaggerswagger使用wagger2使用
base-mongodbmongodb简单使用MongoDB安装以及Spring Boot整合,MongoDB实体创建以及简单CRUD,MongoDB聚合操作,MongoDB分组去重以及MongoDB联表查询

关于版本

依赖版本
springboot2.0.8.RELEASE
mongodb4.0.14

项目地址

因为涉及的代码较多，所以并不会贴出所有代码。本篇文章涉及的源码下载地址： https://gitee.com/daifyutils/springboot-samples

关闭自动消费

Spring-Boot-kafka的配置中有一个参数，提供了自动消费的功能。使用自动消费我们在收到消息的时候会自动向kafka确认消费。但是在一些特殊场景中我们可能需要使用一些其他的消费模式。

enable-auto-commit: true

kafka的消费模式

需要自己配置AckMode时候的配置

spring:
  application:
    name: base.kafka
  kafka:
    bootstrap-servers: kafka服务地址1:端口,kafka服务地址2:端口,kafka服务地址3:端口
    producer:
      # 写入失败时，重试次数。当leader节点失效，一个repli节点会替代成为leader节点，此时可能出现写入失败，
      # 当retris为0时，produce不会重复。retirs重发，此时repli节点完全成为leader节点，不会产生消息丢失。
      retries: 0
      #procedure要求leader在考虑完成请求之前收到的确认数，用于控制发送记录在服务端的持久化，其值可以为如下：
      #acks = 0 如果设置为零，则生产者将不会等待来自服务器的任何确认，该记录将立即添加到套接字缓冲区并视为已发送。在这种情况下，无法保证服务器已收到记录，并且重试配置将不会生效（因为客户端通常不会知道任何故障），为每条记录返回的偏移量始终设置为-1。
      #acks = 1 这意味着leader会将记录写入其本地日志，但无需等待所有副本服务器的完全确认即可做出回应，在这种情况下，如果leader在确认记录后立即失败，但在将数据复制到所有的副本服务器之前，则记录将会丢失。
      #acks = all 这意味着leader将等待完整的同步副本集以确认记录，这保证了只要至少一个同步副本服务器仍然存活，记录就不会丢失，这是最强有力的保证，这相当于acks = -1的设置。
      #可以设置的值为：all, -1, 0, 1
      acks: 1
    consumer:
      group-id: testGroup
      # smallest和largest才有效，如果smallest重新0开始读取，如果是largest从logfile的offset读取。一般情况下我们都是设置smallest
      auto-offset-reset: earliest
      # 设置自动提交offset
      enable-auto-commit: false
      max-poll-records: 2
server:
  port: 8060

kafka支持的消费模式，设置在AbstractMessageListenerContainer.AckMode的枚举中，下面就介绍下各个模式的区别

	/**
	 * The offset commit behavior enumeration.
	 */
	public enum AckMode {

		/**
		 * Commit after each record is processed by the listener.
		 */
		RECORD,

		/**
		 * Commit whatever has already been processed before the next poll.
		 */
		BATCH,

		/**
		 * Commit pending updates after
		 * {@link ContainerProperties#setAckTime(long) ackTime} has elapsed.
		 */
		TIME,

		/**
		 * Commit pending updates after
		 * {@link ContainerProperties#setAckCount(int) ackCount} has been
		 * exceeded.
		 */
		COUNT,

		/**
		 * Commit pending updates after
		 * {@link ContainerProperties#setAckCount(int) ackCount} has been
		 * exceeded or after {@link ContainerProperties#setAckTime(long)
		 * ackTime} has elapsed.
		 */
		COUNT_TIME,

		/**
		 * User takes responsibility for acks using an
		 * {@link AcknowledgingMessageListener}.
		 */
		MANUAL,

		/**
		 * User takes responsibility for acks using an
		 * {@link AcknowledgingMessageListener}. The consumer
		 * immediately processes the commit.
		 */
		MANUAL_IMMEDIATE,

	}
AckMode模式作用
MANUAL当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交
MANUAL_IMMEDIATE手动调用Acknowledgment.acknowledge()后立即提交
RECORD当每一条记录被消费者监听器（ListenerConsumer）处理之后提交
BATCH当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后提交
TIME当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，距离上次提交时间大于TIME时提交
COUNT当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，被处理record数量大于等于COUNT时提交
COUNT_TIMETIME或COUNT　有一个条件满足时提交

MANUAL 和 MANUAL_IMMEDIATE

MANUAL

当每一条记录被消费者监听器（ListenerConsumer）处理之后提交

  • 监听器工厂的配置
    /**
     * MANUAL   当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交
     * @param consumerFactory
     * @return
     */
    @Bean("manualListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> manualListenerContainerFactory(
        ConsumerFactory<String, String> consumerFactory) {

        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        factory.getContainerProperties().setPollTimeout(1500);
        factory.setBatchListener(true);
        //配置手动提交offset
        factory.getContainerProperties().setAckMode(AbstractMessageListenerContainer.AckMode.MANUAL);
        return factory;
    }
  • 指定监听器使用的配置
    /**
     * MANUAL   当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后, 手动调用Acknowledgment.acknowledge()后提交
     * @param message
     * @param ack
     */
    @KafkaListener(containerFactory = "manualListenerContainerFactory" , topics = "kafka-manual")
    public void onMessageManual(List<Object> message, Acknowledgment ack){
        log.info("manualListenerContainerFactory 处理数据量：{}",message.size());
        message.forEach(item -> log.info("manualListenerContainerFactory 处理数据内容：{}",item));
        ack.acknowledge();//直接提交offset
    }

MANUAL_IMMEDIATE

当每一条记录被消费者监听器（ListenerConsumer）处理之后提交

  • 监听器工厂的配置
    /**
     * MANUAL_IMMEDIATE 手动调用Acknowledgment.acknowledge()后立即提交
     * @param consumerFactory
     * @return
     */
    @Bean("manualImmediateListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> manualImmediateListenerContainerFactory(
        ConsumerFactory<String, String> consumerFactory) {

        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        factory.getContainerProperties().setPollTimeout(1500);
        factory.setBatchListener(true);
        //配置手动提交offset
        factory.getContainerProperties().setAckMode(AbstractMessageListenerContainer.AckMode.MANUAL_IMMEDIATE);
        return factory;
    }
  • 指定监听器使用的配置
    /**
     * MANUAL_IMMEDIATE 手动调用Acknowledgment.acknowledge()后立即提交
     * @param message
     */
    @KafkaListener(containerFactory = "manualImmediateListenerContainerFactory" , topics = "kafka-manualImmediate")
    public void onMessageManualImmediate(List<Object> message, Acknowledgment ack){
        log.info("manualImmediateListenerContainerFactory 处理数据量：{}",message.size());
        message.forEach(item -> log.info("manualImmediateListenerContainerFactory 处理数据内容：{}",item));
        ack.acknowledge();//直接提交offset
    }

MANUAL和MANUAL_IMMEDIATE两者的相同和区别

  1. 相同之处

这两种模式都是需要进行手动确认ack.acknowledge();才能完成消息的消费，否则在重启消费端实例的时候数据会再次被消费端接收到。

  1. 两者的区别
  • MANUAL: 在处理完最后一次轮询的所有结果后，将队列排队，并在一次操作中提交偏移量。可以认为是在批处理结束时提交偏移量
  • MANUAL_IMMEDIATE：只要在侦听器线程上执行确认，就立即提交偏移。会在批量执行的时候逐一提交它们。

关于两者的解释可以看看这个提问 what-is-the-difference-between-manual-and-manual-immediate-in-spring-kafka-ackmo

RECORD

  • 监听器工厂的配置
    /**
     * RECORD   当每一条记录被消费者监听器（ListenerConsumer）处理之后提交
     * @param consumerFactory
     * @return
     */
    @Bean("recordListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> recordListenerContainerFactory(
        ConsumerFactory<String, String> consumerFactory) {

        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        factory.getContainerProperties().setPollTimeout(1500);
        //配置手动提交offset
        factory.getContainerProperties().setAckMode(AbstractMessageListenerContainer.AckMode.RECORD);
        return factory;
    }
  • 指定监听器使用的配置
    /**
     * RECORD   当每一条记录被消费者监听器（ListenerConsumer）处理之后提交
     * @param message
     */
    @KafkaListener(containerFactory = "recordListenerContainerFactory" , topics = "kafka-record")
    public void onMessageRecord(List<Object> message){
        log.info("recordListenerContainerFactory 处理数据量：{}",message.size());
        message.forEach(item -> log.info("recordListenerContainerFactory 处理数据内容：{}",item));
    }
  • 关于AckMode.RECORD 模式

使用RECORD模式的时候，当监听器处理完消息后会自动处理，使用此模式不需要手动消费。

TIME

  • 监听器工厂的配置
    /**
     * TIME     当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，距离上次提交时间大于TIME时提交
     * @param consumerFactory
     * @return
     */
    @Bean("timeListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> timeListenerContainerFactory(
        ConsumerFactory<String, String> consumerFactory) {

        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        factory.getContainerProperties().setPollTimeout(2000);
        //配置手动提交offset
        factory.getContainerProperties().setAckMode(AbstractMessageListenerContainer.AckMode.TIME);
        return factory;
    }
  • 指定监听器使用的配置
    /**
     * TIME     当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，距离上次提交时间大于TIME时提交
     * @param message
     */
    @KafkaListener(containerFactory = "timeListenerContainerFactory" , topics = "kafka-time")
    public void onMessageTime(List<Object> message){
        log.info("timeListenerContainerFactory 处理数据量：{}",message.size());
        message.forEach(item -> log.info("timeListenerContainerFactory 处理数据内容：{}",item));
    }
  • 关于AckMode.TIME 模式

此模式会在监听器监听到消息后的PollTimeout的时间段内提交消费请求。上面配置中将PollTimeout设置的超时时间为2秒。使用请求http://localhost:8060//ack/sendStr/kafka-time/3发送三条消息，在消费实例接收到消息后在PollTimeout到达之前关闭消费端实例，再次启动消费实例会发现之前消费的消息会被再次读取到。而接收到消息PollTimeout之后关闭消费实例，则会发现消息已经被成功消费。

COUNT

  • 监听器工厂的配置
    /**
     * COUNT    当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，被处理record数量大于等于COUNT时提交
     * @param consumerFactory
     * @return
     */
    @Bean("countListenerContainerFactory")
    public KafkaListenerContainerFactory<ConcurrentMessageListenerContainer<String, String>> countListenerContainerFactory(
        ConsumerFactory<String, String> consumerFactory) {

        ConcurrentKafkaListenerContainerFactory<String, String> factory = new ConcurrentKafkaListenerContainerFactory<>();
        factory.setConsumerFactory(consumerFactory);
        factory.getContainerProperties().setPollTimeout(1500);
        factory.getContainerProperties().setAckCount(5);
        //配置手动提交offset
        factory.getContainerProperties().setAckMode(AbstractMessageListenerContainer.AckMode.COUNT);
        return factory;
    }
  • 指定监听器使用的配置
    /**
     * COUNT    当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后，被处理record数量大于等于COUNT时提交
     * @param message
     */
    @KafkaListener(containerFactory = "countListenerContainerFactory" , topics = "kafka-count")
    public void onMessageCount(List<Object> message){
        log.info("countListenerContainerFactory 处理数据量：{}",message.size());
        message.forEach(item -> log.info("countListenerContainerFactory 处理数据内容：{}",item));
    }
  • 关于AckMode.COUNT 模式

此模式会在监听器监听到消息等于AckCount的数量提交消费请求。上面配置中将`AckCount``设置为5条消息。使用请求http://localhost:8060//ack/sendStr/kafka-count/9向队列发送9条数据，然后关闭消费端实例，然后再次启动时发现最后4条消息再次被读取到。此时前5条数据被消费，最后四条消息需要凑齐5条数据后才能消费。

个人水平有限，上面的内容可能存在没有描述清楚或者错误的地方，假如开发同学发现了，请及时告知，我会第一时间修改相关内容。假如我的这篇内容对你有任何帮助的话，麻烦给我点一个赞。你的点赞就是我前进的动力。

大·风
关注
专栏目录
Spring Boot 整合kafka：生产者ack机制和消费者AckMode消费模式、手动提交ACK
qq_36551991的博客
12-06 7348
kafka生产者ack机制和消费者AckMode消费模式、手动提交ACK
聊聊spring for kafka的AckMode
weixin_34311757的博客
10-13 1056
序 本文主要讲述一下spring for kafka的consumer在spring.kafka.consumer.enable-auto-commit是false情况下，AckMode的选项 AckMode spring-kafka-1.2.3.RELEASE-sources.jar!/org/springframework/kafka/listener/AbstractMessageListe...
Spring-Kafka确认机制报错：No Acknowledgment available as an argument
qq_44957574的博客
08-05 754
本文解决了spring-kafka报错：No Acknowledgment available as an argument 的bug，在解决的过程通过查阅官方文档，分析了kafka的消息确认机制，以及提供了`AckMode` 的集中模式，最后列出了如何在appliction.yaml中如何合理的配置。
kafka-消费者-指定offset消费（SpringBoot整合Kafka）
小丁的博客
06-06 1358
kafka-消费者-指定offset消费（SpringBoot整合Kafka）
spring-kafka几种AckMode模式介绍，MANUAL_IMMEDIATE和MANUAL区别
热门推荐
huangdi1309的博客
07-24 1万+
kafka每个partition都有自己的offset，消费端处理完要向kafka服务器提交offset，基于spring-kafka组件有下面几种AckMode提交模式： 模式 描述 MANUAL poll()拉取一批消息，在处理完业务手动调用Acknowledgment.acknowledge()方法先放到map缓存，在下一次poll之前从缓存拿出来批量提交 MANUAL_IMMEDIATE 每处理完业务手动调用Acknowledgment.acknowledge()后立即提交
spring kafka消费者配置介绍----ackMode
lixinkuan的博客
10-24 6744
当auto.commit.enable 设置为false时，表示kafak的offset由customer手动维护，spring-kafka提供了通过ackMode的值表示不同的手动提交方式； ackMode有以下7种值： public enum AckMode { // 当每一条记录被消费者监听器（ListenerConsumer）处理之后提交 RECORD, // 当每一批poll()的数据被消费者监听器（ListenerConsumer）处理之后.
spring boot整合spring-kafka实现发送接收消息实例代码
08-30
Spring Boot 整合 Spring-Kafka 实现发送接收消息实例代码 Spring Boot 是一个基于 Java 的开源框架，它提供了一个灵活的方式来构建 Web 应用程序。Spring-Kafka 是一个基于 Apache Kafka 的消息队列组件，提供了...
spring boot整合kafka过程解析
08-25
Spring Boot整合Kafka的过程涉及多个环节，包含对Kafka消息队列的基本理解和Spring Boot中集成Kafka的详细步骤。Kafka是一个分布式流处理平台，被广泛应用于实时数据管道和流应用程序的场景中。Spring Boot作为当下...
Spring Boot 整合 Apache Kafka.zip
07-02
《Spring Boot 整合 Apache Kafka》博文对应的源代码；博文地址：https://blog.csdn.net/shawearn1027/article/details/107067328
springboot 基于spring-kafka动态创建kafka消费者
11-17
本文将详细探讨如何在Spring Boot项目中基于Spring Kafka动态创建Kafka消费者。 首先，了解Kafka基本概念：Kafka是一种分布式流处理平台，用于构建实时数据管道和流应用程序。它提供了高吞吐量、低延迟的消息传递，...
Spring Boot+Kafka实战生产级Kafka消费组
程序员光剑
08-06 2533
Kafka是一个开源分布式消息系统，最初由LinkedIn开发，之后成为Apache项目的一部分。Kafka主要用于大数据实时流处理，具有低延迟、高吞吐量等特点。本文将会从基本概念、术语说明、原理及应用场景三个方面对Kafka进行详细介绍。Kafka作为一个分布式系统，需要配合Zookeeper实现主备、容错等功能。因此在实际中部署Kafka集群至少需要2台服务器，其中一台为zookeeper服务器。
Spring Boot 整合kafka消费模式AckMode以及手动消费
程序人生
06-02 5502
Spring boot 批量消费kafka消息，内容就介绍下各个模式的区别。kafka支持的消费模式等常用代码功能。
spring-kafka中ContainerProperties.AckMode详解
高性价比服务器就选：蓝易云
04-03 404
Spring-Kafka是Spring框架对Apache Kafka的封装，提供了一种便捷的方式来发送和接收消息到Kafka主题。在Spring-Kafka中，ContainerProperties.AckMode是一个枚举类型，用来设置Kafka消费者的确认模式。总的来说，ContainerProperties.AckMode是Spring-Kafka提供的一个重要特性，它可以帮助我们更好地控制Kafka消息的确认过程，从而提高应用的性能和可靠性。
Spring Kafka实战(1) — Kafka集群环境搭建以及AckMode模式探讨
weixin_46053046的博客
01-03 719
Spring Kafka系列教程 Spring Kafka实战(1) — Kafka环境以及AckMode模式探讨
SpringBoot集成kafka之AckMode介绍
敲代码的小小酥的博客
05-19 3340
一、AckMode介绍。 kafka消费端在读取数据后，会向kafka服务端提交偏移量，来记录消费端读取数据的位置。提交偏移量分为手动提交和自动提交，为了保证数据读取的安全性，我们一般设置成手动提交偏移量。在SpringBoot集成kafka后，SpringBoot为我们提供了AckMode枚举，供我们选择。AckMode有以下几种模式:（AckMode在ContainerProperties类的内部定义） public static enum AckMode { RECORD,
RabbitMQ的消息确认机制Ack Mode
最新发布
qq_60638478的博客
08-15 1133
消费者需要告诉 RabbitMQ 某条消息已经被成功处理，这样 RabbitMQ 才会将其从内存中移除。如果消费者没有发送确认信号，RabbitMQ 会保留该消息，直到收到确认或者发生特定的超时情况。在自动确认模式下，RabbitMQ 通常不会等待当前消息被处理完毕再发送下一条消息给同一个消费者。在手动确认模式下，RabbitMQ 会等待当前消息被处理完毕再发送下一条消息给同一个消费者。ackMode ="MANUAL"，此时为手动确认模式，ackMode ="NONE"，此时为自动确认模式。
JMS客户端ACK_MODE类型
漫天雪_昆仑巅
06-30 1303
ACK_MODE确认模式 -------------------------------------------------------------------------------------------------------------------- 确认模式用来指示会话如何确认收到消息，在使用Connection的createSession方法时需要指定此选项，在JMS的Se
基于Springboot的kafka单消息体非批量消费的consumer
ZEUS00456的专栏
01-14 851
INDEX文章目的和缘由所谓单消息体非批量消费各种类说明和具体实现方式推荐最简单的consumer 文章目的和缘由 在实际工作中，笔者使用了kafka，业务场景并不算太复杂，结合网络上一些帖子（绝大部分是互相重复的），简单快速的实现了。然而，在后续的观察中，发现里面有一些不大不小的坑，于是又白嫖了一堆帖子（依旧是各种相互重复）进行了修复，经过一段较长时间的观察和测试，感觉基本上（至少在笔者的场景中，[尴尬]）没有问题了。 使用kafka的过程中，仅凭主观体会，kafka是个功能强大但坑比较多、并且使用相对繁
三.Kafka入门到精通-SpringBoot整合Kafka(同步&异步消息&事务消息&手动确认)
墨家巨子@俏如来
06-12 5372
前面两个章节我们把Kafka给安装起来然后使用命令演示是生产和消费的过程，以及Kafka的架构原理，接下来就是Kafka的实战使用，顺应如今企业流行的开发模式，当然要使用SpringBoot和Kafka进行整合。第一步：我们基于SpringBoot来快速入门Kafka，我这里使用的SpringBoot版本是2.2.5.RELEASE ，对应spring-kafka的版本是2.3.6，具体依赖如下： 第二步：导入依赖之后需要为SpringBoot创建启动类，在启动类中我们通过注解的方式创建一个Topic，如下
kafka auto.offset.reset
03-16
kafka auto.offset.reset是Kafka中的一个配置参数，用于指定当消费者第一次订阅一个主题时，从哪个偏移量开始消费消息。该参数有两个可选值：earliest和latest。如果设置为earliest，则消费者将从最早的可用消息开始消费；如果设置为latest，则消费者将从最新的消息开始消费。
评论 6
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

大·风

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

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

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

打赏作者

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

抵扣说明：

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

余额充值