rabbitMq实现延迟队列

最新推荐文章于 2025-02-25 23:18:15 发布
最新推荐文章于 2025-02-25 23:18:15 发布
阅读量2.2k 收藏 19
点赞数 7
文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/2401_85123458/article/details/139933500
版权

channel.basicPublish(“my-exchange”, “routing-key”, properties, messageBodyBytes);

当上面的消息扔到队列中后，过了60秒，如果没有被消费，它就死了。不会被消费者消费到。

这个消息后面的，没有“死掉”的消息对顶上来，被消费者消费。死信在队列中并不会被删除和释放，它会被统计到队列的消息数中去。单靠死信还不能实现延迟任务，还要靠Dead Letter Exchange。

下面我大致解释一下Dead Letter Exchanges

4.1 Dead Letter Exchanges

一个消息在满足如下条件下，会进死信路由，记住这里是路由而不是队列，一个路由可以对应很多队列。

  • 1.一个消息被Consumer拒收了，并且reject方法的参数里requeue是false。也就是说不会被再次放在队列里，被其他消费者使用。
  • 2.上面的消息的TTL到了，消息过期了。
  • 3.队列的长度限制满了。排在前面的消息会被丢弃或者扔到死信路由上。

Dead Letter Exchange其实就是一种普通的exchange，和创建其他exchange没有两样。只是在某一个设置Dead Letter Exchange的队列中有消息过期了，会自动触发消息的转发，发送到Dead Letter Exchange中去。

4.2 实现延迟队列

延迟任务通过消息的TTL和Dead Letter Exchange来实现。我们需要建立2个队列，一个用于发送消息，一个用于消息过期后的转发目标队列，大致原理如下图所示。

在这里插入图片描述

生产者输出消息到Queue1，并且这个消息是设置有有效时间的，比如60s。消息会在Queue1中等待60s，如果没有消费者收掉的话，它就是被转发到Queue2，Queue2有消费者，收到，处理延迟任务。

接下来正式进入代码阶段

代码

  • 声明交换机、队列以及他们的绑定关系：

import org.springframework.amqp.core.*;

import org.springframework.beans.factory.annotation.Qualifier;

import org.springframework.context.annotation.Bean;

import org.springframework.context.annotation.Configuration;

import java.util.HashMap;

import java.util.Map;

@Configuration

public class RabbitMQConfig {

public static final String DELAY_EXCHANGE_NAME = “delay.queue.demo.business.exchange”;//普通的交换机

public static final String DELAY_QUEUEA_NAME = “delay.queue.demo.business.queuea”;//声明两个队列 A B

public static final String DELAY_QUEUEB_NAME = “delay.queue.demo.business.queueb”;

public static final String DELAY_QUEUEA_ROUTING_KEY = “delay.queue.demo.business.queuea.routingkey”;

public static final String DELAY_QUEUEB_ROUTING_KEY = “delay.queue.demo.business.queueb.routingkey”;

public static final String DEAD_LETTER_EXCHANGE = “delay.queue.demo.deadletter.exchange”;//Dead Letter Exchanges

public static final String DEAD_LETTER_QUEUEA_ROUTING_KEY = “delay.queue.demo.deadletter.delay_10s.routingkey”;//死信交换机

public static final String DEAD_LETTER_QUEUEB_ROUTING_KEY = “delay.queue.demo.deadletter.delay_60s.routingkey”;

public static final String DEAD_LETTER_QUEUEA_NAME = “delay.queue.demo.deadletter.queuea”;

public static final String DEAD_LETTER_QUEUEB_NAME = “delay.queue.demo.deadletter.queueb”;

// 声明延时Exchange

@Bean(“delayExchange”)

public DirectExchange delayExchange() {

return new DirectExchange(DELAY_EXCHANGE_NAME);

}

// 声明死信Exchange

@Bean(“deadLetterExchange”)

public DirectExchange deadLetterExchange() {

return new DirectExchange(DEAD_LETTER_EXCHANGE);

}

// 声明延时队列A 延时10s

// 并绑定到对应的死信交换机

@Bean(“delayQueueA”)

public Queue delayQueueA() {

Map<String, Object> args = new HashMap<>(2);

// x-dead-letter-exchange 这里声明当前队列绑定的死信交换机

args.put(“x-dead-letter-exchange”, DEAD_LETTER_EXCHANGE);

// x-dead-letter-routing-key 这里声明当前队列的死信路由key

args.put(“x-dead-letter-routing-key”, DEAD_LETTER_QUEUEA_ROUTING_KEY);

// x-message-ttl 声明队列的TTL

args.put(“x-message-ttl”, 1000 * 10);

return QueueBuilder.durable(DELAY_QUEUEA_NAME).withArguments(args).build();

}

// 声明延时队列B 延时 60s

// 并绑定到对应的死信交换机

@Bean(“delayQueueB”)

public Queue delayQueueB() {

Map<String, Object> args = new HashMap<>(2);

// x-dead-letter-exchange 这里声明当前队列绑定的死信交换机

args.put(“x-dead-letter-exchange”, DEAD_LETTER_EXCHANGE);

// x-dead-letter-routing-key 这里声明当前队列的死信路由key

args.put(“x-dead-letter-routing-key”, DEAD_LETTER_QUEUEB_ROUTING_KEY);

// x-message-ttl 声明队列的TTL

args.put(“x-message-ttl”, 60000);

return QueueBuilder.durable(DELAY_QUEUEB_NAME).withArguments(args).build();

}

// 声明死信队列A 用于接收延时10s处理的消息

@Bean(“deadLetterQueueA”)

public Queue deadLetterQueueA() {

return new Queue(DEAD_LETTER_QUEUEA_NAME);

}

// 声明死信队列B 用于接收延时60s处理的消息

@Bean(“deadLetterQueueB”)

public Queue deadLetterQueueB() {

return new Queue(DEAD_LETTER_QUEUEB_NAME);

}

// 声明延时队列A绑定关系

@Bean

public Binding delayBindingA(@Qualifier(“delayQueueA”) Queue queue,

@Qualifier(“delayExchange”) DirectExchange exchange) {

return BindingBuilder.bind(queue).to(exchange).with(DELAY_QUEUEA_ROUTING_KEY);

}

// 声明业务队列B绑定关系

@Bean

public Binding delayBindingB(@Qualifier(“delayQueueB”) Queue queue,

@Qualifier(“delayExchange”) DirectExchange exchange) {

return BindingBuilder.bind(queue).to(exchange).with(DELAY_QUEUEB_ROUTING_KEY);

}

// 声明死信队列A绑定关系

@Bean

public Binding deadLetterBindingA(@Qualifier(“deadLetterQueueA”) Queue queue,

@Qualifier(“deadLetterExchange”) DirectExchange exchange) {

return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUEA_ROUTING_KEY);

}

// 声明死信队列B绑定关系

@Bean

public Binding deadLetterBindingB(@Qualifier(“deadLetterQueueB”) Queue queue,

@Qualifier(“deadLetterExchange”) DirectExchange exchange) {

return BindingBuilder.bind(queue).to(exchange).with(DEAD_LETTER_QUEUEB_ROUTING_KEY);

}

}

  • 消息的生产者

import org.springframework.amqp.rabbit.core.RabbitTemplate;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.stereotype.Component;

import org.springframework.stereotype.Service;

import static com.talent.infocenter.rabbitmq.RabbitMQConfig.*;

@Service

public class DelayMessageSender {

@Autowired

private RabbitTemplate rabbitTemplate;

public enum DelayTypeEnum {

DELAY_10s, DELAY_60s;

}

public static DelayTypeEnum getByIntValue(int value) {

switch (value) {

case 10:

return DelayTypeEnum.DELAY_10s;

case 60:

return DelayTypeEnum.DELAY_60s;

default:

return null;

}

}

public void sendMsg(String msg, DelayTypeEnum type) {

switch (type) {

case DELAY_10s:

rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_QUEUEA_ROUTING_KEY, msg);

break;

case DELAY_60s:

rabbitTemplate.convertAndSend(DELAY_EXCHANGE_NAME, DELAY_QUEUEB_ROUTING_KEY, msg);

break;

}

}

}

  • 消费者

我们创建两个消费者，分别消费10s和60s的订单

import com.rabbitmq.client.Channel;

import lombok.extern.slf4j.Slf4j;

import org.springframework.amqp.core.Message;

import org.springframework.amqp.rabbit.annotation.RabbitListener;

import org.springframework.stereotype.Component;

import java.io.IOException;

import java.util.Date;

import static com.talent.infocenter.rabbitmq.RabbitMQConfig.DEAD_LETTER_QUEUEA_NAME;

import static com.talent.infocenter.rabbitmq.RabbitMQConfig.DEAD_LETTER_QUEUEB_NAME;

@Slf4j

@Component

public class DeadLetterQueueConsumer {

@RabbitListener(queues = DEAD_LETTER_QUEUEA_NAME)

public void receiveA(Message message, Channel channel) throws IOException {

String msg = new String(message.getBody());

log.info(“当前时间：{},死信队列A收到消息：{}”, new Date().toString(), msg);

channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);

}

@RabbitListener(queues = DEAD_LETTER_QUEUEB_NAME)

public void receiveB(Message message, Channel channel) throws IOException {

String msg = new String(message.getBody());

log.info(“当前时间：{},死信队列B收到消息：{}”, new Date().toString(), msg);

channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);

}

}

  • 创建一个接口进行测试

import com.talent.infocenter.rabbitmq.DelayMessageSender;

import lombok.extern.slf4j.Slf4j;

import org.springframework.beans.factory.annotation.Autowired;

import org.springframework.web.bind.annotation.RequestMapping;

import org.springframework.web.bind.annotation.RequestMethod;

import org.springframework.web.bind.annotation.RequestParam;

import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

import java.util.Objects;

@Slf4j

@RestController

public class RabbitMQMsgController {

@Autowired

private DelayMessageSender sender;

@RequestMapping(value = “sendmsg”, method = RequestMethod.GET)

public void sendMsg(@RequestParam(value = “msg”) String msg, @RequestParam(value = “delayType”) Integer delayType) {

log.info(“当前时间：{},收到请求，msg:{},delayType:{}”, new Date(), msg, delayType);

sender.sendMsg(msg, Objects.requireNonNull(DelayMessageSender.getByIntValue(delayType)));

}

}

接下来开始测试，我用的是swagger，大家可以用postman等其他方法自行测试

在这里插入图片描述

在这里插入图片描述

打开我们的rabbitmq后台就可以看到我们交换机和队列信息

在这里插入图片描述

同样的方法，我们创建一个60s之后才能消费的订单

在这里插入图片描述

在这里插入图片描述

上面的实现仅能设置两个指定的时间10s和60s，接下来我们设置任意时间的延迟队列

4.3 RabbitMq的优化

我们需要一种更通用的方案才能满足需求，那么就只能将TTL设置在消息属性里了，只有如此我们才能更加灵活的实现延迟队列的具体业务开发，方法也很简单，我们只需要增加一个延时队列，用于接收设置为任意延时时长的消息，同时增加一个相应的死信队列和routingkey，但是该方法有个极大的弊端就是如果使用在消息属性上设置TTL的方式，消息可能并不会按时“死亡“，因为RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列，所以如果第一个消息的延时时长很长，而第二个消息的延时时长很短，则第二个消息并不会优先得到执行，此处则不再进行编写代码，但是为了解决这个问题，我们将利用rabbitMq插件实现延迟队列。

4.4 利用插件实现延迟队列

4.4.1 下载插件

点击此处下载

在这里插入图片描述

下载完成之后进行解压，此处推荐bandzip进行解压，并且将解压之后的文件夹放到rabbitmq的安装目录下的plugins目录下

在这里插入图片描述

进入到sbin目录下使用cmd执行以下指令来启用插件

rabbitmq-plugins enable rabbitmq_delayed_message_exchange

在这里插入图片描述

执行以上步骤之后开始重启我们的rabbitmq服务

  • 1.进入到服务

在这里插入图片描述

最后

面试一面会问很多基础问题，而这些基础问题基本上在网上搜索，面试题都会很多很多。最好把准备一下常见的面试问题，毕竟面试也相当与一次考试，所以找工作面试的准备千万别偷懒。面试就跟考试一样的，时间长了不复习，现场表现肯定不会太好。表现的不好面试官不可能说，我猜他没发挥好，我录用他吧。

96道前端面试题：

常用算法面试题：

前端基础面试题：
内容主要包括HTML，CSS，JavaScript，浏览器，性能优化

执行以上步骤之后开始重启我们的rabbitmq服务

  • 1.进入到服务

在这里插入图片描述

最后

面试一面会问很多基础问题，而这些基础问题基本上在网上搜索，面试题都会很多很多。最好把准备一下常见的面试问题，毕竟面试也相当与一次考试，所以找工作面试的准备千万别偷懒。面试就跟考试一样的，时间长了不复习，现场表现肯定不会太好。表现的不好面试官不可能说，我猜他没发挥好，我录用他吧。

96道前端面试题：

  • [外链图片转存中…(img-xB9m6IkN-1719223135263)]

常用算法面试题：

  • [外链图片转存中…(img-k54ov6LQ-1719223135264)]

前端基础面试题：
内容主要包括HTML，CSS，JavaScript，浏览器，性能优化

2401_85123458
关注
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
热门推荐
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
RabbitMQ延迟队列（重要）
qq_46112274的博客
11-06 2900
RabbitMQ延迟队列
SpringBoot中，如何整合RabbitMQ实现延时队列？
l081499的博客
02-27 913
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 (1)商城订单超时未支付，取消订单 (2)使用权限到期前十分钟提醒用户 (3)收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis...
rabbitmq 延时队列
最新发布
qq_41893505的博客
02-25 780
通过，你可以非常方便地实现延时队列。只需要创建一个支持延迟的交换机，并通过设置x-delay属性来指定消息的延迟时间。
RabbitMQ延迟队列实现
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
07-11 1348
1) 生产者生产一条延迟消息，根据延迟时间的不同，利用不同的routing-key将消息路由到不同的延迟队列，每个队列都设置了不同的 TTL 属性 ( TTL ( Time To Live ) 生存时间 )，并绑定到同一个死信交换机中。 2) 消息过期后，根据routing-key的不同，又会被死信交换机路由到不同的死信队列中，消费者只需要监听对应的死信队列进行消费即可。......
rabbitMq实现延迟队列(1)
2401_84092903的博客
04-13 1065
前端面试题汇总前端面试题是我面试过程中遇到的面试题，每一次面试后我都会复盘总结。
rabbitMQ实现延迟队列
2301_78149288的博客
01-07 2025
自定义的交换机是一种新的交换类型（CustomExchange），这种类型消息支持延迟投递机制消息传递之后不会立即投递到目标队列当中，而是存储在mnesia（一个分布式数据系统）表当中，当到达投递时间之后，才会投递到目标队列当中。//声明目标队列//声明基于插件实现的交换机}*///基于插件实现的交换机，必须是CustomExchange类型，标识这是一个延时类型的交换机/*
RabbitMQ实现延迟队列
后端
07-07 1722
死信交换机、延迟队列插件① 声明死信交换机并编写监听方法② 声明延迟队列和对应的交换机，在声明队列时配置ttl属性③ 发送消息时，设置超时时间（实际上延迟队列的ttl和消息的超时时间至少有一个设置了就行）① 声明一个交换机，设置 delayed属性为true② 发送消息时，添加 x-delay头，值为超时时间。
基于RabbitMQ实现延迟队列
m0_73620832的博客
07-30 955
延迟队列是一种用来存放需要在指定时间之后或之前被处理的元素的队列。队列中的每个元素都指定了一个延迟时间，该时间表示元素应该在何时被取出并处理。在延迟时间到达之前，元素会保持在队列中，不会被消费者立即消费。
【RabbitMQ | 第四篇】基于RabbitMQ实现延迟队列
踢桃的成长之路
03-19 2785
RabbitMQ系列第四篇介绍了延迟队列的定义（存储延迟消息的队列）、两种实现延迟队列的方法（基于DLX、以及基于插件），重点为基于DLX和TTL方法，核心思路为为普通消息队列根据binding key绑定指定的死信交换机，再为死信交换机绑定一个死信队列，以及使用消费者监听死信队列；最后消息发送者发送消息即可
在Spring Boot中使用RabbitMQ实现延迟队列
qq_42572322的博客
08-15 942
2. **使用RabbitMQ的延迟插件**：从RabbitMQ 3.5.7版本开始，可以使用`rabbitmq-delayed-message-exchange`插件来实现延迟队列。另外，还可以使用TTL和DLX结合的方式来实现延迟队列，这种方式不需要安装任何插件，适用于RabbitMQ的早期版本。可以通过设置队列的`x-message-ttl`属性或消息的`expiration`属性来实现消息的延迟消费，当消息成为死信后，会被发送到配置的DLX，进而路由到一个监听的队列进行消费。
SpringBoot+RabbitMQ实现延迟队列
LoveLacie的博客
04-08 483
一、什么是延迟队列? 先来说一下什么是延迟队列,延迟队列就是消息进入队列之后不会立即被消息,只有达到指定时间后,才会被消费. 常见需求: 1、在网上商城下单后,30分钟未支付,取消订单,回滚库存; ​ 2、新用户注册成功7天后,发送短信. 实现方法: 1、定时器 2、延迟队列 但RabbitMQ未提供延迟队列功能,但是可以使用**TTL+死信队列(DLX)**组...
如何使用PHP和RabbitMQ实现延迟队列（方式二）？
zhangbin1988的专栏
03-25 1080
用PHP和RabbitMQ实现消息队列的延迟功能的两种方式。1、使用RabbitMQ的插件。如何使用PHP和RabbitMQ实现延迟队列（方式一）？-CSDN博客2、使用RabbitMQ的死信队列（Dead-Letter-Exchanges, DLX）和消息TTL（Time-To-Live）上面的代码只是做个简单的示例，如果运用到实际的项目当中需要做进一步的优化。
rabbitMq实现延时队列
chuizhuquan8731的博客
08-12 178
rabbitMq是受欢迎的消息中间件之一，相比其他的消息中间件，具有高并发的特性（天生具备高并发高可用的erlang语言编写），除此之外，还可以持久化，保证消息不易丢失，高可用，实现集群部署，提供灵活的路由和可靠性，可视化管理等等的优点。 相比于其他的消息队列，rabbitm...
一口气说出 6种 延时队列的实现方法，面试官也得服
HollisChuang's Blog
05-14 940
一、延时队列的应用什么是延时队列？顾名思义：首先它要具有队列的特性，再给它附加一个延迟消费队列消息的功能，也就是说可以指定队列中的消息在哪个时间点被消费。延时队列在项目中的应用还是比较多...
RabbitMQ实现延时队列
lianaozhe的博客
02-27 586
延时队列，首先，它是一种队列，队列意味着内部的元素是有序的，元素出队和入队是有方向性的，元素从一端进入，从另一端取出。其次，延时队列，最重要的特性就体现在它的延时属性上，跟普通的队列不一样的是，普通队列中的元素总是等着希望被早点取出处理，而延时队列中的元素则是希望被在指定时间得到取出和处理，所以延时队列中的元素是都是带时间属性的，通常来说是需要被处理的消息或者任务。简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。
RabbitMQ之“延时队列”
2302_77971734的博客
03-21 3187
延迟队列存储的对象是对应的延迟消息，所谓“延迟消息”是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值