RabbitMQ学习记录 - 死信队列（死信交换机）

其他 2021-11-21 13:13:09 阅读次数: 0

（内容均来自RabbitMQ官网：https://www.rabbitmq.com/dlx.html）

前面几篇学习了RabbitMQ的几种消息模型"HelloWorl"、"WorkQueue"、"Publish/Subscribe"、"Routing"、"Topic"，以及RabbitMQ中几个基本的组件：生产者、路由器、队列、消费者。

这篇学习下死信交换机，我觉得这么叫比较合理，因为RabbitMQ的官网也是这么叫的，名字也叫：Dead Letter Exchanges，简称：DLX。并不是网上大很多人说的死信队列。

什么情况下死信会投递到死信交换机去呢？

  1. 消息被消费者拒收了（消费者调用basic.reject或者basic.nack还有就是把requeue 的参数设置成false）
  2. 设置消息的TTL(x-message-ttl)
  3. 消息的数量超出了队列的最大长度限制(x-max-length)

情况一：消息被消费者拒收的情况产生死信

生产者代码

        我们第一步准备演示情况1产生死信，消息的生产者这里做的事情主要是有：

  1. 创建普通交换机和普通队列
  2. 创建死信交换机和死信队列
  3. 在普通队列创建的时候携带参数（x-dead-letter-exchange：用于指定死信交换机的名称，x-dead-letter-routing-key：指定死信交换的routingKey、x-message-ttl指定消息过期时间、x-max-length队列最大消息容量等等）
  4. 发送消息
import com.booyue.tlh.utils.RabbitMQUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class DeadQueueProduce {

    //普通交换机名称、队列名称、routingKey
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String NORMAL_ROUTINGKEY = "normal_routing_key";

    //死信交换机名称、队列名称、routingKey
    public static final String DEAD_EXCHANGE = "dead_exchange";
    public static final String DEAD_QUEUE = "dead_queue";
    public static final String DEAD_ROUTINGKEY = "dead_routing_key";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        //声明普通交换机交换机、死信交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT, true);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        /**
         * 声明普通交换机时候需要的参数
         *  参数内容：可以指定死信交换机的名称、死信交换机的routingKey、队列的最大长度、队列中的消息过期时间等等
         */
        Map<String, Object> argsMap = new HashMap<>();
        //绑定死信队列名称
        argsMap.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //指定死信队列routingKey
        argsMap.put("x-dead-letter-routing-key", DEAD_ROUTINGKEY);
        //指定消息的过期时间为10000毫秒（10秒）
        //argsMap.put("x-message-ttl", 10000);
        //指定普通队列的最大长度
        // argsMap.put("x-max-length", 10);
        /**
         * 声明两个队列：普通交队列和死信队列
         */
        channel.queueDeclare(NORMAL_QUEUE, true, false, false, argsMap);
        channel.queueDeclare(DEAD_QUEUE, true, false, false, null);
        /**
         * 将普通队列和普通交换机绑定、死信队列和死信交换机绑定
         */
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, NORMAL_ROUTINGKEY);
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, DEAD_ROUTINGKEY);

        /**
         * 发送消息
         */
        for (int i = 0; i < 10; i++) {
            String message = "info :" + i;
            channel.basicPublish(NORMAL_EXCHANGE, NORMAL_ROUTINGKEY, null, message.getBytes());
        }
    }
}

将生产者运行起来，我们在RabbitMQ的服务器上就能看到我们创建的普通交换机、普通队列（和死信交换机的绑定关系）、死信队列、死信交换机等等。

普通队列【途中看到的DLX和DLK用鼠标放上去，就能显示它绑定死信交换机和死信队列的routtingKey】和死信队列

普通交换机和死信交换机

普通消费者代码

        这里需要改成手动确认的方式：autoAck=false，当消息是info :5的时候我们就拒收，让其进入到死信堆里中去，采用basicReject的方式拒收消息。其余与的消息就正常消费掉

import com.booyue.tlh.utils.RabbitMQUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DeliverCallback;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

@Slf4j
public class NormalConsumer {

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

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

    public static final String NORMAL_ROUTINGKEY = "normal_routing_key";
    public static final String DEAD_ROUTINGKEY = "dead_routing_key";

    public static void main(String[] args) throws IOException {
        //获取连接
        Connection connection = RabbitMQUtils.getConnection();
        //获取通道
        Channel channel = connection.createChannel();
        /**
         * 接受消息（当消息是info :5的时候我们就拒收，让其进入到死信堆里中去）
         *  这里需要改成手动确认的方式：autoAck=false
         *  采用basicReject的方式拒收消息
         */
        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String ss = new String(message.getBody());
            if (ss.equals("info :5")) {
                //拒绝消息，不放回队列（该条消息就会到死信队列中）
                log.info("=====普通消费者拒收的信息：{}", ss);
                channel.basicReject(message.getEnvelope().getDeliveryTag(), false);
            } else {
                log.info("普通消费者收到的信息：{}", ss);
                //手动确认消息,不批量应答
                channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
            }
        };
        //修改成手动确认
        channel.basicConsume(NORMAL_QUEUE, false, deliverCallback, consumerTag -> {
        });
    }
}

把普通生产者和和普通消费者跑起来，看信息打印和RabbitMQ后台数据

        看到信息打印，确实info：5的是消息被拒收了

20:43:33.971 [pool-1-thread-4] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :0
20:43:33.975 [pool-1-thread-4] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :1
20:43:33.975 [pool-1-thread-4] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :2
20:43:33.975 [pool-1-thread-4] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :3
20:43:33.975 [pool-1-thread-4] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :4
20:43:33.976 [pool-1-thread-5] INFO com.booyue.tlh.dead.NormalConsumer - =====普通消费者拒收的信息：info :5
20:43:33.976 [pool-1-thread-5] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :6
20:43:33.976 [pool-1-thread-5] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :7
20:43:33.976 [pool-1-thread-5] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :8
20:43:33.976 [pool-1-thread-5] INFO com.booyue.tlh.dead.NormalConsumer - 普通消费者收到的信息：info :9

RabbitMQ的服务器后台数据

        在死信队列中确实都了一条数据，也确实是info：5

死信消息的消费者代码

import com.booyue.tlh.utils.RabbitMQUtils;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DeliverCallback;
import lombok.extern.slf4j.Slf4j;

import java.io.IOException;

@Slf4j
public class DeadConsumer {

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

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

    public static final String NORMAL_ROUTINGKEY = "normal_routing_key";
    public static final String DEAD_ROUTINGKEY = "dead_routing_key";

    public static void main(String[] args) throws IOException {

        Connection connection = RabbitMQUtils.getConnection();
        Channel channel = connection.createChannel();
        //接受消息
        DeliverCallback deliverCallback = (consumerTag, message) -> log.info("死信消费者受到的消息：{}",new String(message.getBody()));
        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {
        });
    }
}

死信消息的消费者获取到的信息打印

20:51:42.065 [pool-1-thread-4] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :5

情况二：设置消息的TTL(x-message-ttl)

        在普通队列创建的时候，设置x-message-ttl，普通的消费者这次就不运行起来，模拟消息超时的情况。

生产者代码

         与第一种情况的差异就是把argsMap.put("x-message-ttl", 10000);注释打开了。默认超时时长为10000毫秒（10秒）

import com.booyue.tlh.utils.RabbitMQUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class DeadQueueProduce {

    //普通交换机名称、队列名称、routingKey
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String NORMAL_ROUTINGKEY = "normal_routing_key";

    //死信交换机名称、队列名称、routingKey
    public static final String DEAD_EXCHANGE = "dead_exchange";
    public static final String DEAD_QUEUE = "dead_queue";
    public static final String DEAD_ROUTINGKEY = "dead_routing_key";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        //声明普通交换机交换机、死信交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT, true);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        /**
         * 声明普通交换机时候需要的参数
         *  参数内容：可以指定死信交换机的名称、死信交换机的routingKey、队列的最大长度、队列中的消息过期时间等等
         */
        Map<String, Object> argsMap = new HashMap<>();
        //绑定死信队列名称
        argsMap.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //指定死信队列routingKey
        argsMap.put("x-dead-letter-routing-key", DEAD_ROUTINGKEY);
        //指定消息的过期时间为10000毫秒（10秒）
        argsMap.put("x-message-ttl", 10000);
        //指定普通队列的最大长度
        // argsMap.put("x-max-length", 10);
        /**
         * 声明两个队列：普通交队列和死信队列
         */
        channel.queueDeclare(NORMAL_QUEUE, true, false, false, argsMap);
        channel.queueDeclare(DEAD_QUEUE, true, false, false, null);
        /**
         * 将普通队列和普通交换机绑定、死信队列和死信交换机绑定
         */
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, NORMAL_ROUTINGKEY);
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, DEAD_ROUTINGKEY);

        /**
         * 发送消息
         */
        for (int i = 0; i < 10; i++) {
            String message = "info :" + i;
            channel.basicPublish(NORMAL_EXCHANGE, NORMAL_ROUTINGKEY, null, message.getBytes());
        }
    }
}

死信消费者代码

       （和第一种情况时候的代码一样）

运行生产者和死信消费者，我们在RabbitMQ服务器后台能看到在普通队列里有10条消息积压

等待我们设置的超时时长，我们就能按到给条信息超时之后都会被死信消费者消费

21:01:20.530 [pool-1-thread-4] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :0
21:01:20.533 [pool-1-thread-4] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :1
21:01:20.533 [pool-1-thread-4] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :2
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :3
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :4
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :5
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :6
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :7
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :8
21:01:20.533 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :9

情况二：消息的数量超出了队列的最大长度限制(x-max-length)

        在普通队列创建的时候，设置x-max-length（我们这里指定5），普通的消费者这次就不运行起来，让普通队列中的消息数量超过我呢设置的最大值5。与第一种情况的差异就是把argsMap.put("x-max-length", 5);注释打开了。默认队列的容量为5

生产者代码

import com.booyue.tlh.utils.RabbitMQUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;

import java.io.IOException;
import java.util.HashMap;
import java.util.Map;

public class DeadQueueProduce {

    //普通交换机名称、队列名称、routingKey
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String NORMAL_ROUTINGKEY = "normal_routing_key";

    //死信交换机名称、队列名称、routingKey
    public static final String DEAD_EXCHANGE = "dead_exchange";
    public static final String DEAD_QUEUE = "dead_queue";
    public static final String DEAD_ROUTINGKEY = "dead_routing_key";

    public static void main(String[] args) throws IOException {
        Channel channel = RabbitMQUtils.getConnection().createChannel();
        //声明普通交换机交换机、死信交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT, true);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT, true);

        /**
         * 声明普通交换机时候需要的参数
         *  参数内容：可以指定死信交换机的名称、死信交换机的routingKey、队列的最大长度、队列中的消息过期时间等等
         */
        Map<String, Object> argsMap = new HashMap<>();
        //绑定死信队列名称
        argsMap.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //指定死信队列routingKey
        argsMap.put("x-dead-letter-routing-key", DEAD_ROUTINGKEY);
        //指定消息的过期时间为10000毫秒（10秒）
        //argsMap.put("x-message-ttl", 10000);
        //指定普通队列的最大长度
         argsMap.put("x-max-length", 5);
        /**
         * 声明两个队列：普通交队列和死信队列
         */
        channel.queueDeclare(NORMAL_QUEUE, true, false, false, argsMap);
        channel.queueDeclare(DEAD_QUEUE, true, false, false, null);
        /**
         * 将普通队列和普通交换机绑定、死信队列和死信交换机绑定
         */
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, NORMAL_ROUTINGKEY);
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, DEAD_ROUTINGKEY);

        /**
         * 发送消息
         */
        for (int i = 0; i < 10; i++) {
            String message = "info :" + i;
            channel.basicPublish(NORMAL_EXCHANGE, NORMAL_ROUTINGKEY, null, message.getBytes());
        }
    }
}

死信消费者代码

       （和第一种情、第二中情况时候的代码一样）

运行生产者代码我们就能发现有五条消息在普通队列，另外5条在死信队列中（为了看效果我们先不运行死信队列，不然消息瞬间就被消费了）

运行死信消费者，看打印信息

        只会消费死信队列里的信息，不会消费普通队列里面的信息

21:13:01.804 [pool-1-thread-4] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :0
21:13:01.809 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :1
21:13:01.809 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :2
21:13:01.809 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :3
21:13:01.809 [pool-1-thread-5] INFO com.booyue.tlh.dead.DeadConsumer - 死信消费者受到的消息：info :4

猜你喜欢

转载自blog.csdn.net/qq_27062249/article/details/118576950
今日推荐
火速冲上 GitHub 热榜 —— 开源编程语言、框架哪有这么可爱？
北京人形机器人创新中心发布全球首个纯电驱拟人奔跑的全尺寸人形机器人“天工”
LFOSSA 源来如此公开课 | 掌握云原生未来：CNCF 认证全面攻略与备考秘籍
国产云输入法——仅华为无云端数据上传安全问题
开源日报 | 工业开源项目OGG 1.0；姐姐，你要和我一起配置火狐吗；苹果AI遥遥落后？Fedora 40
开放签电子签章：停止新增，优化体验，前进更进（五一假期前工作）
开源日报 | 中学生开源前端动画引擎；全球首个Llama3 8B中文版开源模型；联想电脑恐出局；Linus讽刺AI炒作
周排行
浏览器对同一域名进行请求的最大并发连接数
React Hook之自定义Hook
【转】MyBatis缓存机制
-Java-泛型
自动化测试常用脚本-发送邮件
LeetCode#859: Buddy Strings
java、Python处理字符串
第二篇の博客
Hadoop伪分布式环境安装
SQL Server进阶（十一）临时表、表变量
每日归档
更多
2024-04-27(56)
2024-04-26(39)
2024-04-25(22)
2024-04-24(36)
2024-04-23(26)
2024-04-22(39)
2024-04-21(0)
2024-04-20(6)
2024-04-19(5)
2024-04-18(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022