六、死信队列

悬浮海

已于 2022-03-21 19:58:00 修改

阅读量4.1k

点赞数 1

分类专栏： # RabbitMQ 文章标签： rabbitmq 死信队列

于 2022-03-19 10:43:01 首次发布

本文链接：https://blog.csdn.net/wang_luwei/article/details/123590393

版权

RabbitMQ 专栏收录该内容

12 篇文章 9 订阅

订阅专栏

本文详细讲解了如何在RabbitMQ中实现死信队列，包括死信概念、常见来源（如消息TTL过期、队列长度限制和消息被拒），并通过代码实例展示了如何配置交换机、队列和消费者来处理死信消息，确保业务数据完整性。

摘要由CSDN通过智能技术生成

RabbitMQ目录

文章目录

死信队列

死信队列

1、死信的概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

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

2、死信的来源

消息 TTL（存活时间）过期
队列达到最大长度(队列满了，无法再添加数据到队列中)
消息被拒绝（消费方拒绝应答：basic.reject 或 basic.nack）并且（不放回队列中： requeue=false）

3、死信实战

3.1. 代码架构图

描述：一个生产者，两个消费者，有一个正常的交换机，类型为direct，路由模式。一个消息正常发给消费者C1，结果出现了上面描述的三种情况：消息 TTL 过期、队列达到最大长度、消息被拒绝，消息成为死信，之后消息被转发到（死信交换机）ded_exchange，类型也为direct，之后进入死信队列，最终由消费者C2消费。

代码核心部分在C1。

3.2. 消息TTL 过期

先启动C1，让其创建正常交换机、死信交换机、正常队列、死信队列，以及之间的绑定关系，之后关闭C1，生产者发送消息，这是模拟“消息TTL 过期”。之后启动C2去消息死信队列中的消息。

消费者 C1 代码 (启动之后关闭该消费者模拟其接收不到消息)

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 死信队列 消费者C1
 */
public class Consumer01 {

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

    public static void main(String[] argv) 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);
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        //正常队列 将消息转发给死信队列 所需参数
        Map<String, Object> params = new HashMap<>();
        //正常队列 设置 死信交换机，参数 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("Consumer01等待接收消息........... ");
        //成功接收消息的回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer01 接收到消息"+message);
        };
        //接收消息
        channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {});
    }
}

生产者代码：

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

/**
 * 死信队列 生产者
 */
public class Producer {

    //正常交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";

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

        //声明正常交换机和死信交换机 类型为 direct
        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;
            //正常交换机名称、正常交换机于正常队列之间的routingKey、配置参数、消息
            channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", properties, message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }

    }
}

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

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

/**
 * 死信队列 消费者C2 - 消费死信消息
 */
public class Consumer02 {

    //死信队列的名称 - 和C1中保持一致
    private static final String DEAD_QUEUE = "dead-queue";

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

        System.out.println("Consumer02等待接收死信队列消息........... ");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer02 接收死信队列的消息" + message);
        };
        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
    }
}

3.3. 队列达到最大长度

在测试时，还是需要关闭C1，这样消息才会积压，正常队列才会满。

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

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

/**
 * 死信队列 生产者
 */
public class Producer {

    //正常交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";

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

        //声明正常交换机和死信交换机 类型为 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);

        //该信息是用作演示队列个数限制
        for (int i = 1; i <11 ; i++) {
            String message="info"+i;
            //正常交换机名称、正常交换机于正常队列之间的routingKey、配置参数、消息
            channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", null, message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }

    }
}

2.C1 消费者修改以下代码

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

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 死信队列 消费者C1
 *
 * @auther wlw
 * @date 2022/3/13
 */
public class Consumer01 {

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

    public static void main(String[] argv) 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);
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        //正常队列 将消息转发给死信队列 所需参数
        Map<String, Object> params = new HashMap<>();
        //正常队列 设置 死信交换机，参数 key 是固定值
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //正常队列设置死信 routing-key，参数 key 是固定值
        params.put("x-dead-letter-routing-key", "lisi");
        //设置正常队列的限制
        params.put("x-max-length", 6);

        //声明正常队列,并绑定正常交换机
        String normalQueue = "normal-queue";
        channel.queueDeclare(normalQueue, false, false, false, params);
        channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");

        System.out.println("Consumer01等待接收消息........... ");
        //成功接收消息的回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer01 接收到消息"+message);
        };
        //接收消息
        channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {});
    }
}

3.C2 消费者代码不变(启动 C2 消费者)

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

/**
 * 死信队列 消费者C2 - 消费死信消息
 */
public class Consumer02 {

    //死信队列的名称 - 和C1中保持一致
    private static final String DEAD_QUEUE = "dead-queue";

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

        System.out.println("Consumer02等待接收死信队列消息........... ");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer02 接收死信队列的消息" + message);
        };
        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
    }
}

3.4. 消息被拒

1.消息生产者代码同上生产者一致

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

/**
 * 死信队列 生产者
 */
public class Producer {

    //正常交换机名称
    private static final String NORMAL_EXCHANGE = "normal_exchange";

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

        //声明正常交换机和死信交换机 类型为 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);

        for (int i = 1; i <11 ; i++) {
            String message="info"+i;
            //正常交换机名称、正常交换机于正常队列之间的routingKey、配置参数、消息
            channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", null, message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }

    }
}

2.C1 消费者代码

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

import java.util.HashMap;
import java.util.Map;

/**
 * 死信队列 消费者C1
 */
public class Consumer01 {

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

    public static void main(String[] argv) 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);
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");

        //正常队列 将消息转发给死信队列 所需参数
        Map<String, Object> params = new HashMap<>();
        //正常队列 设置 死信交换机，参数 key 是固定值
        params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //正常队列设置死信 routing-key，参数 key 是固定值
        params.put("x-dead-letter-routing-key", "lisi");
        //设置正常队列的限制
        //params.put("x-max-length", 6);

        //声明正常队列,并绑定正常交换机
        String normalQueue = "normal-queue";
        channel.queueDeclare(normalQueue, false, false, false, params);
        channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");

        System.out.println("Consumer01等待接收消息........... ");
        //成功接收消息的回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            if(message.equals("info5")){
                // "info5"为消息内容
                System.out.println("Consumer01 接收到消息" + message + "并拒绝签收该消息");
                //拒绝应答，requeue 设置为 false 代表拒绝重新入队 该队列如果配置了死信交换机将发送到死信队列中
                //并且下面接收消息也要设置为手动应答
                channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false);
            }else {
                System.out.println("Consumer01 接收到消息"+message);
                //确认应答
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };
        //接收消息
        boolean autoAck = false; //表示手动应答
        channel.basicConsume(normalQueue, autoAck, deliverCallback, consumerTag -> {});
    }
}

3.C2 消费者代码不变

package com.wlw.rabbitmq.eight;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;

/**
 * 死信队列 消费者C2 - 消费死信消息
 */
public class Consumer02 {

    //死信队列的名称 - 和C1中保持一致
    private static final String DEAD_QUEUE = "dead-queue";

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

        System.out.println("Consumer02等待接收死信队列消息........... ");
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer02 接收死信队列的消息" + message);
        };
        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
    }
}