RabbitMQ 死信和延迟队列

最新推荐文章于 2025-06-30 22:33:09 发布
最新推荐文章于 2025-06-30 22:33:09 发布
阅读量1.5k 收藏 20
点赞数 15
CC 4.0 BY-SA版权
分类专栏： MQ 消息队列 文章标签： java-rabbitmq rabbitmq java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44374928/article/details/144592646

1. 死信队列

1.1. 死信的概念

死信也就是无法被消费的消息，一般来说，producer 将消息投递到 broker 或 queue 里，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有死信队列

应用场景：为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列中；还有比如说：用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

1.2. 死信的来源

  1. 消息TTL过期（time to live，生存时间）
  2. 队列达到最大长度（队列满了，无法再添加数据到MQ中）
  3. 消息被拒绝（basic.reject 或 basic.nack 并且 requeue = false）

1.3. 死信实战

1.3.1. 死信之 TTL

public class Consumer01 {

    //普通交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";
    //死信交换机名称
    private static final String DEAD_EXCHANGE = "dead_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        // 声明死信和普通交换机，类型为 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        // 声明死信队列
        String deadQueue = "DEAD-QUEUE";
        channel.queueDeclare(deadQueue, false, false, false, null);
        // 死信队列绑定：队列、交换机、路由键（routingKey）
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        //正常队列绑定死信队列信息的其他参数
        Map<String, Object> params = new HashMap<>();
        // 过期时间一般设置在生产者，过期时间为 10s
        // params.put("x-message-ttl", 10000)
        // 正常队列绑定死信交换机，参数 key 是固定值
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        // 正常队列设置死信 routing-key，参数 key 是固定值
        params.put("x-dead-letter-routing-key", "lisi");

        //正常队列
        String normalQueue = "NORMAL-QUEUE";
        channel.queueDeclare(normalQueue, false, false, false, params);
        // 正常队列绑定正常交换机
        channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");

        System.out.println("等待接收消息........... ");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Consumer01 接收到消息" + message);
        };
        channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {
        });
    }
}
public class Producer01 {

    private static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] argv) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        // 设置消息的 TTL 时间 10s
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();

        // 该信息是用作演示队列个数限制
        for (int i = 1; i < 11; i++) {
            String message = "info" + i;
            channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", properties, message.getBytes());
            System.out.println("生产者发送消息:" + message);
        }

    }
}
public class Consumer02 {

    //死信交换机名称
    private static final String DEAD_EXCHANGE = "dead_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();

        // 声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        // 声明队列
        String deadQueue = "DEAD-QUEUE";
        channel.queueDeclare(deadQueue, false, false, false, null);
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        System.out.println("等待接收死信消息........... ");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
            System.out.println("Consumer02 接收到消息" + message);
        };
        channel.basicConsume(deadQueue, true, deliverCallback, consumerTag -> {
        });
    }
}

启动 消费者C1 ，之后关闭消费者，模拟其接收不到消息；再启动 Producer

生产者未发送消息

生产者发送10条消息，关闭消费者C1，此时正常的消息队列有10条未消费的信息

时间过去 10s，正常队列里面的消息由于没有被消费，消息进入死信队列

以上步骤完成后，启动 C2 消费者，它消费死信队列里面的消息

1.3.2. 死信之 最大长度

  1. 消息生产者代码去掉 TTL 属性

  1. 消费者 C1 修改以下代码（启动之后关闭该消费者C1，模拟其接收不到消息）
// 设置正常队列的长度限制，例如发10个，4个则为死信
params.put("x-max-length",6);

注意：此时需要把原先队列删除 因为参数改变了

  1. 消费者C2 代码不变（关闭C1，启动生产者）

  1. 启动消费者 C1 和 C2

消费者 C1 消费 6 个消息，设置队列中最多是 6 个消息

消费者 C2 从死信队列中消费 4 个消息

1.3.3. 死信之 消息被拒绝

  1. 消息生产者代码保持不变
  2. C1 消费者代码（启动之后关闭该消费者C1，模拟其接收不到消息），拒收消息"info5"
  3. 开启手动应答
  4. C2 消费者代码保持不变

关闭消息者 C1，然后生产者发送消息之后

启动消费者 C1，然后再启动消费者 C2

消费者 C2 从死信队列中获取消息 info5，也就是消费者 C1 拒绝的消息 info5

2. 延迟队列

2.1. 延迟队列介绍

延迟队列的内部是有序的，特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列

使用场景：

  1. 订单在十分钟之内未支付则自动取消
  2. 新创建的店铺如果十天内没有上传过商品，则会自动发消息提醒；
  3. 账号注册成功，如果三天内没登陆则进行短信提醒
  4. 用户发起退款，如果三天内没有得到处理则通知相关运营人员
  5. 预定会议后，需要在预定的时间点前十分钟通知各个与会人员参加会议

2.2. RabbitMQ 中的 TTL

TTL 是 RabbitMQ 中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间，单位是 ms；换句话说，如果一条消息设置了 TTL 属性或者进入了设置 TTL 属性的队列，那么这条消息如果在 TTL 设置的时间内没有被消费，则会成为"死信"；

如果同时配置了队列的TTL 和消息的 TTL，那么较小的那个值将会被使用，有两种方式设置 TTL

  1. 队列设置 TTL：创建队列时设置“x-message-ttl”属性

  1. 消息设置 TTL：针对每条消息设置 TTL

  1. 两者的区别

如果设置队列设置 TTL 属性，那么一旦消息过期，就会被队列丢弃（如果配置了死信队列被丢到死信队列中），而消息设置 TTL 属性，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；

注意：如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以直接投递该消息到消费者，否则该消息将会被丢弃

2.3. 整合 SpringBoot

  1. 添加依赖
<dependencies>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter</artifactId>
  </dependency>
  <!--RabbitMQ 依赖-->
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-amqp</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
  </dependency>
  <dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-test</artifactId>
    <scope>test</scope>
  </dependency>
  <dependency>
    <groupId>com.alibaba</groupId>
    <artifactId>fastjson</artifactId>
    <version>1.2.47</version>
  </dependency>
  <dependency>
    <groupId>org.projectlombok</groupId>
    <artifactId>lombok</artifactId>
  </dependency>
  <!--swagger-->
  <dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger2</artifactId>
    <version>3.0.0</version>
  </dependency>
  <dependency>
    <groupId>io.springfox</groupId>
    <artifactId>springfox-swagger-ui</artifactId>
    <version>3.0.0</version>
  </dependency>
  <!--RabbitMQ 测试依赖-->
  <dependency>
    <groupId>org.springframework.amqp</groupId>
    <artifactId>spring-rabbit-test</artifactId>
    <scope>test</scope>
  </dependency>
</dependencies>
  1. 修改配置文件
spring.rabbitmq.host=42.192.149.71
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123456
  1. 添加 Swagger 配置类（可以去Swagger查看笔记）

2.4. 队列 TTL

@Configuration
public class TtlQueueConfig {

    public static final String X_EXCHANGE = "X";
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    //死信交换机
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    //死信队列
    public static final String DEAD_LETTER_QUEUE = "QD";

    // 声明正常交换机
    @Bean("xExchange")
    public DirectExchange getXExchange() {
        return new DirectExchange(X_EXCHANGE);
    }

    // 声明死信交换机
    @Bean("yExchange")
    public DirectExchange getYExchange() {
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    // 声明队列 QA , 过期时间为 10s 并绑定到对应的死信交换机
    @Bean("QA")
    public Queue getQAQueue() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
    }

    // 声明队列 QB , 过期时间为 40s 并绑定到对应的死信交换机
    @Bean("QB")
    public Queue getQBQueue() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("y-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("y-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 10000 * 40);
        return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
    }

    // 队列 QA 绑定正常交换机 X
    @Bean
    public Binding queueQABindingX(@Qualifier(value = "QA") Queue queue,
                                   @Qualifier(value = "xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queue).to(xExchange).with("XA");
    }

    // 队列 QB 绑定正常交换机 X
    @Bean
    public Binding queueQBBindingX(@Qualifier(value = "QB") Queue queue,
                                   @Qualifier(value = "xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queue).to(xExchange).with("XB");
    }

    // 声明死信队列 QD
    @Bean(value = "QD")
    public Queue getQDQueue() {
        return new Queue(DEAD_LETTER_QUEUE);
    }

    // 死信队列 QD 绑定死信交换机 Y
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier(value = "QD") Queue queue,
                                        @Qualifier("yExchange") DirectExchange yExchange) {
        return BindingBuilder.bind(queue).to(yExchange).with("YD");
    }

}

访问：http://localhost:8080/ttl/sendMsg/范智诚

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息， 然后被消费掉，这样一个延时队列就打造完成了

如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S 两个时间选项，如果需要一个小时后处理，那么就需要增加TTL 为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？

2.5. 延迟队列 TTL 优化

新增了一个队列 QC，绑定关系如下：该队列不设置TTL 时间

新增的配置类代码：

@Configuration
public class MsgTtlQueueConfig {

    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String QUEUE_C = "QC";

    //声明正常队列 QC 并绑定死信交换机 Y
    @Bean("QC")
    public Queue queueB() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //没有声明 TTL 属性
        return QueueBuilder.durable(QUEUE_C).withArguments(args).build();
    }

    //声明队列 QC 绑定 X 交换机
    @Bean
    public Binding queuecBindingX(@Qualifier("QC") Queue queue,
                                  @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queue).to(xExchange).with("XC");
    }
}
/**
 * 延时队列优化
 *
 * @param message 消息
 * @param ttlTime 延时的毫秒
 */
@GetMapping("sendExpirationMsg/{message}/{ttlTime}")
public void sendMsg(@PathVariable String message, @PathVariable String ttlTime) {
    rabbitTemplate.convertAndSend("X", "XC", message, correlationData -> {
        correlationData.getMessageProperties().setExpiration(ttlTime);
        return correlationData;
    });
    log.info("当前时间：{},发送一条时长{}毫秒 TTL 信息给队列 C:{}", new Date(), ttlTime, message);
}

发送请求访问：http://localhost:8080/ttl/sendExpirationMsg/范智诚/10000

看起来似乎没什么问题，但是在最开始的时候，就介绍过如果使用在消息属性上设置 TTL 的方式，消息可能并不会按时“死亡“；因为 RabbitMQ 只会检查第一个消息是否过期，如果过期则丢到死信队列， 如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。这也就是为什么第二个延时2秒，却后执行

2.6. RabbitMQ 插件实现延迟队列

略

浅谈RabbitMQ——死信队列与延迟队列
tanning11627的博客
05-25 414
死信队列 引言 死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），其实应该叫做死信交换机才更恰当。 当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。 总结：其实死信队列就是一个普通的交换机，有些队列的消息成为死信后，（比如过期了或者队列满了）这些死信一般情况下是会被 RabbitMQ 清理的。但是你可以配置某个交换机为此队列的死信交换机，该队列的消息成为死信后会被重新发送到此 DLX 。至于怎么处理这个DLX中的死信就是看具体
RabbitMQ 死信队列&延迟队列&安装延迟插件
weixin_42396003的博客
12-12 951
Rabbitmq 死信队列，延迟队列，安装延迟插件
【RabbitMQ】死信队列、延迟队列
weixin_73060900的博客
09-20 1979
对死信队列、延迟队列的概述以及简单代码案例
详解RabbitMQ高级特性之死信队列
最新发布
.
06-30 2444
详解RabbitMQ高级特性之死信队列以及面试题。
RabbitMQ（五）死信队列和延迟队列
yfy的博客
04-08 4428
1.1 概念 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列
RabbitMQ死信队列和延迟队列
孟斌斌的博客
03-22 1663
1）“死信”是RabbitMQ中的一种消息机制。2）消息变成死信，可能是由于以下的原因：- 消息被拒绝- 消息过期- 队列达到最大长度3）死信队列当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是 DLX(Dead-Letter-Exchange ) ，绑定 DLX 的队列就称之为死信队列。
RabbitMQ中死信队列和延迟队列
Knight
03-30 2935
先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列；
RabbitMQ的死信队列和延迟队列
就很有趣的博客
05-22 934
RabbitMQ的相关内容
SpringBoot教程（二） | SpringBoot集成RabbitMq（死信队列、延迟队列）
qq_20236937的博客
09-05 1772
SpringBoot集成RabbitMq（死信队列、延迟队列）
RabbitMQ死信队列
小生不才的博客
01-22 803
死信队列是一种特殊的消息队列,用来存储无法被正常消费的消息，常被用来实现延迟处理，异常消息处理等，提高了系统的可伸缩性和容错性，能够应对高并发和异常消息。死信队列中的消息被称为,用来分发死信消息的交换机被称为。延迟等待消息重试机制。
RabbitMq死信队列实现 延时队列
Ye7073的博客
10-21 954
RabbitMq 死信队列 延时队列 实现
【RabbitMQ学习日记】——死信队列与延迟队列
欢迎来到我的世界
04-13 2566
介绍了死信队列与延迟队列的概念与用法，也包括通过死信队列实现延迟队列、通过占位符传参优化延迟队列、通过插件设置延迟队列等
RabbitMQ（五）死信队列与延时队列
fox_bert的博客
06-11 2857
DLX，全称为 Dead-Letter-Exchange，可以称为死信交换机，也有人称之为死信邮箱，当消息在一个正常队列中变成死信（dead message）之后，它能被重新发送到另一个交换机中，这个交换机就是DLX，绑定DLX的队列就称之为死信队列。消息变成死信，可能由于以下原因：DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何队列上被指定。实际上就是设置某一个队列的属性，当这个队列中存在死信时，rabbitMQ就会自动的将这个消息重新发布到设置的DLX上去，进而被路由到另一个队列，即死信队
RabbitMQ——死信队列和延迟队列
万里顾一程的博客
03-17 1680
延迟队列是一种消息队列中的一种特殊类型，它允许消息在一定的延迟时间后再被消费。死信队列（Dead Letter Queue，DLQ）是 RabbitMQ 中的一种重要特性，用于处理无法被消费的消息，防止消息丢失。生产者发送消息到正常队列，而消费者负责消费正常队列的消息。当消息被消费者拒绝并不再重新投递时，消息会被发送到死信队列。在消息队列中，当消息满足一定条件而无法被正常消费时，这些消息会被发送到死信队列。1、把下载好的插件从服务器拷贝到 RabbitMQ 容器内plugins目录。2、进入容器查看插件。
五、RabbitMQ死信队列和延迟队列
endless_fighting的博客
05-05 3147
文章目录RabbitMQ死信队列和延迟队列RabbitMQ死信队列死信队列及TTL使用RabbitMQ控制台做一个死信队列测试Rabbit的延迟队列Rabbit延时队列样例 RabbitMQ死信队列和延迟队列 RabbitMQ死信队列 死信队列及TTL 什么是TTL？ time to live 消息存活时间 如果消息在存活时间内未被消费，则会别清除 RabbitMQ支持两种ttl设置 单独消息进行配置ttl 整个队列进行配置ttl（居多） 什么是rabbitmq的死信队列？ 没有被及时消费的消息
RabbitMq死信队列和延时队列
远方的少年
11-25 1102
RabbitMq提供了一个死信队列的功能，可以在消息被拒绝或者过期后还没消费时，扔到死信队列里面，然后通过邮件告警等方式来手工处理. 进入死信队列的三种方式 1.消息被Basic.reject()或者Basic.nack().并且request设置为false,即不重试 2.消息设置了过期时间，并且过期时间到了还没有被消费 3.消息队列的长度达到了最大值。 通常一个项目里面使用一个死信队列，然后再业务队列里面设置好死信队列。这样当业务消费出现异常时，可以加入死信队列，这样可以防止消息丢失。..
rabbitmq死信队列及延迟队列
sashaSloan的博客
01-11 1007
看起来似乎没什么问题，但是如果使用在消息属性上设置TTL的方式，消息可能并不会按时“死亡“，因为RabbitMQ只会检查第一个消息是否过期，如果过期则丢到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望。
RabbitMQ - 死信队列，延时队列
MinggeQingchun的博客
06-11 3970
而在第二种方法中，即使消息过期，也不会马上从队列中抹去，因为每条消息是否过期是在即将投递到消费者之前判定的。参数，那么它会被发送到x-dead-letter-exchange对应值的交换器上，这个交换器就称之为死信交换器，与这个死信交换器绑定的队列就是死信队列。DLX 全称（Dead-Letter-Exchange）,称之为死信交换器，当消息变成一个死信之后，如果这个消息所在的队列存在。消费者二监听的死信队列收到消息。进入死信队列之后，headers 加了一些死信相关的信息，包括原队列以及进入死信的原因。
RabbitMQ消息和队列的TTL以及死信队列和延迟队列
weixin_30911451的博客
05-22 211
TTL：TimeToLive的简称，即过期时间。RabbitMQ可以对消息和队列设置TTL。 设置消息的TTL 目前有两种方法设置消息的TTL，第一种方法是通过队列的属性设置，队列中的所有消息都有相同的过期时间。第二种方法是对消息本身进行单独设置，每条消息的TTL可以不同。如果两种方法一起使用那么消息的TTL以两者之间较小的那个数值为准。消息在队列中的生存时间一旦超过设置的TTL值时，就会...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值