RabbitMQ (六）死信队列

已于 2023-06-21 09:17:53 修改
阅读量92 收藏
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java
于 2023-06-19 18:21:28 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42078689/article/details/131292865
版权

6.1 死信的概念

先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说: 用户在商城下单成功并点击去支付后在指定时间未支付时自动失效

6.2 死信的来源

消息 TTL 过期 队列达到最大长度(队列满了，无法再添加数据到 mq 中) 消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

6.3 死信实战

6.3.1 代码架构图

6.3.2 消息TTL 过期

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

/**
 * 死信队列 之 生产者代码
 */
public class Producer {
    //普通交换机的名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //死信消息 设置TTL时间 单位是ms 10000ms = 10s
        // time to live
        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());
        }
    }
}

/**
 * 死信队列实战
 *
 * 消费者 01
 */
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 {
        Channel channel = RabbitMqUtils.getChannel();
        //声明死信和普通交换机类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明普通队列
        Map<String, Object> arguements = new HashMap<>();
        //过期时间 10s=10000ms
        //arguements.put("x-message-ttl", 100000);
        //正常队列设置死信交换机
        arguements.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信队列RoutingKey
        arguements.put("x-dead-letter-routing-key", "lisi");
        channel.queueDeclare(NORMAL_QUEUE,false, false, false, arguements);
        //声明死信队列
        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) ->{
            System.out.println("Consumer01接收的消息是：" + new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, consumerTag -> {});
    }
}

生产者未发送消息

生产者发送了10条消息 此时正常消息队列有10条未消费信息

10秒过去了 正常队列里面的消息由于没有被消费 消息进入死信队列

消费者代码C2 启动C2消费者，它消费死信队列里面的消息

/**
 * 死信队列实战
 *
 * 消费者 02
 */
public class Consumer02 {
    public static final String DEAD_EXCHANGE = "dead_exchange";
    public static final String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        //声明死信和普通交换机类型为direct
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.queueDeclare(DEAD_QUEUE,false, false, false,null);
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, "lisi");
        System.out.println("等待接收死信队列消息......");
        DeliverCallback deliverCallback = (consumerTag, message) ->{
            System.out.println("Consumer02接收的消息是：" + new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
    }
}

 

6.3.3 队列达到最大长度

  1. 消息生产者代码去掉 TTL 属性
/**
 * 死信队列 之 生产者代码
 */
public class Producer {
    //普通交换机的名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = RabbitMqUtils.getChannel();
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
//        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", null, message.getBytes());
        }
    }
}

2. C1 消费者修改以下代码(启动之后关闭该消费者 模拟其接收不到消息)

/**
 * 死信队列实战
 *
 * 消费者 01
 */
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 {
        Channel channel = RabbitMqUtils.getChannel();
        //声明死信和普通交换机类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明普通队列
        Map<String, Object> arguements = new HashMap<>();
        //过期时间 10s=10000ms
        //arguements.put("x-message-ttl", 100000);
        //正常队列设置死信交换机
        arguements.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信队列RoutingKey
        arguements.put("x-dead-letter-routing-key", "lisi");
        //设置正常队列长度的限制
        arguements.put("x-max-length", 6);
        channel.queueDeclare(NORMAL_QUEUE,false, false, false, arguements);
        //声明死信队列
        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) ->{
            System.out.println("Consumer01接收的消息是：" + new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, consumerTag -> {});
    }
}

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

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

 

6.3.4 消息被拒

  1. 消息生产者代码同上生产者一致
  2. C1消费者代码（启动之后关闭 模拟接收不到消息）
/**
 * 死信队列实战
 * <p>
 * 消费者 01
 */
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 {
        Channel channel = RabbitMqUtils.getChannel();
        //声明死信和普通交换机类型为direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明普通队列
        Map<String, Object> arguements = new HashMap<>();
        //过期时间 10s=10000ms
        //arguements.put("x-message-ttl", 100000);
        //正常队列设置死信交换机
        arguements.put("x-dead-letter-exchange", DEAD_EXCHANGE);
        //设置死信队列RoutingKey
        arguements.put("x-dead-letter-routing-key", "lisi");
        //设置正常队列长度的限制
//        arguements.put("x-max-length", 6);
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, arguements);
        //声明死信队列
        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 + "：此消息是被C1拒绝的");
                channel.basicReject(message.getEnvelope().getDeliveryTag(), false);
            } else {
                System.out.println("Consumer01接收的消息是：" + msg);
                channel.basicAck(message.getEnvelope().getDeliveryTag(), false);
            }
        };
        //开启手动应答
        channel.basicConsume(NORMAL_QUEUE, false, deliverCallback, consumerTag -> {
        });
    }
}

生产者发送消息后

3. C2 消费者代码不变
      启动消费者 1 然后再启动消费者 2

 生产者1接收到9个有一个拒绝了， 生产者2从死信队列中接收到一个消息

weixin_42078689
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合rabbitmq使用死信队列
11-06
在这个场景中，我们将重点讨论如何在Spring Boot中整合RabbitMQ，并利用死信队列（Dead-Letter Queue，DLQ）来处理异常消息。 首先，我们需要在Spring Boot项目中引入RabbitMQ的相关依赖。在`pom.xml`文件中，添加...
Spring RabbitMQ死信机制原理实例详解
08-24
在 Spring RabbitMQ 中，可以通过配置死信队列和死信交换机来实现死信机制。例如： ```java @Bean public Queue deadQueue() { return new Queue(DEAD_QUEUE_NAME, true); } @Bean public DirectExchange ...
RabbitMQ：死信队列
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-12 8499
队列中不能被消费的消息称为死信队列有时候因为特殊原因，可能导致队列中的某些信息无法被消费，而队列中这些不能被消费的消息在后期没有进行处理，就会变成死信队列，死信队列中的消息称为死信。应用场景:未来保证订单业务的消息数据不丢失，我们需要使用到RabbitMQ的死信队列机制，当消息消费发生异常的时候，我们就把消息投入到死信队列中，比如说用户买东西，下单成功后去支付，但是没有在指定时间支付的时候就会自动失效。死信队列，英文缩写：DLX。
RabbitMQ创建死信队列
一个头发贼多的小火鸡
05-27 944
RabbitMQ创建死信队列示例
rabbitMQ引入死信队列
2301_78149288的博客
01-06 1318
指的是，从队列当中取出来的消息，到达消费方后，因为某些原因导致消息并没有被正常消费掉，这些没有被后续处理的消息就是“死信”，而保存死信的队列，就是死信队列。
RabbitMQ的死信队列
一江溪水
11-13 6815
什么是死信 在 RabbitMQ 中充当主角的就是消息，在不同场景下，消息会有不同地表现。 死信就是消息在特定场景下的一种表现形式，这些场景包括： 消息被拒绝访问，即 RabbitMQ返回 nack 的信号时 消息的 TTL 过期时 消息队列达到最大长度 消息不能入队时。 上述场景经常产生死信，即消息在这些场景中时，被称为死信。 什么是死信队列 死信队列就是用于储存死信的消息队列，在死信队列中，有且只有死信构成，不会存在其余类型的消息。 死信队列在 RabbitMQ 中并不会单独存在，往往死信队列都会绑
RabbitMQ的死信队列和延迟队列
刘皇叔说Java的博客
02-23 1509
一般用在较为重要的业务队列中，确保未被正确消费的消息不被丢弃，一般发生消费异常可能原因主要有由于消息信息本身存在错误导致处理异常，处理过程中参数校验异常，或者因网络波动导致的查询异常等等，当发生异常时，当然不能每次通过日志来获取原消息，然后让运维帮忙重新投递消息。先把订单消息设置好 15 分钟过期时间，然后过期后队列将消息转发给我们设置好的 DLX-Exchange，DLX-Exchange 再将分发给它绑定的队列，我们的消费者再消费这个队列中的消息，就做到了延时十五分钟消费。
RabbitMQ 之 死信队列
weixin_73616913的博客
05-27 964
但是发生了上面所说的三种情况中的一种，成为了死信，然后被转换到死信交换机中，这个死信交换机也是 direct 类型，它们之间的 routingKey 是 "lisi",然后就进入了死信队列，死信队列由 C2 消费。生产者正常情况下走的是普通的交换机，这个交换机的类型是 direct ，它和普通队列之间的关系是一个叫 "zhangsan" 的路由 key， 正常情况下会被 C1 消费。应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。，字面意思可以这样理。
rabbitmq的死信队列
qq_63431773的博客
08-17 1012
producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。
RabbitMQ的死信队列机制
qq_39794062的博客
06-24 717
一、死信队列 死信指的是无法被消费的消息，由于消息TTL过期、队列达到最大长度、消息被拒绝等原因，导致队列中一些消息无法被消费，这样的消息如果没有进行后续的处理，就会变成死信。为了保证消息数据不丢失，需要使用死信队列机制。 二、死信队列的实现 1、消息 TTL 过期 普通队列消费者Consumer01 public class Consumer01 { //不同交换机 public static final String NORMAL_EXCHANGE = "normal_exchang
RabbitMQ实现死信队列
lianaozhe的博客
02-27 1575
死信队列其实并没有什么神秘的地方，不过是绑定在死信交换机上的普通队列，而死信交换机也只是一个普通的交换机，不过是用来专门处理死信的交换机。业务消息被投入业务队列消费者消费业务队列的消息，由于处理过程中发生异常，于是进行了nck或者reject操作被nck或reject的消息由RabbitMQ投递到死信交换机中死信交换机将消息投入相应的死信队列死信队列的消费者消费死信消息本篇文章到此结束！希望对您有所帮助。
RabbitMQ-死信队列
weixin_43956692的博客
02-11 417
学习笔记
RabbitMQ死信队列应用1
08-03
RabbitMQ死信队列（Dead Letter Exchange, DLX）是一种高级特性，用于处理那些无法正常处理或过期的消息。当消息在业务队列中处理失败，如因异常导致重试次数达到上限，就会变为死信。DLX允许将这些死信重新发布到另...
rabbitMQ 死信队列 完整例子
03-19
**RabbitMQ死信队列完整实例解析** 在分布式系统中，消息队列扮演着重要的角色，它能够帮助处理高并发、异步任务以及解耦系统组件。RabbitMQ作为一款广泛使用的开源消息代理和队列服务器，其提供的死信队列（Dead ...
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程
06-28
springboot整合RabbitMQ实现死信/死信队列及实现源码及教程，参考博客：https://blog.csdn.net/qq_29914837/article/details/93334313
Java版Flink使用指南——将消息写入到RabbitMQ的队列中
方亮的专栏
07-08 548
在一文中，我们介绍了如何使用Java在Flink中读取RabbitMQ中的数据，并将其写入日志中。本文将通过代码产生一些数据，然后将它们写入到另外一个RabbitMQ队列中。
RabbitMQ 迁移
Dablelv 的博客专栏。
07-08 597
如果您只需要导出和导入RabbitMQ的定义（如vhost、exchange、queue等），可以使用RabbitMQ的 HTTP API。
RABBITMQ的本地测试证书生成脚本
applebomb的专栏
07-11 311
由于小程序要求必须访问wss的接口，因此需要将测试环境也切换到https，需要一堆证书。写了个脚本用来自动处理这个事情
Elsaticsearch java基本操作
最新发布
qq_62383709的博客
07-13 441
索引 基本操作 package com.orchids.elasticsearch.web.controller; import cn.hutool.core.collection.CollUtil; import cn.hutool.json.JSONUtil; import com.orchids.elasticsearch.web.po.User; import io.swagger.annotations.Api; import io.swagger.annotations.ApiOperatio

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值