rabbitmq死信队列详解与使用

最新推荐文章于 2024-05-27 20:23:49 发布
最新推荐文章于 2024-05-27 20:23:49 发布
阅读量630 收藏 10
点赞数

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

以上是个人的通俗解释，专业术语解释的比较正规点大家可以参考，主要想搞清楚这个概念，不同的消息中间件大概都有自身对于死信或者死信队列的处理方式，下面重点要说说rabbitmq的死信队列

对rabbitmq来说，产生死信的来源大致有如下几种：

  • 消息被拒绝（basic.reject或basic.nack）并且requeue=false.

  • 消息TTL过期

  • 队列达到最大长度（队列满了，无法再添加数据到mq中）

  • 死信的产生既然不可避免，那么就需要从实际的业务角度和场景出发，对这些死信进行后续的处理，常见的处理方式大致有下面几种，

  • 综合来看，更常用的做法是第三种，即通过死信队列，将产生的死信通过程序的配置路由到指定的死信队列，然后应用监听死信队列，对接收到的死信做后续的处理，关于这一点，也是本篇要重点讲述的，下面将用代码演示一下死信的产生及路由，即上面提到的三种方式，网上可供参考的资料比较多，但大多不全面，下面提供比较完整的demo，将各种场景的产生和过程进行列举，

640?wx_fmt=png

方式1：消息超时进入死信队列

这是一种在实际生产中应用场景比较多的一种方式，比如我们熟知的订单业务场景，当用户购买商品产生了一个订单的时候，可以设置过期时间，如果在这段时间内，消息还没有被消费，将会被路由到死信队列，专业术语来讲，即消息的TTL，TTL过期了消息将进入死信队列，下面是一段演示代码，这里包括两部分，生产者和消费者。

producer代码，此处模拟生产者产生订单，推送到队列中，消息有效时间是10S，过了10S如果没有被消费将会被路由到死信队列

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

	
        final Channel channel = RabbitUtil.getChannel();	

	
        String orderExchangeName = "order_exchange";	
        String orderQueueName = "order_queue";	
        String orderRoutingKey = "order.#";	
        Map<String, Object> arguments = new HashMap<String, Object>(16);	

	
        //死信队列配置  ----------------	
        String dlxExchangeName = "dlx.exchange";	
        String dlxQueueName = "dlx.queue";	
        String dlxRoutingKey = "#";	

	
        // 为队列设置队列交换器	
        arguments.put("x-dead-letter-exchange",dlxExchangeName);	
        // 设置队列中的消息 10s 钟后过期	
        arguments.put("x-message-ttl", 10000);	

	
        //正常的队列绑定	
        channel.exchangeDeclare(orderExchangeName, "topic", true, false, null);	
        channel.queueDeclare(orderQueueName, true, false, false, arguments);	
        channel.queueBind(orderQueueName, orderExchangeName, orderRoutingKey);	

	
        String message = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 创建订单.";	

	
        // 创建死信交换器和队列	
        channel.exchangeDeclare(dlxExchangeName, "topic", true, false, null);	
        channel.queueDeclare(dlxQueueName, true, false, false, null);	
        channel.queueBind(dlxQueueName, dlxExchangeName, orderRoutingKey);	

	
        channel.basicPublish(orderExchangeName, "order.save", MessageProperties.PERSISTENT_TEXT_PLAIN, message.getBytes());	

	
        System.err.println("消息发送完成......");	
    }

consumer代码，消费端监听的是死信队列，如果conusmer收到了消息，表明死信队列里面有消息了

public class Consumer {	

	
    //消费端监听的是死信队列，如果conusmer收到了消息，表明死信队列里面有消息了	
    private static final String QUEUE_NAME = "dlx.queue";	

	
    public static void main(String[] args) throws Exception{	
        // 创建信道	
        final Channel channel = RabbitUtil.getChannel();	

	
        System.out.println("消费者启动 ..........");	

	
        com.rabbitmq.client.Consumer consumer = new DefaultConsumer(channel){	
            @Override	
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {	
                System.err.println("死信队列接收到消息：" + new String(body));	
                System.err.println("deliveryTag:" + envelope.getDeliveryTag());	
                channel.basicAck(envelope.getDeliveryTag(), false);	
            }	
        };	

	
        channel.basicConsume(QUEUE_NAME, consumer);	
        TimeUnit.SECONDS.sleep(10000000L);	
    }	

	
}

然后我们分别运行两端的代码，这里提示一下，我们并没有提前在控制台去创建queue 和 exchange，这个在producer启动或者consumer启动的时候，如果没有创建过会自动创建以及建立queue和exchange的绑定关系，

启动producer，消息发送成功，同时可以通过控制台看到，exhange和相关的队列也帮我们创建了，要注意的是在dlx.queue中，有一个消息就绪，很明显，消息过了10S中没有任何消费者消费，就被路由到了死信队列dlx.queue中，

640?wx_fmt=png

640?wx_fmt=png

640?wx_fmt=png

启动consumer,通过控制台打印结果，可以看到，由于消费端监听的是死信队列，已经从dlx.queue中成功获取到了这条信息，

640?wx_fmt=png

2、消息被拒绝，且requeue=false

没有细致研究过这个问题的可能会有点儿懵，其实就是在consumer端，当消费者要过滤某些消息的时候，那部分被过滤掉的消息如果不设置退回，即上一篇所讲的消息重回队列的话，这些消息就变成了死信，即在下面的代码中第三个参数设置成false即可，下面来看具体的代码，

有这样一个场景，一批消息中，当消费端从header中收到了num=0的消息将会被过滤掉，并且设置如上requeue=false，下面看具体的代码，

peoducer端代码，

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

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

	
        Channel channel = RabbitUtil.getChannel();	
        String exchangeName = "test_ack_exchange";	
        String routingKey = "ack.save";	

	
        //通过在properties设置来标识消息的相关属性	
        for(int i=0;i<5;i++){	
            Map<String, Object> headers = new HashMap<String, Object>();	
            headers.put("num",i);	
            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()	
                    .deliveryMode(2)                    // 传送方式 2:持久化投递	
                    .contentEncoding("UTF-8")           // 编码方式	
                    //.expiration("10000")              // 过期时间	
                    .headers(headers)                  //自定义属性	
                    .build();	
            String message = "hello this is ack message ....."  + i;	
            System.out.println(message);	
            channel.basicPublish(exchangeName,routingKey,true,properties,message.getBytes());	
        }	

	
    }	

	

	
}

consumer端代码，

public class Consumer {	

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

	
        final Channel channel = RabbitUtil.getChannel();	
        String exchangeName = "test_ack_exchange";	
        String exchangeType="topic";	
        final String queueName = "test_ack_queue";	
        String routingKey = "ack.#";	

	
        //死信队列配置  ----------------	
        String deadExchangeName = "dead_exchange";	
        String deadQueueName = "dead_queue";	
        String deadRoutingKey = "#";	
        //死信队列配置  ----------------	

	
        //如果需要将死信消息路由	
        Map<String,Object> arguments = new HashMap<String, Object>();	
        arguments.put("x-dead-letter-exchange",deadExchangeName);	

	
        channel.exchangeDeclare(exchangeName,exchangeType,true,false,false,null);	
        channel.queueDeclare(queueName,false,false,false,arguments);	
        channel.queueBind(queueName,exchangeName,routingKey);	

	
        //死信队列绑定配置  ----------------	
        channel.exchangeDeclare(deadExchangeName,exchangeType,true,false,false,null);	
        channel.queueDeclare(deadQueueName,true,false,false,null);	
        channel.queueBind(deadQueueName,deadExchangeName,deadRoutingKey);	
        //死信队列配置  ----------------	

	
        System.out.println("consumer启动 .....");	

	
        com.rabbitmq.client.Consumer consumer = new DefaultConsumer(channel){	
            @Override	
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {	
                try{	
                    Thread.sleep(2000);	
                }catch (Exception e){	

	
                }	
                Integer num = (Integer)properties.getHeaders().get("num");	
                if(num==0){	
                    //未被ack的消息，并且requeue=false。即nack的 消息不再被退回队列而成为死信队列	
                    channel.basicNack(envelope.getDeliveryTag(),false,false);	
                    String message = new String(body, "UTF-8");	
                    System.out.println("consumer端的Nack消息是：" + message);	
                }else {	
                    channel.basicAck(envelope.getDeliveryTag(),false);	
                    String message = new String(body, "UTF-8");	
                    System.out.println("consumer端的ack消息是：" + message);	
                }	
            }	
        };	
        //消息要能重回队列，需要设置autoAck的属性为false，即在回调函数中进行手动签收	
        channel.basicConsume(queueName,false,consumer);	
    }	
}

要关注的即下面的这处代码和第三个参数，

640?wx_fmt=png

启动生产者和消费者

640?wx_fmt=png

启动生产者，生产者成功发送5条消息

640?wx_fmt=png

再看消费端的控制台，这里num=0的这条消息由于设置了死信队列而不会重回原来的队列，在上一篇中，当参数设置成了true的时候，看到控制台一直会打印一条消息，

640?wx_fmt=png

同时，通过控制台也可以发现，在dead_queue中，有一条消息为就绪状态了，即死信消息，但这里并没有对这条消息做处理，目前一直存在队列里面，可以根据实际应用做后续的处理，

640?wx_fmt=png

3、队列达到最大长度

这个很好理解，比如我们设置某个队列的最大可承载消息的数量是100个，超出第100个的消息将会被路由到死信队列中，设置消息队列的最大数量也是实际生产中作为队列限流的一种常规手段，具有实际的业务意义，下面是代码演示，基本设置和上述的TTL类似，只是在参数中将TTL更换为如下配置，

生产者代码，这里我们设定order_queue这个队列的容量是5个，但是我们在程序中设置的x-max-length=3，那么按照这个猜想，将会有两个消息被路由到死信队列

public class Producer {	

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

	
        final Channel channel = RabbitUtil.getChannel();	
        String orderExchangeName = "order_exchange";	
        String orderQueueName = "order_queue";	
        String orderRoutingKey = "order.#";	
        Map<String, Object> arguments = new HashMap<String, Object>(16);	

	
        //死信队列配置  ----------------	
        String dlxExchangeName = "dlx.exchange";	
        String dlxQueueName = "dlx.queue";	
        String dlxRoutingKey = "#";	

	
        // 为队列设置队列交换器	
        arguments.put("x-dead-letter-exchange",dlxExchangeName);	
        // 设置队列中的消息 10s 钟后过期	
        //arguments.put("x-message-ttl", 10000);	
        arguments.put("x-max-length",3);	

	
        //正常的队列绑定	
        channel.exchangeDeclare(orderExchangeName, "topic", true, false, null);	
        channel.queueDeclare(orderQueueName, true, false, false, arguments);	
        channel.queueBind(orderQueueName, orderExchangeName, orderRoutingKey);	

	
        String message = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()) + " 创建订单.";	

	
        // 创建死信交换器和队列	
        channel.exchangeDeclare(dlxExchangeName, "topic", true, false, null);	
        channel.queueDeclare(dlxQueueName, true, false, false, null);	
        channel.queueBind(dlxQueueName, dlxExchangeName, orderRoutingKey);	

	
        for(int i=0;i<5;i++){	
            message = message + "========> " + i ;	
            System.out.println("发送的消息是:" + message);	
            channel.basicPublish(orderExchangeName, "order.save",null, message.getBytes());	
        }	

	
        System.err.println("消息发送完成......");	
    }	

	
}

消费者代码

public class Consumer {	

	
    private static final String QUEUE_NAME = "order_queue";	

	
    public static void main(String[] args) throws Exception{	
        // 创建信道	
        final Channel channel = RabbitUtil.getChannel();	
        // 消费端消息限流。	
        // 设置客户端最多接收未被ack的消息个数, 只有消息 手动签收  此参数才会生效。	
        //channel.basicQos(1);	

	
        System.out.println("消费者启动 ..........");	

	
        com.rabbitmq.client.Consumer consumer = new DefaultConsumer(channel){	
            @Override	
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {	
                System.err.println("死信队列接收到消息：" + new String(body));	
                System.err.println("deliveryTag:" + envelope.getDeliveryTag());	
                channel.basicAck(envelope.getDeliveryTag(),false);	
            }	
        };	

	
        channel.basicConsume(QUEUE_NAME,false, consumer);	
        //TimeUnit.SECONDS.sleep(10000000L);	
    }	

	
}

启动生产者，5条消息发送完毕

640?wx_fmt=png

再启动消费端，通过控制台可以看到，消费端只从order_queue中消费了3条消息，还剩2条消息去哪里了呢？

640?wx_fmt=png

我们再回到控制台观察一下，发现在dlx.queue这个死信队列中有两条就绪的消息，即剩下的2条消息被路由到了死信队列了

640?wx_fmt=png

以上便是关于死信队列常见的3种方式的处理程序和逻辑

640?wx_fmt=jpeg

dotNET跨平台
关注
  • 0
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
RabbitMQ死信队列
weixin_59074080的博客
05-14 9125
DLX，全称为Dead-Letter-Exchange , 可以称之为死信交换机，也有人称之为死信邮箱。当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就称之为死信队列。消息被拒绝消息过期队列达到最大长度DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何的队列上被指定，实际上就是设置某一个队列的属性。
RabbitMq（1）死信队列、延迟队列
qq_34708359的博客
01-11 4089
一、死信队列 DLX（Dead Letter Exchange），死信交换器。当队列中的消息被拒绝、或者过期会变成死信，死信可以被重新发布到另一个交换器，这个交换器就是DLX，与DLX绑定的队列称为死信队列。 造成死信的原因： 信息被拒绝 信息超时 超过了队列的最大长度 可以通过设置x-dead-letter-exchange参数指定DLX，设置x-dead-letter-routing-ke...
RabbitMQ的死信队列和延时队列
DMaker1993的博客
12-26 3294
本文介绍并实战RabbitMQ的死信队列，以及通过RabbitMQ如何实现延时队列。
RabbitMQ 之 死信队列
最新发布
weixin_73616913的博客
05-27 1012
但是发生了上面所说的三种情况中的一种，成为了死信，然后被转换到死信交换机中，这个死信交换机也是 direct 类型，它们之间的 routingKey 是 "lisi",然后就进入了死信队列，死信队列由 C2 消费。生产者正常情况下走的是普通的交换机，这个交换机的类型是 direct ，它和普通队列之间的关系是一个叫 "zhangsan" 的路由 key， 正常情况下会被 C1 消费。应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。，字面意思可以这样理。
Spring Boot利用RabbitMQ的死信队列实现定时任务,如超时未支付,自动取消订单等等......
a870368162的博客
08-14 3980
本文不介绍如何整合消息队列,有需要请参考我之前发布:https://blog.csdn.net/a870368162/article/details/99566685 RabbitMQ死信队列 RabbitMQ要实现延时任务，需要使用RabbitMQ的死信交换机（Exchange）和消息的存活时间TTL（Time To Live）来实现 死信交换机 死信交换机跟普通交换机一样,只是这个交换机用来存...
RabbitMQ系列（十三）RabbitMQ的死信队列
在不断的学习和实践中提升自己......
08-06 343
RabbitMQ系列（十三）RabbitMQ的死信队列 目录 [隐藏]概览死信的概念死信出现的情况如何配置死信队列示例死信队列的应用场景概览注意：业务队列与死信交换机的绑定是在构建业务队列时，通过参数（x-dead-letter-exchange和x-dead-letter-routing-key）的形式进行指定。死信的概念“死信–Dead Letter”是RabbitMQ中的一种消息机制。 “死信”消息会被RabbitMQ进行特殊处理，如果配置了死信队列，那么“死信”消息将会被丢进死信队列中，如果没有配置
Spring RabbitMQ死信机制原理实例详解
08-24
Spring RabbitMQ 死信机制原理实例详解是指在消息队列中，消息没有被及时消费的机制，可以提高系统的稳定性，当消息消费失败后，消息进入死信队列，可以对消息进行补偿，达到最终一致性的目标。本文通过示例代码介绍...
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
延迟队列的实现方式有多种，例如，使用死信队列+TTL 过期时间来实现延迟队列，使用 RabbitMQ 官方提供的延迟队列插件等。每种方式都有其优缺点，需要根据实际情况选择合适的方式。 在使用 RabbitMQ 实现延迟队列时...
JAVA获取rabbitmq消息总数过程详解
08-25
在Java中，获取RabbitMQ消息总数的过程涉及与RabbitMQ服务器建立连接、创建通道、声明队列以及查询队列状态。以下是一个详细的步骤解析： 1. **建立连接**: 首先，需要通过`ConnectionFactory`类来创建一个连接工厂...
RabbitMq整合使用
02-07
**RabbitMQ整合使用详解** RabbitMQ是一个开源的消息队列系统，基于AMQP（Advanced Message Queuing Protocol）协议，广泛应用于分布式系统中，用于处理异步任务、解耦组件以及实现流量控制。在Spring Boot框架中...
RabbitMQ实战 高效部署分布式消息队列
05-19
6. **高级特性**：如死信队列、延迟队列、TTL（Time To Live）设置、镜像队列和高可用性配置，用于提升系统稳定性和容错性。 7. **监控与日志**：如何使用RabbitMQ管理控制台监控队列状态，以及如何配置日志记录，...
RabbitMQ详解（超详细整理，值得珍藏）
03-17
- **死信队列（Dead Letter Exchange,DLX）**：当消息无法正常路由或达到最大重试次数时，可将其发送到死信队列，便于排查问题。 - **消息持久化（Message Persistence）**：通过持久化设置，即使RabbitMQ重启，消息...
关于利用RabbitMQ实现延迟任务的方法详解
10-18
4. 当消息过期，RabbitMQ会将它们从源头队列移动到死信交换机，然后再路由到目标队列，由消费者处理。 这种模式的优点在于，它能够实现精确的延迟任务处理，而不需要定时轮询或者依赖额外的后台服务。同时，由于...
RabbitMQ高级（消息可靠性、死信交换机、惰性队列、MQ集群部署）
06-30
死信交换机与死信队列 在某些情况下，消息可能无法被正确路由或消费，这时它们会被放入死信队列。通过配置死信交换机，我们可以定义这些消息的新去向，例如用于日志记录、分析或人工处理。 - **死信交换机**：...
RabbitMq与Spring整合实例
01-17
**RabbitMQ与Spring整合详解** RabbitMQ是一款开源的消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议实现，广泛应用于分布式系统中的异步处理、解耦和扩展性需求。Spring框架则是Java领域中最...
rabbitmq-windows64位两件套
10-08
除了基本的消息传递功能，RabbitMQ还支持高级特性，如死信队列、延迟队列、消息确认机制、TTL（Time To Live）等，这些特性能够帮助企业构建更加健壮、灵活的消息处理系统。 总的来说，RabbitMQ作为一个成熟的消息...
RabbitMQ高级：死信队列详解
祝我飞黄腾达
03-24 2147
应用场景：下单20分钟还未完成支付，订单自动取消（转移到死信队列，并更新订单状态） 什么是死信队列？ DLX (全称：Dead-Letter-Exchange 可称为死信交换机)，如果一条消息成为死信 dead message，它不是直接丢弃掉，而是再转发到另外一个交换机，由这个交换机来处理这条死信。即DLX，绑定DLX的队列称之为死信队列。 DLX与其它正常交换机无区别，当队列中存在死信时，RabbitMQ自动会将此消息重新发布到设置的死信交换机中，进而被路由到死信队列 ➳ 结论：.
消息中间件之rabbitMQ实战-死信队列
weixin_43408362的博客
10-25 854
该篇文章内容较多，包括有rabbitMq相关的一些简单理论介绍，集成spring Boot，provider消息推送实例，consumer消息消费实例，Direct（直连类型交换机）、Fanout（广播类型交换机）的使用、死信队列等。 MQ使用场景 1、异步： 当一个服务调用链路过长时，而用户只关心前面的流程，例如下订单、减库存、增积分、发短信等等，而用户只关心我的订单是否创建成功，后面的流程可以放到MQ去通知下游系统。 2、解耦： 你一个订单流程，你扣积分，扣优惠券，发短信，扣库存。。。等等这么多业务要调
RabbitMQ：死信队列
kaven
02-13 1905
Java初识RabbitMQ一死信队列 什么是死信队列 死信队列，DLX（dead-letter-exchange），利用DLX，当消息在一个队列中变成死信 (dead message) 之后，它能被重新投递到另一个exchange上，这个exchange就是DLX，似乎叫死信交换机更加贴切，当死信投递到这个exchange后，我们也可以用queue来绑定该exchange，该exchange可以...
rabbitmq死信
08-22
- *1* [RabbitMQ中的死信及死信队列详解](https://blog.csdn.net/qq_41865652/article/details/123311813)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值