RabbitMQ——死信队列和延迟队列

最新推荐文章于 2025-07-04 21:52:12 发布
原创 最新推荐文章于 2025-07-04 21:52:12 发布 · 1.6k 阅读 · 23 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#rabbitmq

文章目录

RabbitMQ——死信队列和延迟队列

1、死信队列

死信队列（Dead Letter Queue，DLQ）是 RabbitMQ 中的一种重要特性，用于处理无法被消费的消息，防止消息丢失。

死信的来源

在消息队列中，当消息满足一定条件而无法被正常消费时，这些消息会被发送到死信队列。满足条件的情况包括但不限于：

  • 消息被拒绝（basic.reject 或 basic.nack）且不重新入队（requeue 参数为 false）。
  • 消息过期（TTL，Time-To-Live）。
  • 队列长度超过限制，无法再添加数据到mq中。

生产者

package com.weipch.rabbitmq.dlq;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.GetResponse;
import com.weipch.util.RabbitMqUtils;

/**
 * @Author 方唐镜
 * @Create 2024-03-03 14:08
 * @Description
 */
public class Produce {


	private static final String NORMAL_EXCHANGE = "normal_exchange";


	public static void main(String[] args) throws Exception {
		Channel channel = RabbitMqUtils.getChannel();
        //模拟消息过期 10s
		//AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
		for (int i = 0; i < 10; i++) {
			String message = "hello world" + i;
			channel.basicPublish(NORMAL_EXCHANGE, "normal-routing-key", null, message.getBytes());
		}
	}
}

消费者

正常队列：

package com.weipch.rabbitmq.dlq;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.weipch.util.RabbitMqUtils;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author 方唐镜
 * @Create 2024-03-03 13:50
 * @Description
 */
public class Consumer01 {


	private static final String NORMAL_EXCHANGE = "normal_exchange";
	private static final String DEAD_EXCHANGE = "dead_exchange";

	private static final String NORMAL_QUEUE = "normal_queue";
	private static final String DEAD_QUEUE = "dead_queue";


	public static void main(String[] args) throws Exception {
		Channel channel = RabbitMqUtils.getChannel();
		//声明死信交换机和队列
		channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
		channel.queueDeclare(DEAD_QUEUE, false, false, false, null);
		//绑定
		channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, "dead-routing-key");


		//声明普通交换机和队列
		channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
		//死信配制 指定死信交换机和死信路由键
		Map<String, Object> map = new HashMap<>();
		map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
		map.put("x-dead-letter-routing-key", "dead-routing-key");
		//最大长度
		//map.put("x-max-length", 6);
		channel.queueDeclare(NORMAL_QUEUE, false, false, false, map);
		channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, "normal-routing-key");
		DeliverCallback deliverCallback = (consumerTag, delivery) -> {
			String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
			if (message.contains("5")){
				System.out.println("Consumer01接收消息：" + message + "，此消息被拒绝");
				//拒绝消息并把消息丢入死信队列
				channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false);
			}else {
				System.out.println("Consumer01接收消息：" + message);
				channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
			}
		};
		channel.basicConsume(NORMAL_QUEUE, false, deliverCallback, (consumerTag, e) -> {});
	}
}

死信队列：

package com.weipch.rabbitmq.dlq;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.weipch.util.RabbitMqUtils;

import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Map;

/**
 * @Author 方唐镜
 * @Create 2024-03-03 13:50
 * @Description
 */
public class Consumer02 {
	
	private static final String DEAD_QUEUE = "dead_queue";

	public static void main(String[] args) throws Exception {
		Channel channel = RabbitMqUtils.getChannel();
		channel.basicConsume(DEAD_QUEUE, true,
			(consumerTag, delivery) -> System.out.println("Consumer02:" + new String(delivery.getBody(), StandardCharsets.UTF_8)),
			(consumerTag, e) -> {});
	}
}

生产者发送消息到正常队列，而消费者负责消费正常队列的消息。当消息被消费者拒绝并不再重新投递时，消息会被发送到死信队列。

2、基于插件的延迟队列

延迟队列是一种消息队列中的一种特殊类型，它允许消息在一定的延迟时间后再被消费。延迟队列的元素是希望在指定时间到了以后或之前取出处理。在实际应用中，延迟队列通常用于处理需要延时执行的任务或事件。

使用场景

  1. 定时任务执行： 在需要定时执行任务的应用中，可以使用延迟队列来实现。将任务消息发送到延迟队列，设置消息的过期时间为任务执行的时间，当消息过期时，消费者即可执行相应的任务。
  2. 消息重试机制： 当某个操作失败时，可以将操作消息发送到延迟队列，并设置合适的重试时间。在消息重试的过程中，如果操作成功，消息将正常被消费；如果一直失败，可以选择在一定时间后放弃重试，将消息发送到死信队列或进行其他处理。
  3. 订单超时处理： 在电商等场景中，对于长时间未支付的订单，可以将订单消息发送到延迟队列，并设置订单的过期时间。当订单过期时，系统可以取消订单、释放库存等操作。
  4. 限流与流控： 通过使用延迟队列，可以实现消息的有序处理和限流，确保系统在高峰期不会因为瞬时大量请求而过载。
  5. 系统通知与提醒： 在需要发送系统通知或提醒的场景中，可以使用延迟队列来实现消息的定时推送。
  6. 缓解数据库压力： 对于一些需要定期清理的数据，可以使用延迟队列来触发数据清理操作，减轻数据库压力。

2.1、安装延迟队列插件

下载地址：https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases

以docker方式安装

1、把下载好的插件从服务器拷贝到 RabbitMQ 容器内plugins目录

docker cp rabbitmq_delayed_message_exchange-3.13.0.ez 7c8726620871:/plugins

插件版本和rabbitmq版本一致

2、进入容器查看插件

在这里插入图片描述

3、启动插件

root@my-rabbit:/plugins# rabbitmq-plugins enable rabbitmq_delayed_message_exchange

4、重启容器

docker restart 7c8726620871

5、安装成功

在这里插入图片描述

2.2、代码实例

配置类

package springbootrabbitmq.config;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

import java.util.HashMap;


@Configuration
public class DelayedQueueConfig {
    //    队列
    public static final String DELAYED_QUEUE_NAME = "delayed.queue";
    //    交换机
    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
    //    routingKey
    public static final String DELAYED_ROUTING_KEY = "delayed.routingKey";

    //    声明队列
    @Bean
    public Queue delayedQueue() {
        return new Queue(DELAYED_QUEUE_NAME);
    }

    //    声明交换机 基于插件的交换机
    @Bean
    public CustomExchange delayedExchange() {

        HashMap<String, Object> arguments = new HashMap<>();
        arguments.put("x-delayed-type", "direct");
        /*
         * 1.交换机名称
         * 2.交换机类型
         * 3.是否需要持久化
         * 4.是否需要自动删除
         * 5.其他参数
         * */
        return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, arguments);
    }

    //    绑定
    @Bean
    public Binding delayedQueueBindingDelayedExchange(@Qualifier("delayedQueue") Queue delayedQueue, @Qualifier("delayedExchange") CustomExchange delayedExchange) {
        return BindingBuilder.bind(delayedQueue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
    }
}

生产者

@GetMapping("/sendDelayMsg/{message}/{delayTime}")
public void sendMsg(@PathVariable String message, @PathVariable Integer delayTime) {
    log.info("当前时间：{}，发送一条时长{}毫秒消息给延迟队列delayed.queue：{}", new Date(), delayTime, message);
    rabbitTemplate.convertAndSend(DelayedQueueConfig.DELAYED_EXCHANGE_NAME, DelayedQueueConfig.DELAYED_ROUTING_KEY, message, msg -> {
        //            发送消息的时候 延迟时长
        msg.getMessageProperties().setDelay(delayTime);
        return msg;
    });
}

消费者

@Slf4j
@Component
public class DelayedQueueConsumer {
    //监听消息
    @RabbitListener(queues = DelayedQueueConfig.DELAYED_QUEUE_NAME)
    public void receiveDelayedQueue(Message message) {
        String msg = new String(message.getBody());
        log.info("当前时间：{}，收到延迟队列的消息：{}", new Date(), msg);
    }
}
RabbitMQ 高级特性——死信队列
不能再留遗憾了的博客
10-11 2054
RabbitMQ死信队列
RabbitMQ——死信队列介绍和项目应用
xyendjsj的博客
02-04 1140
RabbitMQ——死信队列介绍和项目应用。如果你不还不了解死信队列，或者不知道其在项目中的应用的话，看完我的文章你一定会有所收获。
使用RabbitMQ死信实现延迟消息
05-24
spring boot 配置， Rabbitmq集成, 利用死信 实现延时消息队列实现
RabbitMQ死信队列和延迟队列
孟斌斌的博客
03-22 1669
1）“死信”是RabbitMQ中的一种消息机制。2）消息变成死信，可能是由于以下的原因：- 消息被拒绝- 消息过期- 队列达到最大长度3）死信队列当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是 DLX(Dead-Letter-Exchange ) ，绑定 DLX 的队列就称之为死信队列。
RabbitMQ 高级特性之死信队列
最新发布
2301_79184547的博客
07-04 889
本文介绍了RabbitMQ中的死信队列机制。当消息因重试超次、过期或队列溢出成为死信时，可通过配置专用死信队列进行存储。文章详细说明了死信的产生场景：重试次数超标、TTL过期、队列溢出。通过Spring配置示例展示了如何建立正常队列与死信队列的绑定关系，并验证了三种场景下消息进入死信队列的过程。实验结果表明，超过重试次数（5次）、超过TTL（10秒）以及超出队列容量（10条）的消息都能正确转入死信队列。这种机制有效解决了异常消息的处理问题，确保重要数据不会丢失。
RabbitMQ中死信队列和延迟队列
Knight
03-30 2938
先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列；
rabbitmq死信队列及延迟队列
sashaSloan的博客
01-11 1010
看起来似乎没什么问题，但是如果使用在消息属性上设置TTL的方式，消息可能并不会按时“死亡“，因为RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望。
【RabbitMQ】死信队列、延迟队列
weixin_73060900的博客
09-20 1982
对死信队列、延迟队列的概述以及简单代码案例
浅谈RabbitMQ——死信队列与延迟队列
tanning11627的博客
05-25 416
死信队列 引言 死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），其实应该叫做死信交换机才更恰当。 当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。 总结：其实死信队列就是一个普通的交换机，有些队列的消息成为死信后，（比如过期了或者队列满了）这些死信一般情况下是会被 RabbitMQ 清理的。但是你可以配置某个交换机为此队列的死信交换机，该队列的消息成为死信后会被重新发送到此 DLX 。至于怎么处理这个DLX中的死信就是看具体
rabbitmq通过死信队列实现延迟任务——java
qq_45735918的博客
07-29 450
很多场景下都需要延迟任务，比如一笔订单50分钟后还没支付则过期，发出去的红包24小时后未领取则自动过期，合同第一次签署失败后20秒后再尝试签署一次。。。。 本博客介绍如何使用rabbitmq通过死信队列实现延迟任务。 首先是配置rabbitmq环境，关于如何配置与mq的各种参数详解，请移步https://blog.csdn.net/echizao1839/article/details/105533214 当配置好以后，我们需要创建一个配置类，方便我们管理交换机与队列 @Configuration publ
RabbitMQ延迟队列的实现——TTL+死信队列DLX
保暖透气大裤衩LeoLee的博客
11-08 645
大伙可以到我的RabbitMQ专栏获取更多信息 demo示例这里拿 概述 什么是延迟队列 延迟队列，即消息到达队列后不会被立即消费，只有到达指定的时间后，才会被消费 场景： 下单后，30分钟为结算，自动取消该订单，被锁商品重回库存 新用户注册1小时之后，发短信问候 实现方式： 定时器：以某个时间间隔去轮询订单表中的下单时间并于当前时间比对，超过30分钟就取消该订单。该方式不优雅，性能消耗大，数据库压力大。 MQ延迟队列：当用户下单之后，订单生成，就发送一条消息到MQ延迟队列，该消息30分钟
RabbitMq死信队列和延时队列
远方的少年
11-25 1103
RabbitMq提供了一个死信队列的功能，可以在消息被拒绝或者过期后还没消费时，扔到死信队列里面，然后通过邮件告警等方式来手工处理. 进入死信队列的三种方式 1.消息被Basic.reject()或者Basic.nack().并且request设置为false,即不重试 2.消息设置了过期时间，并且过期时间到了还没有被消费 3.消息队列的长度达到了最大值。 通常一个项目里面使用一个死信队列，然后再业务队列里面设置好死信队列。这样当业务消费出现异常时，可以加入死信队列，这样可以防止消息丢失。..
RabbitMQ - 死信队列，延时队列
MinggeQingchun的博客
06-11 3975
而在第二种方法中，即使消息过期，也不会马上从队列中抹去，因为每条消息是否过期是在即将投递到消费者之前判定的。参数，那么它会被发送到x-dead-letter-exchange对应值的交换器上，这个交换器就称之为死信交换器，与这个死信交换器绑定的队列就是死信队列。DLX 全称（Dead-Letter-Exchange）,称之为死信交换器，当消息变成一个死信之后，如果这个消息所在的队列存在。消费者二监听的死信队列收到消息。进入死信队列之后，headers 加了一些死信相关的信息，包括原队列以及进入死信的原因。
【RabbitMQ学习日记】——死信队列与延迟队列
欢迎来到我的世界
04-13 2574
介绍了死信队列与延迟队列的概念与用法，也包括通过死信队列实现延迟队列、通过占位符传参优化延迟队列、通过插件设置延迟队列等
RabbitMQ的死信队列及延迟队列
我能在河边钓一整天的鱼
07-07 534
目录 过期时间TTL 死信队列 延迟队列 消息确认机制 消息追踪机制 过期时间TTL TTL表示可以对消息设置预期时间，在这个时间内的消息可以被消费者接收获取，过了之后消息自动被删除。RabbitMQ设置TTL有两种方式~ 通过队列属性进行设置，队列中的所有消息都有相同的过期时间 对消息进行单独设置，每条消息TTL可以不同 如果同时使用上述两种方法，则消息过期时间以两者之间的TTL较小数值为准。消息在队列的生存时间一旦超过了TTL值，就称为dead message并被投递到..
RabbitMQ的死信队列和延迟队列
刘皇叔说Java的博客
02-23 1841
一般用在较为重要的业务队列中，确保未被正确消费的消息不被丢弃，一般发生消费异常可能原因主要有由于消息信息本身存在错误导致处理异常，处理过程中参数校验异常，或者因网络波动导致的查询异常等等，当发生异常时，当然不能每次通过日志来获取原消息，然后让运维帮忙重新投递消息。先把订单消息设置好 15 分钟过期时间，然后过期后队列将消息转发给我们设置好的 DLX-Exchange，DLX-Exchange 再将分发给它绑定的队列，我们的消费者再消费这个队列中的消息，就做到了延时十五分钟消费。
RabbitMQ 死信队列和延迟队列
立志成为一个前端、后端、测试全方位发展的程序员
04-07 1003
文章目录死信队列延迟队列 死信队列 死信队列，英文缩写：DLX （Dead Letter Exchange（死信交换机）），当消息成为 Dead message 后，可以被重新发送到另一个交换机，这个交换机就是DLX 在RabbitMQ中死信队列一般指的是死信交换机，其余MQ产品则指的是实际意义的死信队列 比如一条消息过期后，这条消息就成为了 Dead message，如果该消息所在的队列绑定了死信交换机 可以将这个 Dead message 发送到死信交换机，被传递到与死信交换机绑定的死信队列中进行
RabbitMQ（五）死信队列和延迟队列
yfy的博客
04-08 4428
1.1 概念 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列
RabbitMQ 死信队列 延迟队列
@小刘同学nice
07-22 429
死信队列 死信的概念 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信
rabbitmq死信队列加入条件
03-24
### 如何在 RabbitMQ 中设置死信队列的加入条件 在 RabbitMQ 中，通过配置特定的消息属性或队列参数可以定义消息进入死信队列 (DLQ) 的条件。以下是详细的说明以及示例代码。 #### 死信队列的工作原理 当满足某些条件时，RabbitMQ 会将无法正常处理的消息转发至指定的死信交换机 (Dead-Letter Exchange, DLX)，从而实现死信队列的功能。这些条件通常包括但不限于以下几种情况： - 消息被消费者拒绝并重新入队失败（`basic.reject` 或 `basic.nack` 调用时设置了 `requeue=false`）[^1]。 - 消息过期（TTL，Time-To-Live 属性超时）[^2]。 - 队列达到最大长度限制或其他资源约束[^3]。 #### 配置死信队列的具体方法 为了使某个队列能够支持死信机制，需为其声明三个关键参数： 1. **x-dead-letter-exchange**: 定义目标死信交换机名称。 2. **x-dead-letter-routing-key**: 可选字段，用于指定路由键。 3. **x-message-ttl**（可选）: 设置消息存活时间，超过该时间后自动进入死信队列。 下面提供了一个基于 Spring Boot 和 Java 的完整示例来演示这一过程。 ```java import org.springframework.amqp.core.*; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; @Configuration public class RabbitMqConfig { @Bean public Queue mainQueue() { Map<String, Object> args = new HashMap<>(); // 声明此队列为具有死信特性的队列 args.put("x-dead-letter-exchange", "dlx.exchange"); args.put("x-dead-letter-routing-key", "dl.routing.key"); return QueueBuilder.durable("main.queue").withArguments(args).build(); } @Bean public DirectExchange dlxExchange() { return new DirectExchange("dlx.exchange"); } @Bean public Queue deadLetterQueue() { return new Queue("dead.letter.queue", true); } @Bean public Binding binding(DirectExchange dlxExchange, Queue deadLetterQueue) { return BindingBuilder.bind(deadLetterQueue).to(dlxExchange).with("dl.routing.key"); } } ``` 上述代码片段展示了如何创建一个主队列 (`main.queue`) 并将其关联到名为 `dlx.exchange` 的死信交换机上。如果消息未能成功消费，则会被重定向到另一个队列——即所谓的“死信队列”。 另外，在 TypeScript 环境下同样可以通过插件启用延迟特性，并利用命令行工具完成必要的初始化操作[^4]: ```bash rabbitmq-plugins enable rabbitmq_delayed_message_exchange ``` 随后可通过 API 查看当前系统的 exchange 列表验证安装效果: ```bash rabbitmqadmin list exchanges ``` #### 总结 综上所述，合理规划好各个组件之间的协作关系对于构建高效的错误恢复策略至关重要。除了基本的 TTL 控制外，还可以结合业务逻辑动态调整哪些情形应该触发向 DLQ 的转移行为。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

万里顾—程

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

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

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

打赏作者

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

抵扣说明：

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

余额充值