RabbitMQ死信

最新推荐文章于 2024-08-03 21:27:32 发布
最新推荐文章于 2024-08-03 21:27:32 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： 中间件 文章标签： rabbitmq java 分布式
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_38987390/article/details/123386111
版权

RabbitMQ死信

死信的概念

死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，生产者直接将消息投递给交换机或者队列，消费者从队列取出消息进行消费，但某些时候由于特定的原因导致队列中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

死信的来源

  • 消息 TTL 过期
  • 队列达到最大长度(队列满了，无法再添加数据到 mq 中)
  • 消息被拒绝

死信的来源举例

消息TTL过期

普通消费者，启动后关闭，模拟普通消费者接收不到消息
public class Consumer01 {

    // 普通交换机名称
    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 void main(String[] args) throws IOException, TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        // 工厂IP，连接RabbitMQ队列(安装RabbitMQ机器的IP地址)
        factory.setHost("xxx.xxx.xxx.xxx");
        //用户名
        factory.setUsername("username");
        //密码
        factory.setPassword("password");
        // 创建连接
        Connection connection = factory.newConnection();
        // 获取信道
        Channel channel = connection.createChannel();
        // 声明死信和普通交换机的类型为DIRECT
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        Map<String,Object> map = new HashMap<>();
        // 设置死信交换机
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        // 设置死信的routingkey
        map.put("x-dead-letter-routing-key","lisi");
        // 声明死信和普通队列
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, map);
        channel.queueDeclare(DEAD_QUEUE, false, false, false, null);

        // 绑定普通交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        // 绑定死信交换机与队列
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");

        System.out.println("等待接收消息。。。。");

        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String msg = new String(message.getBody(),"UTF-8");
      		System.out.println("Consumer01 接收到消息"+message);
        };

        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, consumerTag -> {
        });
    }
}
死信消费者
	public class Consumer02 {
    //死信队列的名称
    public static final String DEAD_QUEUE = "dead_queue";
    public static void main(String[] args) throws IOException, TimeoutException {
        ==========上述的方式获取信道=============
        System.out.println("Consumer02等待接收消息。。。。");


        DeliverCallback deliverCallback = (consumerTag, message) -> {
            System.out.println("Consumer02接收到消息：" + new String(message.getBody(), "UTF-8") + "绑定键："
                    + message.getEnvelope().getRoutingKey());
        };

        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {
        });


    }
}
生产者
public class Producer {
    // 普通交换机名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
       ==========上述的方式获取信道===========
        // 发送延迟消息，设置TTL 单位是毫秒
        AMQP.BasicProperties properties =
                new AMQP.BasicProperties().builder().expiration("10000").build();
        for (int i = 0; i < 10; i++) {
            String message = "info" + i;
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());
        }
    }
}
结果

当消费者01停止后，由于发送者发送的消息过期时间到了，所以发送的十条消息发送到死信队列，正常队列中的未确认数变为0
在这里插入图片描述
在这里插入图片描述
启动消费者02后收到消息
在这里插入图片描述

队列达到最大长度

生产者01

与上述相比，增加了最大队列长度属性map.put("x-max-length",6);,切记，如果要改变队列和交换机的属性，需要在管理端删除这个队列或者交换机，再重新创建，否则会报错，无法创建，同上面一样，启动后停止运行正常队列，模拟队列无法接受消息

public class Consumer01 {

    // 普通交换机名称
    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 void main(String[] args) throws IOException, TimeoutException {
        =============同初始一样获取信道===========
        // 声明死信和普通交换机的类型为DIRECT
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        Map<String,Object> map = new HashMap<>();
    
        // 设置死信交换机
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        // 设置死信的routingkey
        map.put("x-dead-letter-routing-key","lisi");
        // 设置正常队列的长度
        map.put("x-max-length",6);
        // 声明死信和普通队列
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, map);
        channel.queueDeclare(DEAD_QUEUE, false, false, false, null);


        // 绑定普通交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        // 绑定死信交换机与队列
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");

        System.out.println("等待接收消息。。。。");


        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String msg = new String(message.getBody(),"UTF-8");
           
        };
        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, consumerTag -> {
        });
    }
}
其余两个和上述一样，生产者移除掉配置过期时间
结果如下

正常队列只能保存六个未处理的消息，其余消息加入到死信队列
在这里插入图片描述

消息被拒绝

消息生产者

与上述的最大长度的生产者相同，移除掉过期时间的配置

正常消费者

正常消费者移除掉设置队列最大长度，同时设置手动确认，当消息体为info05时，拒绝接收该消息

public class Consumer01 {

    // 普通交换机名称
    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 void main(String[] args) throws IOException, TimeoutException {
        ===========与初始获取信道的方式相同===========
        // 声明死信和普通交换机的类型为DIRECT
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);

        Map<String,Object> map = new HashMap<>();
        // 设置死信交换机
        map.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        // 设置死信的routingkey
        map.put("x-dead-letter-routing-key","lisi");
        // 声明死信和普通队列
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, map);
        channel.queueDeclare(DEAD_QUEUE, false, false, false, null);


        // 绑定普通交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        // 绑定死信交换机与队列
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");

        System.out.println("等待接收消息。。。。");


        DeliverCallback deliverCallback = (consumerTag, message) -> {
            String msg = new String(message.getBody(),"UTF-8");
            if(msg.equals("info5")){
                System.out.println("Consumer01接收到消息是："+msg+"但是被拒绝");
                /**
                 * 1. 消息的标识
                 * 2. 是否重新添加到队列
                 */
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else {
                System.out.println("Consumer01接收到消息：" + new String(message.getBody(), "UTF-8") + "绑定键："
                        + message.getEnvelope().getRoutingKey());
                /**
                 * 1. 消息的标签
                 * 2. 是否批量应答
                 */
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }

        };
        // 设为不自动应答，手动应答
        channel.basicConsume(NORMAL_QUEUE, false, deliverCallback, consumerTag -> {
        });


    }
}
死信消费者
  • 与上述相同，死信消费者不变
结果

在这里插入图片描述
在这里插入图片描述

总结

以上就是死信的三种产生方式，当因为各种情况导致上述的三种情景发生时，我们可以使用死信队列来接收消息从而分析为什么会产生死信

aiYouWei啊
关注
专栏目录
使用RabbitMQ死信实现延迟消息
05-24
spring boot 配置， Rabbitmq集成, 利用死信 实现延时消息队列实现
【RabbitMQ】——死信
qq_42000631的博客
08-17 769
rabbitmq 死信
Rabbitmq中的死信队列
最新发布
你我约定有三的博客
08-03 1041
消息投递到MQ中存放 消息已经过期 消费者没有及时的获取到我们消息，消息如果存放到mq服务器中过期之后，会转移到备胎死信队列存放。2.如果生产者投递消息到普通队列中，普通队列发现该消息一直没有被消费者消费。的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机。的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机。普通队列中缓存起来，普通队列对应有自己独立普通消费者。普通队列中缓存起来，普通队列对应有自己独立普通消费者。死信队列和普通队列区别不是很大。
RabbitMQ 之 死信队列
weixin_73616913的博客
05-27 2803
但是发生了上面所说的三种情况中的一种，成为了死信，然后被转换到死信交换机中，这个死信交换机也是 direct 类型，它们之间的 routingKey 是 "lisi",然后就进入了死信队列，死信队列由 C2 消费。生产者正常情况下走的是普通的交换机，这个交换机的类型是 direct ，它和普通队列之间的关系是一个叫 "zhangsan" 的路由 key， 正常情况下会被 C1 消费。应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。，字面意思可以这样理。
rabbitmq死信
jingzhi_f
03-15 983
rabbitmq中的消息当遇到以下几种情况，会变成死信： 消息被拒绝(basic.reject / basic.nack)，并且requeue = false 消息TTL过期 队列达到最大长度 当一个队列中的消息变成死信，可以通过x-dead-letter-exchange配置一个交换器，让这些消息到另一个队列上处理 //正常队列配置 String myExchangeName = "...
RabbitMQ之死信队列
JAVA开发区的博客
07-20 949
死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取消息进行消费，但某些时候由于特定的。：为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列中。，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。时间过去10秒，正常队列里面的消息由于没有被消费，消息进入死信队列。消息生产者代码同上生产者一致。
Spring RabbitMQ死信机制原理实例详解
08-24
Spring RabbitMQ 死信机制原理实例详解 Spring RabbitMQ 死信机制是指在消息队列中，消息没有被及时消费的机制。这种机制可以提高系统的稳定性，当消息消费失败后，消息进入死信队列，可以对消息进行补偿，达到...
rabbitMQ 死信队列 完整例子
03-19
**RabbitMQ死信队列完整实例解析** 在分布式系统中，消息队列扮演着重要的角色，它能够帮助处理高并发、异步任务以及解耦系统组件。RabbitMQ作为一款广泛使用的开源消息代理和队列服务器，其提供的死信队列（Dead ...
RabbitMQ死信队列
weixin_59074080的博客
05-14 9201
DLX，全称为Dead-Letter-Exchange , 可以称之为死信交换机，也有人称之为死信邮箱。当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就称之为死信队列。消息被拒绝消息过期队列达到最大长度DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何的队列上被指定，实际上就是设置某一个队列的属性。
RabbitMq死信队列概述与使用
m0_57781768的博客
11-15 171
死信是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。应用场景：为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。
rabbitmq死信队列详解与使用
热门推荐
congge
08-28 14万+
什么是死信队列 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列； 以上是个人的通俗解释，专业术语解释的比...
RabbitMQ 死信队列详解
dingd1234的博客
05-28 1万+
一、死信的概念 死信，顾名思义就是无法被消费的消息。一般来说，Producer 将消息投递到 Broker 或者直接到 Queue 里了，Consumer 从 Queue 取出消息进行消费，但某些时候由于特定的原因导致 Queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景：为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，档消息消费发生异常时，将消息投入到死信队列中。还有比如说：用户在商城下单成功并点击支付后再指定
RabbitMQ的死信队列
yygr的博客
07-01 171
当消息被标记为死信后，如果配置了死信队列，RabbitMQ会将该消息发送到死信交换机（Dead Letter Exchange）。可以将其从当前队列发送到另一个队列中，这个队列就是死信队列。可以观察得到，执行测试代码两秒后消费者拒签消息，三秒后查看队列，也查看不了，总共没有超过队列的存活时间，而且也没有超过队列长度，但依旧看不到，证明消费者拒签后也会变成死信队列。普通交换机和普通队列，然后在创建普通队列时让其绑定死信交换机，并且设置队列的存活时间为15s，以及最大长度为10。
RabbitMq死信队列（六）
weixin_41987908的博客
02-13 560
    当队列中的消息过期，或者达到最大长度而被删除，或者达到最大空间时而被删除时，可以将这些被删除的信息推送到其他交换机中，让其他消费者订阅这些被删除的消息，处理这些消息。     准备要素：一个生产者 一个正常消费者（带一个正常交换机，一个路由键，一个正常队列） 一个处理过期消息的消费者（带一个死亡交换机，死亡路...
RabbitMQ深入 —— 死信队列
荔枝当大佬的博客
09-18 3760
前面荔枝梳理了RabbitMQ中的普通队列、交换机以及相关的知识，在这篇文章中荔枝将会梳理RabbitMQ的一个重要的队列 —— 死信队列，主要了解消息流转到死信队列的三种的方式以及相应的实现demo。希望能帮助到有需要的小伙伴~~~
RabbitMQ中的死信及死信队列详解
最爱嫣夜来
03-06 6940
1、什么是死信 死信产生主要来自于两个过程角色 来自于消费者端 来自于queue 产生死信的三种情况： 如果queue中的消息被消费者接收， 但是消费者拒绝消费（消费者执行了reject 或nack 并将 requee 参数设置为 false ）的时候，这个消息就会变成死信。 消息本身设置了过期时间(TTL), 并且消息过期时间已经生效， 还未被消费的消息就会变成死信【特点是每个消息的过期时间都不同】 可以设置队列中所有消息的过期时间，如果消息过期时间已经生效，消息还未被消费 队列设置了最大长度限制，
rabbitMQ死信
liang只的博客
06-25 234
死信流程图 死信信息处理步骤 一、声明死信交换器。 二、声明普通队列中消费失败的信息入死信交换器。 （目的：消费者消费失败的消息不重入队列，交给死信交换器） 此处需要设置两个点：1、消费者消费消息失败，设置不重入队列。 2、设置普通队列的属性，将消费失败不重入队列的消息，交由死信交换器处理。 三、声明专门存放死信消息的队列。 四、死信交换器和死信消息存储队列绑定。 只有绑定后，其他队列中那些失败的没有重入队列的消息，才会经死信交换器放入死信存储队列中 五、配.
rabbitMQ 系列 之 死信
QismyQ的专栏
11-13 299
rabbitMQ 系列 之 死信概念示意图延迟队列实例 概念 ​ 先说下什么是死信。这里边包含几个概念： 死信交换器：Dead-Letter-Exchange，简称DLX。作用是干嘛的呢，当一条消息在普通队列中变为死信后，这条消息就能被重新发送到另一个交换器中，这个交换器就是死信交换器。 死信队列：和死信交换器绑定的队列就是死信队列。当死信被重新发送到DLX后，被路由到此队列。 死信：简而言之，可以概括为被丢弃的消息，就是死信。 消息变为死信的几种情况： 消息被拒绝（Basic.Reje
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值