springboot kafka 实现延时队列

已于 2023-11-23 10:13:12 修改
阅读量4.8w 收藏 97
点赞数 20
分类专栏： kafka 大数据 分布式 文章标签： kafka java 分布式 大数据
于 2023-04-21 17:26:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41889508/article/details/130259348
版权
分布式 同时被 3 个专栏收录
4 篇文章 0 订阅
订阅专栏
kafka
1 篇文章 1 订阅
订阅专栏
大数据
1 篇文章 0 订阅
订阅专栏

好文推荐：
2.5万字详解23种设计模式
基于Netty搭建websocket集群实现服务器消息推送
2.5万字讲解DDD领域驱动设计

文章目录


在这里插入图片描述

一、延时队列定义

延时队列：是一种消息队列，可以用于在指定时间或经过一定时间后执行某种操作。

小编已经做好了Kafka延时队列的封装，以后只需要一行代码就可以实现kafka延时队列了，代码中有详细注释，完整代码已经给大家整理好了，领取方式放在了文章末。

二、应用场景

1，订单超时自动取消：用户下单后，如果在指定时间内未完成支付，系统会自动取消订单，释放库存。
2，定时推送：比如消息通知，用户预约某个服务，系统会在服务开始前一定时间发送提醒短信。
3，定时任务：将需要定时执行的任务放入延时队列中，等到指定的时间到达时再进行执行，例如生成报表、统计数据等操作。
4，限时抢购：将限时抢购的结束时间放入延时队列中，当时间到达时自动下架商品。
…

三、技术实现方案：

1. Redis

1.1 优点：
①Redis的延迟队列是基于Redis的sorted set实现的，性能较高。
②Redis的延迟队列可以通过TTL设置过期时间，灵活性较高。
③简单易用，适用于小型系统。
④性能较高，支持高并发。

1.2 缺点：
①可靠性相对较低，可能会丢失消息，就算redis最高级别的持久化也是有可能丢一条的，每次请求都做aof，但是aof是异步的，所以不保证这一条操作能被持久化。
②而且Redis持久化的特性也导致其在数据量较大时，存储和查询效率逐渐降低，此时会需要对其进行分片和负载均衡。
③Redis的延迟队列需要手动实现消息重试机制，更严谨的消息队列需要数据库兜底。

1.3 应用场景：
①适用于较小规模的系统，实时性要求较高的场景。
②适用于轻量级的任务调度和消息通知场景，适合短期延迟任务，不适合长期任务，例如订单超时未支付等。

2. Kafka

2.1 优点：
①Kafka的优点在于其高并发、高吞吐量和可扩展性强，同时支持分片。
②可靠性高，支持分布式和消息持久化。
③消费者可以随时回溯消费。
④支持多个消费者并行消费、消费者组等机制。

2.2 缺点：
①没有原生的延迟队列功能，需要使用topic和消费者组来实现，实现延迟队列需要额外的开发工作。
②消费者需要主动拉取数据，可能会导致延迟，精度不是特别高。
在此案例中代码已经实现了，直接拿来使用就可以了。

2.3 应用场景：
适用于大规模的数据处理，实时性要求较高的，高吞吐量的消息处理场景。

3. RabbitMQ

3.1 优点：
①RabbitMQ的延迟队列是通过RabbitMQ的插件实现的，易于部署和使用。
②RabbitMQ的延迟队列支持消息重试和消息顺序处理，可靠性较高。
③支持消息持久化和分布式。
④支持优先级队列和死信队列。
⑤提供了丰富的插件和工具。

3.2 缺点：
①RabbitMQ的延迟队列性能较低，不适用于高吞吐量的场景。
②性能较低，不适合高并发场景。
③实现延迟队列需要额外的配置，但是配置就很简单了。

3.3应用场景：
适用于中小型的任务调度和消息通知，对可靠性要求高的场景。

4. RocketMQ

4.1 优点：
①RocketMQ的延迟队列是RocketMQ原生支持的，易于使用和部署。
②RocketMQ的延迟队列支持消息重试和消息顺序处理，可靠性较高。
③高性能和高吞吐量，支持分布式和消息持久化。
④RocketMQ使用简单，性能好，并且支持延迟队列功能。

4.2 缺点：
①RocketMQ的延迟队列不支持动态添加或删除队列。
②RocketMQ的延迟队列需要保证消息的顺序，可能会导致消息延迟。
③在节点崩溃后，RocketMQ有可能发生消息丢失。

4.3 应用场景：
①适用于大规模的数据处理，对性能和吞吐量要求较高的场景。
②适合于任务量较大、需要延迟消息和定时消息的场景。例如电商平台、社交软件等。
③适用于分布式任务调度和高可靠性消息通知场景。

四、Kafka延时队列背景

  1. 基于以上四种实现延时队列的分析来，选择对应的技术方案的基础上呢，不同公司的mq的基础设施不同，如果只有Kafka，也没必要引入RabbitMQ和RocketMq来实现，引入新的组件也会顺便带来新的问题。

  2. 网上搜Kafka实现延时队列有很多文章，很多文章说使用Kafka内部的时间轮，支持延时操作，但这是Kafka自己内部使用的，时间轮只是一个工具类，用户无法将其作为延迟队列来使用。

  3. Kafka延时队列的最佳实践，使用Kafka消费者的暂停和恢复机制来实现。

五、Kafka延时队列实现思路

  1. 解决一个问题前首先要明确问题，如何让Kafka有延时队列的功能呢？
  2. 就是在Kafka消费者消费的时候延时消费，不久搞定了嘛
  3. 那如何延时消费呢，网上有些文章使用Thread.sleep进行延时消费这是不靠谱的（亲身实践），sleep的时间超过了Kafka配置的max.poll.records时间，消费者无法及时提交offset，kafka就会认为这个消费者已经挂了，会进行rebalance也就是重新分配分区给消费者，以保证每个分区只被一个消费者消费
  4. 也有同学说了，为了不发生rebalance，那可以增加max.poll.records时间啊，但是这样的话，如果要sleep几天的时间，难道max.poll.records要写几天的时间嘛，有违Kafka的设计原理了，那怎么办呢？
  5. 这时候Kafka的pause暂停消费和resume恢复消费就登场了，pause暂停某个分区之后消费者不会再poll拉取该分区的消息，直到resume恢复该分区之后才会重新poll消息。
  6. 我已经做好了Kafka延时队列的封装，以后只需要一行代码就可以实现延时队列了，代码核心使用Kafka消费者的pause函数（暂停）和resume函数（恢复）+线程池+定时任务+事件监听机制+工厂模式

六、Kafka延时队列架构图

在这里插入图片描述

七、kafka延时任务代码实现

以下代码只列出了核心实现，完整代码已经给大家整理好了，可以关注【微信公众号】微信搜索【老板来一杯java】，然后【加群】直接获取源码，在自己项目中引入即用！
源码目录：
在这里插入图片描述

1. KafkaDelayQueue：Kafka延迟队列

定义一个Kafka延期队列，包含的内容：KafkaDelayQueue，其中有延迟队列配置，主题，消费组，延迟时间，目标主题，KafkaSyncConsumer，ApplicationContext，poll线程池，delay线程池等等

package com.wdyin.kafka.delay;

import lombok.Getter;
import lombok.Setter;
import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.common.TopicPartition;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.context.ApplicationContext;
import org.springframework.scheduling.concurrent.ThreadPoolTaskScheduler;

import java.time.Duration;
import java.util.Collections;
import java.util.concurrent.ThreadPoolExecutor;

/**
 * kafka延时队列
 *
 * @Author WDYin
 * @Date 2022/7/2
 **/
@Slf4j
@Getter
@Setter
class KafkaDelayQueue<K, V> {

    private String topic;
    private String group;
    private Integer delayTime;
    private String targetTopic;
    private KafkaDelayConfig kafkaDelayConfig;
    private KafkaSyncConsumer<K, V> kafkaSyncConsumer;
    private ApplicationContext applicationContext;
    private ThreadPoolTaskScheduler threadPoolPollTaskScheduler;
    private ThreadPoolTaskScheduler threadPoolDelayTaskScheduler;
    ......
}

2. KafkaDelayQueueFactory：Kafka延迟队列工厂

Kafka延期队列的工厂，用于及其管理延迟队列

package com.wdyin.kafka.delay;

import lombok.Data;
import org.apache.kafka.clients.consumer.ConsumerConfig;
import org.springframework.context.ApplicationContext;
import org.springframework.util.Assert;
import org.springframework.util.StringUtils;

import java.util.Properties;

/**
 * 延时队列工厂
 * @author WDYin
 * @date 2023/4/17
 **/
@Data
public class KafkaDelayQueueFactory {

    private KafkaDelayConfig kafkaDelayConfig;
    private Properties properties;
    private ApplicationContext applicationContext;
    private Integer concurrency;

    public KafkaDelayQueueFactory(Properties properties, KafkaDelayConfig kafkaDelayConfig) {
        Assert.notNull(properties, "properties cannot null");
        Assert.notNull(kafkaDelayConfig.getDelayThreadPool(), "delayThreadPool cannot null");
        Assert.notNull(kafkaDelayConfig.getPollThreadPool(), "pollThreadPool cannot null");
        Assert.notNull(kafkaDelayConfig.getPollInterval(), "pollInterval cannot null");
        Assert.notNull(kafkaDelayConfig.getPollTimeout(), "timeout cannot null");
        this.properties = properties;
        this.kafkaDelayConfig = kafkaDelayConfig;
    }

    public void listener(String topic, String group, Integer delayTime, String targetTopic) {
        if (StringUtils.isEmpty(topic)) {
            throw new RuntimeException("topic cannot empty");
        }
        if (StringUtils.isEmpty(group)) {
            throw new RuntimeException("group cannot empty");
        }
        if (StringUtils.isEmpty(delayTime)) {
            throw new RuntimeException("delayTime cannot empty");
        }
        if (StringUtils.isEmpty(targetTopic)) {
            throw new RuntimeException("targetTopic cannot empty");
        }
        KafkaSyncConsumer<String, String> kafkaSyncConsumer = createKafkaSyncConsumer(group);
        KafkaDelayQueue<String, String> kafkaDelayQueue = createKafkaDelayQueue(topic, group, delayTime, targetTopic, kafkaSyncConsumer);
        kafkaDelayQueue.send();
    }

    private KafkaDelayQueue<String, String> createKafkaDelayQueue(String topic, String group, Integer delayTime, String targetTopic, KafkaSyncConsumer<String, String> kafkaSyncConsumer) {
        KafkaDelayQueue<String, String> kafkaDelayQueue = new KafkaDelayQueue<>(kafkaSyncConsumer, kafkaDelayConfig);
        Assert.notNull(applicationContext, "kafkaDelayQueue need applicationContext");
        kafkaDelayQueue.setApplicationContext(applicationContext);
        kafkaDelayQueue.setDelayTime(delayTime);
        kafkaDelayQueue.setTopic(topic);
        kafkaDelayQueue.setGroup(group);
        kafkaDelayQueue.setTargetTopic(targetTopic);
        return kafkaDelayQueue;
    }

    private KafkaSyncConsumer<String, String> createKafkaSyncConsumer(String group) {
        properties.put(ConsumerConfig.GROUP_ID_CONFIG, group);
        return new KafkaSyncConsumer<>(properties);
    }

}

3. KafkaPollListener：Kafka延迟队列事件监听

package com.wdyin.kafka.delay;

import lombok.extern.slf4j.Slf4j;
import org.apache.kafka.clients.consumer.ConsumerRecord;
import org.apache.kafka.clients.consumer.ConsumerRecords;
import org.apache.kafka.clients.consumer.OffsetAndMetadata;
import org.apache.kafka.common.TopicPartition;
import org.springframework.context.ApplicationListener;
import org.springframework.kafka.core.KafkaTemplate;

import java.time.Instant;
import java.time.LocalDateTime;
import java.time.ZoneId;
import java.util.*;

/**
 * 延时队列监听
 * @Author : WDYin
 * @Date : 2021/5/7
 * @Desc :
 */
@Slf4j
public class KafkaPollListener<K, V> implements ApplicationListener<KafkaPollEvent<K, V>> {

    private KafkaTemplate kafkaTemplate;

    public KafkaPollListener(KafkaTemplate kafkaTemplate) {
        this.kafkaTemplate = kafkaTemplate;
    }

    @Override
    public void onApplicationEvent(KafkaPollEvent<K, V> event) {
        ConsumerRecords<K, V> records = (ConsumerRecords<K, V>) event.getSource();
        Integer delayTime = event.getDelayTime();
        KafkaDelayQueue<K, V> kafkaDelayQueue = event.getKafkaDelayQueue();
        KafkaSyncConsumer<K, V> kafkaSyncConsumer = kafkaDelayQueue.getKafkaSyncConsumer();
        Set<TopicPartition> partitions = records.partitions();
        Map<TopicPartition, OffsetAndMetadata> commitMap = new HashMap<>();
        partitions.forEach((partition) -> {
            List<ConsumerRecord<K, V>> consumerRecords = records.records(partition);
            for (ConsumerRecord<K, V> record : consumerRecords) {
                long startTime = (record.timestamp() / 1000) * 1000;
                long endTime = startTime + delayTime;
                long now = System.currentTimeMillis();
                if (endTime > now) {
                    kafkaSyncConsumer.pauseAndSeek(partition, record.offset());
                    kafkaDelayQueue.getThreadPoolPollTaskScheduler().schedule(kafkaDelayQueue.delayTask(partition), new Date(endTime));
                    break;
                }
                log.info("{}: partition:{}, offset:{}, key:{}, value:{}, messageDate:{}, nowDate:{}, messageDate:{}, nowDate:{}",
                        Thread.currentThread().getName() + "#" + Thread.currentThread().getId(), record.topic() + "-" + record.partition(), record.offset(), record.key(), record.value(), LocalDateTime.ofInstant(Instant.ofEpochMilli(startTime), ZoneId.systemDefault()), LocalDateTime.now(), startTime, Instant.now().getEpochSecond());
                kafkaTemplate.send(kafkaDelayQueue.getTargetTopic(), record.value());
                commitMap.put(partition, new OffsetAndMetadata(record.offset() + 1));
            }
        });
        if (!commitMap.isEmpty()) {
            kafkaSyncConsumer.commit(commitMap);
        }
    }
}

4. KafkaDelayConfig：Kafka延时配置

package com.wdyin.kafka.delay;

import lombok.Data;

/**
 * 延时队列配置
 * @author WDYin
 * @date 2023/4/16
 **/
@Data
public class KafkaDelayConfig {

    private Integer pollInterval;
    private Integer pollTimeout;
    private Integer pollThreadPool;
    private Integer delayThreadPool;

    public KafkaDelayConfig() {
    }
    ......
}

八. 如何使用kafka延时队列

自己项目中引入以上代码之后，使用KafkaDelayApplication：一个Kafka延迟任务注册程序，注意一个延时主题对应一个延迟时间，后续有新的延迟任务只需要在此注册延迟任务的监听即可！开箱即用！
使用流程：

  1. 生产者发送消息到【延时主题】——自己写
  2. 然后Kafka将消息从【延时主题】经过【延时时间】后发送到【目标主题】——以下代码
  3. 自己创建消费者消费【目标主题】——自己写
import org.springframework.stereotype.Component;

import javax.annotation.PostConstruct;
import javax.annotation.Resource;

/**
 * @author WDYin
 * @date 2023/4/18
 **/
@Component
public class KafkaDelayApplication {

    @Resource
    private KafkaDelayQueueFactory kafkaDelayQueueFactory;

	/**
     * 延迟任务都可以配置在这里
     * Kafka将消息从【延时主题】经过【延时时间】后发送到【目标主题】
     */
    @PostConstruct
    public void init() {
        //延迟30秒
        kafkaDelayQueueFactory.listener("delay-30-second-topic", "delay-30-second-group", 1 * 30 * 1000, "delay-60-second-target-topic");
        //延迟60秒
        kafkaDelayQueueFactory.listener("delay-60-second-topic", "delay-60-second-group", 1 * 60 * 1000, "delay-60-second-target-topic");
        //延迟30分钟
        kafkaDelayQueueFactory.listener("delay-30-minute-topic", "delay-30-minute-group", 30 * 60 * 1000, "delay-30-minute-target-topic");
    }
}

九、测试

  1. 先往延时主题【delay-60-second-topic】发送一千条消息，一共10个分区，每个分区100条消息，消息时间是2023-04-21 16:37:26分，延迟消息消费时间就应该是2023-04-21 16:38:26
    在这里插入图片描述
  2. 延时队列进行消费：通过日志查看，消息日期和延迟队列消费消息时间正好相差一分钟
    在这里插入图片描述

十、总结

  1. 本案例已成功实现Kafka的延时队列，并进行实测，代码引入可用非常方便。
  2. Kafka实现的延时队列支持秒级别的延时任务，不支持毫秒级别，但是毫秒级别的延时任务也没有意义
  3. 注意一个主题对应的延时时间是一致的，不能在同一个主题里放不同时间的延时任务。
  4. 此方案的缺点就是，如果数据量极大，生产者生产消息速度很快，一定要保证Kafka的消费能力，否则可能会导致延迟，精度不是特别高，不过如果延迟秒级的任务，差个几毫秒肯定可以接受的，一般场景肯定满足。
  5. 完整代码已经给大家整理好了，可以关注【微信公众号】微信搜索【老板来一杯java】，然后【加群】直接获取源码。

好文推荐：
2.5万字详解23种设计模式
微服务springcloud环境下基于Netty搭建websocket集群实现服务器消息推送----netty是yyds
2.5万字讲解DDD领域驱动设计

王德印
关注
  • 20
    点赞
  • 踩
  • 97
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 7
    评论
专栏目录
Kafka实战开源消息队列的坑与对策-刘喆
07-27
AdMaster架构师刘喆主要负责数据处理的全流程技术支持，高性能和高可用的分布式架构设计，DSL语言抽象，Hadoop/HBase/Storm/Spark等大数据平台优化。
springboot-kafka--消息队列
05-11
springboot集成kafka消息队列代码，可在上面进行二次开发。亲测有效，可以通过注释进行消息的接口
Kafka实现延时队列的效果（面试）
weixin_53451002的博客
01-22 435
Kafka实现延时队列的效果
springboot kafka 实现延时队列_kafka延迟队列(1)
2401_84166965的博客
04-08 2034
3.1 优点： ①RabbitMQ的延迟队列是通过RabbitMQ的插件实现的，易于部署和使用。 ②RabbitMQ的延迟队列支持消息重试和消息顺序处理，可靠性较高。 ③支持消息持久化和分布式。 ④支持优先级队列和死信队列。 ⑤提供了丰富的插件和工具。3.2 缺点： ①RabbitMQ的延迟队列性能较低，不适用于高吞吐量的场景。 ②性能较低，不适合高并发场景。 ③实现延迟队列需要额外的配置，但是配置就很简单了。3.3应用场景： 适用于中小型的任务调度和消息通知，对可靠性要求高的场景。4.1 优点： ①Roc
Kafka 实战 - Kafka优化之实现延时队列
最新发布
qq_33240556的博客
04-11 954
总结来说，在实现 Kafka 延迟队列时，可以根据项目的具体需求、现有技术栈以及团队的开发运维能力，选择上述的一种或多种方法进行组合。生产者根据消息的延迟要求，将消息发送到相应的延迟主题。同时运行一个后台任务（如定时任务或常驻服务），该任务订阅这些延迟主题，当消息到达预期处理时间时，将它们转发到最终的目标主题。创建一个独立的服务（代理），负责接收并存储待延迟的消息。这个服务根据消息的延迟要求，将其存储在一个内部数据结构（如优先队列或时间轮）中，并在适当时间将消息重新发布到目标 Kafka 主题。
Kafka--延迟队列--使用/实现/原理
热门推荐
IT利刃出鞘的博客
11-17 5万+
本文介绍Kafka如何使用延迟队列的功能。 Kafka是很长用的消息队列，但Kafka本身是没有延迟队列功能的，RabbitMQ、RocketMQ有延迟队列的功能。本文介绍如何手动给Kafka添加延迟消息的功能。 虽然Kafka内部有时间轮，支持延时操作，例如：延迟生产、延迟拉取以及延迟删除，但这是Kafka自己内部使用的，用户无法将其作为延迟队列来使用。 本内容也是Java后端面试常问的问题 。...
kafka实现延迟队列
weixin_51991615的博客
01-31 2124
首先说一下延迟队列这个东西，实际上实现他的方法有很多，kafka实现并不是一个最好的选择，例如redis的zset可以实现，rocketmq天然的可以实现，rabbitmq也可以实现。如果切换前几种方案成本高的情况下，那么就使用kafka实现，实际上kafka实现延迟队列也是借用了rocketmq的延迟队列思想，rocketmq的延迟时间是固定的几个，并不是自定义的，但是kafka可以实现自定义的延迟时间，但是不能过多，因为是依据topic实现的，接下来我使用go实现简单的kafka的延迟队列。
Kafka系列之：延时队列
zhengzaifeidelushang的博客
09-09 3641
Kafka系列之：延时队列
kafka如何实现延迟队列来实现延迟消费
08-08 2312
这种方式利用Kafka的时间戳和时间戳索引功能，在消费者端可以通过设置合适的等待时间来实现延迟消费的效果，避免了频繁轮询和重复发送消息。在Kafka中实现延迟队列来实现延迟消费的最有效率的方式是使用Kafka的时间戳和时间戳索引功能。
Kafka 消息队列消息消费延迟解决方案
leehsiao的专栏
12-17 1万+
一、消息队列解决的问题： 引入消息队列一般能解决一下五种场景：异步处理，应用解耦，流量削锋，日志采集和消息通讯 1、异步处理 场景说明：用户注册后，需要发注册邮件和注册短信。传统的做法有两种 1.串行的方式；2.并行方式 （1）串行方式：将注册信息写入数据库成功后，发送注册邮件，再发送注册短信。以上三个任务全部完成后，返回给客户端 （2）并行方式：将注册信息写入数据库成功后，发送注...
用Kafka实现延迟消息
weixin_40270946的博客
11-12 9220
本篇参考了基于kafka实现延迟队列 - 知乎，实现了Rocket MQ 18级延迟消息队列的功能，并加入任意延迟时间的支持（通过多个延迟队列的转发实现）。 1. Kafka操作工具类——KafkaManager 本类实现了对Kafka的连接和基本操作。 import org.apache.kafka.clients.admin.*; import org.apache.kafka.common.TopicPartitionInfo; import org.springframework...
Kafka 延迟队列
专注Java（全栈）应用开发，求知若渴，虚心若愚，talk is cheap, show me the code.
03-02 736
kafka 延迟队列。
springboot整合kafka实现生产者和消费者
06-01
springboot整合kafka实现生产者和消费者，该项目用于小白学习，导入idea连上自己的kafka即可使用
SpringBoot整合kafka及ProtoBuf实现跨平台跨语言的信息交互
10-28
SpringBoot2.x整合Kafka实现消息中间件的发送及消费监听业务，其序列化方式采用ProtoBuf协议实现跨平台、跨语言的数据传输方式。
springboot-kafka:springboot-kafka
03-13
springboot-kafka springboot-kafka
SpringBoot Kafka 整合使用及安装教程
08-25
SpringBoot Kafka 整合使用及安装教程是将 SpringBoot 和 Kafka 两个技术栈进行整合，实现消息队列的处理。本文将详细介绍 SpringBoot Kafka 的整合使用及安装教程，包括项目的创建、pom 文件的配置、Kafka 的安装和...
Kafka延迟队列的实现方式
果酱 の 博客
07-28 7275
延迟队列是一种特殊的消息队列，可以将消息或任务推迟到指定的时间再进行处理。它通常用于处理需要在未来某个时间点执行的任务，如定时任务、延迟通知等。延迟队列允许开发人员根据任务的延迟要求进行灵活的调度和处理。本文介绍了如何使用Kafka实现延迟队列的两种方式。无论是使用消息的时间戳和消费者组，还是使用Kafka Streams的事件时间，都可以实现灵活的延迟队列功能。通过合理的设计和调度，我们可以在分布式系统中实现高效、可靠的延迟任务处理。希望本文对你理解Kafka延迟队列的实现方式有所帮助。
Kafka中的消息延时队列与死信队列
禅与计算机程序设计艺术
01-18 1461
1.背景介绍 Kafka是一个分布式流处理平台，可以用于构建实时数据流管道和流处理应用。它的核心功能包括生产者-消费者模式、分区、副本和分布式集群等。在Kafka中，消息延时队列和死信队列是两个重要的概念，它们有助于处理消息的延迟和失效问题。 消息延时队列是指在Kafka中，消息在队列中的存活时间为一定的延时时间，当延时时间到达后，消息会被自动删除。这种特性可以用于处理短暂的延迟和避免队列中的...
springboot实现kafka延时
08-19
Spring Boot 中实现 Kafka 延时消息可以通过以下步骤完成： 1. 首先，添加 Kafka 相关的依赖。在 pom.xml 文件中添加以下依赖项： ```xml <dependency> <groupId>org.springframework.kafka</groupId> <artifactId>spring-kafka</artifactId> </dependency> ``` 2. 创建 Kafka 生产者。可以使用 Spring Boot 的 KafkaTemplate 来发送消息。在你的代码中创建一个 KafkaProducer 类，并注入 KafkaTemplate。示例代码如下： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.kafka.core.KafkaTemplate; import org.springframework.stereotype.Component; @Component public class KafkaProducer { @Autowired private KafkaTemplate<String, String> kafkaTemplate; public void sendDelayedMessage(String message, long delay) { kafkaTemplate.send("topicName", message) .addCallback(result -> { // 消息发送成功的回调 System.out.println("Message sent: " + message); }, ex -> { // 消息发送失败的回调 System.err.println("Failed to send message: " + ex.getMessage()); }); } } ``` 3. 创建一个定时任务。使用 Spring 的 @Scheduled 注解来创建一个定时任务，其中调用 KafkaProducer 类中的 sendDelayedMessage 方法来发送延时消息。示例代码如下： ```java import org.springframework.beans.factory.annotation.Autowired; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; @Component public class ScheduledTask { @Autowired private KafkaProducer kafkaProducer; @Scheduled(fixedDelay = 5000) // 每隔5秒执行一次 public void sendMessage() { String message = "Delayed message"; long delay = 10000; // 延时10秒发送 kafkaProducer.sendDelayedMessage(message, delay); } } ``` 在上述示例中，定时任务每隔5秒发送一条延时消息，延时时间为10秒。 4. 配置 Kafka。在 application.properties 或 application.yml 文件中添加 Kafka 的配置。示例配置如下： ```yaml spring.kafka.bootstrap-servers=localhost:9092 spring.kafka.consumer.group-id=my-group spring.kafka.consumer.auto-offset-reset=earliest spring.kafka.consumer.key-deserializer=org.apache.kafka.common.serialization.StringDeserializer spring.kafka.consumer.value-deserializer=org.apache.kafka.common.serialization.StringDeserializer spring.kafka.producer.key-serializer=org.apache.kafka.common.serialization.StringSerializer spring.kafka.producer.value-serializer=org.apache.kafka.common.serialization.StringSerializer ``` 在上述配置中，可以根据你的实际情况修改 bootstrap-servers、group-id 等属性。 这样，你就可以在 Spring Boot 中实现 Kafka 延时消息的功能了。请注意，上述示例仅作为参考，你可能需要根据你的具体业务需求进行适当的修改。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

王德印

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

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

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

打赏作者

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

抵扣说明：

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

余额充值