【RabbitMQ快速入门(三、RabbitMQ高级特性：死信队列)】

最新推荐文章于 2024-10-11 18:10:05 发布
最新推荐文章于 2024-10-11 18:10:05 发布
阅读量145 收藏
点赞数 1
分类专栏： MQ 后端 java 文章标签： java-rabbitmq rabbitmq java 分布式 后端
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/xyhxuyonghao/article/details/129666979
版权
java 同时被 3 个专栏收录
51 篇文章 0 订阅
订阅专栏
后端
18 篇文章 0 订阅
订阅专栏
MQ
5 篇文章 0 订阅
订阅专栏

RabbitMQ高级特性：死信队列

前言

跟随b站尚硅谷RabbitMQ视频学习：如果有小伙伴们认为不正确的的地方，欢迎大家一起讨论

下面是b站视频链接：
b站尚硅谷rabbitmq的死信队列视频

提示：以下是本篇文章正文内容，下面案例可供参考

一、什么是死信队列？

1.什么是死信队列

当一条消息在队列中出现以下三种情况的时候，该消息就会变成一条死信。

  • 消息被拒绝(basic.reject / basic.nack)，并且requeue = false
  • 消息TTL过期
  • 队列达到最大长度

当消息在一个队列中变成一个死信之后，如果配置了死信队列，它将被重新publish到死信交换机，死信交换机将死信投递到一个队列上，这个队列就是死信队列。

2.死信队列的工作模式

在这里插入图片描述

3.死信队列的工作流程：

生产者发布消息到普通交换机，普通交换机绑定一个普通队列，如果发布的消息在加入队列的时候发生了1.消息被拒绝、2.消息超时(TTL)、3.普通队列达到了最大长度，那么不符合条件的消息就通过正常队列绑定的私信交换机发送到死信交换机，然后再由死信交换机把消息发送到绑定的死信队列，其中正常用户c1消费了普通队列中的消息，死信用户消费了死信队列中的消息。

二、死信队列的实现

1.创建消费者1

消费者1要绑定正常交换机，正常队列，死信交换机，死信队列，是比较麻烦的一个类，所以先把消费者1实现：

引入rabbitmq依赖，创建一个rabbitmq的连接工具：
代码如下（示例）：

package utils;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitMQUtil {
    public static Channel getChannel() throws IOException, TimeoutException {
            //1.创建连接工厂
            ConnectionFactory connectionFactory = new ConnectionFactory();
            //2.设置参数
            connectionFactory.setHost("192.168.209.128");//ip:默认值 localhost
            connectionFactory.setPort(5672);//端口 默认值 5672
            connectionFactory.setVirtualHost("/xyh");//虚拟机 默认值：/
            connectionFactory.setUsername("xyh");//用户名
            connectionFactory.setPassword("xyh980616");//密码
            //3.获取连接 connection
            Connection connection = connectionFactory.newConnection();
            //4.创建channel
            Channel channel = connection.createChannel();
            return channel;
    }

}

创建Consumer01：

模拟因为TTL实现死信队列的产生

public class Consumer01_DeadQueue {

    //普通交换机名称
    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 = RabbitMQUtil.getChannel();
        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);
        //声明普通队列
        Map<String, Object> arguments = new HashMap<>();
        //过期时间
        //10s = 10000ms
        arguments.put("x-message-ttl",10000);
        //正常队列到死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信routingkey
        arguments.put("x-dead-letter-routing-key","lisi");
        //设置正常队列的长度的限制
//        arguments.put("x-max-length",6);


        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        //声明死信队列
        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 s = new String(message.getBody());
            System.out.println("Consumer01接受的消息是:"+s);
            }

        };

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

    }


}

启动Consumer01，创建了两个交换机和队列
运行实现

2.创建Producer

生产者不知道死信队列是怎么产生的，它只需要绑定普通交换机跟普通队列即可

生产者代码如下：

public class Producer_DeadQueue {
    //普通交换机名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtil.getChannel();
        //死信消息 设置TTL时间 单位是毫秒
        AMQP.BasicProperties properties =
                new AMQP.BasicProperties()
                        .builder().expiration("100000").build();


        for (int i = 1;i<11;i++){
            String message = "info"+i;

//发布消息          
channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());

        }
    }
}

模拟TTL死信队列的产生，先挂掉Consumer01，在启动producer，按照流程消息发布到normal_queue里面，一开始normal_queue的Ready里面会有10条数据，然后十秒钟过后这十条数据都会跑到dead_queue里面去。

一开始在normal_queue里面的结果：
在这里插入图片描述
过了10秒后的MQ页面：
在这里插入图片描述
可见跟工作流程实现的是一样的。

模拟因为队列达到最大长度而产生的死信队列：

Consumer01的代码：

public class Consumer01_DeadQueue {

    //普通交换机名称
    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 = RabbitMQUtil.getChannel();
        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);
        //声明普通队列
        Map<String, Object> arguments = new HashMap<>();
        //正常队列到死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信routingkey
        arguments.put("x-dead-letter-routing-key","lisi");
        //设置正常队列的长度的限制
        arguments.put("x-max-length",6);


        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        //声明死信队列
        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 s = new String(message.getBody());
            System.out.println("Consumer01接受的消息是:"+s);

        };

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

因为我们设置了普通队列最大长度为6，那么如果producer发送10条数据，那么死信队列里面会有4条数据，让我们来看看结果：
producer实现：

public class Producer_DeadQueue {
    //普通交换机名称
    public static final String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMQUtil.getChannel();
        //死信消息 设置TTL时间 单位是毫秒
//        AMQP.BasicProperties properties =
//                new AMQP.BasicProperties()
//                        .builder().expiration("100000").build();


        for (int i = 1;i<11;i++){
            String message = "info"+i;
//          channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());

            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes());
        }
    }
}

先运行Consumer01，创建出两个队列：
在这里插入图片描述
在挂掉Consumer01，运行producer，让我们来看看结果：
在这里插入图片描述
跟我们预料的结果是一致的。

模拟消息被拒绝产生的死信队列：

Consumer01 的代码：

public class Consumer01_DeadQueue {

    //普通交换机名称
    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 = RabbitMQUtil.getChannel();
        //声明普通交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);
        //声明普通队列
        Map<String, Object> arguments = new HashMap<>();
        //过期时间
        //10s = 10000ms
//        arguments.put("x-message-ttl",10000);
        //正常队列到死信交换机
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信routingkey
        arguments.put("x-dead-letter-routing-key","lisi");
        //设置正常队列的长度的限制
//        arguments.put("x-max-length",6);


        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        //声明死信队列
        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 s = new String(message.getBody());
            if (s.equals("info5")){
                System.out.println("Consumer01接受的消息是:"+s+"此消息被C1拒绝");
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else {
                System.out.println("Consumer01接受的消息是:"+s);
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }
        };
        //开启手动应答
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,consumerTag->{});
    }


}

先运行Consumer01创建出队列：
在这里插入图片描述
不挂断Consumer01,继续运行Producer，结果为：
在这里插入图片描述
让我们再看看控制台是否输出符合预期：
在这里插入图片描述
让我们再看看MQ控制台里面拿到的dead_queue里面的信息：
在这里插入图片描述
恭喜我们完成了死信队列的实现！

十六、RabbitMQ快速入门
11-21
【RabbitMQ快速入门】 RabbitMQ是一款广泛使用的开源消息队列系统，它基于AMQP（Advanced Message Queuing Protocol）协议，提供高可用性、可靠性和可扩展性，是分布式系统中实现异步任务处理、解耦组件以及负载...
死信队列介绍
weixin_45063957的博客
10-04 2665
先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说: 用户在商城下单成功并点击
死信队列详解
DevCorner的Pro技术博客
06-07 7868
在消息队列中，执行异步任务时，通常是将消息生产者发布的消息存储在队列中，由消费者从队列中获取并处理这些消息。但是，在某些情况下，消息可能无法正常地被处理和消耗，例如：格式错误、设备故障等，这些未成功处理的消息就被称为“死信”。为了避免这些未成功处理的消息导致程序异常或对系统造成影响，我们需要使用死信队列当我们设置死信队列后，所有无法成功处理的消息将被捕获并重定向到指定的死信交换机中。消费者可以从该交换机中读取并处理这些“死信”。
RabbitMQ 高级特性——死信队列
最新发布
不能再留遗憾了的博客
10-11 1666
RabbitMQ死信队列
[MQ] 死信队列介绍与场景描述
沫洺的博客
11-20 2361
死信队列介绍与场景描述
rabbitmq死信队列详解（亲手实践）
爪哇人的博客
06-04 4276
因为在声明普通队列的时候，已经说明了队列最大长度为5，那么多余的消息就会根据配置的参数找到对应的交换机进而找到对应的路由，然后路由到对应的队列（死信队列）。死信队列其实和普通的队列一样，只不过里面存放的消息都是普通队列过期没有消费的。以上只是声明了一个普通队列queueB，然后在该队列设置了过期时间40s，和死信交换机和死信路由key。死信队列就是一个普通的队列，只不过声明普通队列的时候指定了死信交换机，二者才产生了联系。可以发现，发送给普通队列的消息，超时没有被消费，都进入到了死信队列中。
什么是死信队列
qq_36042938的博客
03-11 551
当消息满足特定条件时，比如消息被拒绝、消息过期或者队列达到最大长度等，这些消息就会被发送到死信队列中。通过使用死信队列，我们可以对无法正常处理的消息进行特殊处理，比如记录日志、统计失败次数、发送告警通知等。当队列已经达到最大长度，新的消息无法进入队列时，这些新消息可能会被发送到死信队列，以便给予特别处理或记录日志。如果消息设置了过期时间，并且在此时间内没有被消费者处理，那么该消息可能会成为死信，被发送到死信队列中。当消费者拒绝消费消息并且不将其重新放回原始队列时，消息可能会被发送到死信队列。
RabbitMQ从入门到进阶
01-30
此外，还有死信队列、延迟队列等高级特性，以应对更复杂的业务需求。 总之，RabbitMQ是一个强大的消息中间件，通过AMQP协议提供了高效、可靠的消息传递机制。了解其工作原理和模式对于开发高效、稳定的分布式系统至...
rabbitmq基础入门
04-01
此外，RabbitMQ还有死信队列的概念，处理那些无法正常路由或被拒绝的消息。死信可能源于消息TTL过期、队列溢出或消息被拒绝。延时队列则用于处理需要在特定时间后处理的消息，RabbitMQ可以通过插件实现这一功能。 ...
RabbitMQ入门视频
04-05
**正文** RabbitMQ是一种广泛使用的开源消息代理和队列服务器，它基于AMQP（Advanced ...在后续的学习中，还可以探索RabbitMQ的高级特性，如死信队列、延迟队列、镜像队列以及插件系统等，以提升系统的健壮性和性能。
RabbitMQ极速入门.zip
07-19
本资料将带你快速了解并入门RabbitMQ。 1. **什么是消息队列** 消息队列是一种中间件，用于在分布式系统中解耦组件，通过临时存储消息来协调不同进程之间的通信。这种模式降低了组件间的依赖性，提高了系统的响应...
RabbitMQ系列（15）--死信队列的简介与死信队列和死信消费者的实现
m0_64284147的博客
07-06 3470
(21)查看Consumer01控制台的输出，观察dead_queue队列消息数量的变化，因为没有开启Consumer02消费dead_queue队列，可以看到dead_queue队列堆积了1条消息，查看这条消息，可以看出就是我们拒绝掉的info5，这证明消费者拒绝消费消息info5后，消息info5从normal_queue队列移到了dead_queue队列里，由此可见当消息被拒绝消费后，死信队列成功运行。(18)修改Consumer01的代码，注释掉限制队列长度的代码，修改消息应答的部分代码。
死信队列
热门推荐
qq_43644198的博客
11-18 2万+
死信队列 什么是死信队列 一般来说，producer将消息投递到queue中，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信(Dead Letter)，所有的死信都会放到死信队列中。 “死信”消息会被RabbitMQ进行特殊处理，如果配置了死信队列信息，那么该消息将会被丢进死信队列中，如果没有配置，则该消息将会被丢弃。 消费者消费消息 ​ 1)正常消费–>手动ack–>MQ从队列中删除消息
Rabbitmq死信队列
Rk的博客
10-12 5711
死信队列俗称，备胎队列；消息中间件因为某种原因拒收该消息后，可以转移到死信队列中存放，死信队列也可以有交换机和路由key等。消费者在消费生产者生产的消息时发生了某些特殊情况（下文会说），导致消息无法被正常消费，存放这些未被消费的消息的队列即为死信队列。
【RabbitMQ笔记10】消息队列RabbitMQ之死信队列的介绍
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
03-19 2823
在RabbitMQ中，并没有提供真正意义上的延迟队列，但是RabbitMQ可以设置队列、消息的过期时间，当队列或者消息到达过期时间之后，还没有被消费者消费，那么RabbitMQ会将这些消息放入另外一个队列，这个队列叫做：死信队列，而这个过期的消息就叫做：死信消息。哪些情况下，消息会变成死信消息？？？第一种情况：Queue队列已经满了，无法保存新进入的消息，那么这个消息就会被放入死信队列。第二种情况：队列中的消息被消费者拒绝消费了，并且没有设置重新放入Queue队列里面。
RabbitMQ之死信队列
weixin_43937178的博客
01-08 4380
死信队列概念 顾名思义，（死去的消息）即无法被消费的消息，指的是消费者在消费生产者生产的消息时发生了某些特殊情况（下文会说），导致消息无法被正常消费，存放这些未被消费的消息的队列即为死信队列。 死信队列应用场景 为了保证消息不被丢失，专门存放消息 做延时，将过了过期时间的消息存放在该队列中重新消费 造成消息成为死信的三种原因 消息过了过期时间TTL（time to live） 消息队列达到了最大长度 消息被消费者拒绝（basic.reject或者basic.nack）且requeue=false 死
《RabbitMQ》什么是死信队列
Java旅途
08-07 8940
一 什么是死信队列 当一条消息在队列中出现以下三种情况的时候，该消息就会变成一条死信。 消息被拒绝(basic.reject / basic.nack)，并且requeue = false 消息TTL过期 队列达到最大长度 当消息在一个队列中变成一个死信之后，如果配置了死信队列，它将被重新publish到死信交换机，死信交换机将死信投递到一个队列上，这个队列就是死信队列。 二 实现死信队列 2.1 原理图 2.2 创建消费者 创建一个消费者，绑定消费队列及死信交换机，交换机默认为direct模型，死信
RabbitMQ死信队列与延迟队列
tszc95的博客
09-11 948
延迟队列（Delayed Queues）： 延迟队列允许消息在一定时间后才能被消费者接收和处理。与普通队列不同，延迟队列会在消息发送后暂时存储消息，直到设定的延迟时间过去后才将消息发送给消费者。RabbitMQ 并没有内置的延迟队列机制，但我们可以通过插件或自定义实现来实现延迟队列。一种常见的实现方式是使用 RabbitMQ 的过期时间（TTL）和死信队列结合，将消息发送到带有延迟时间的队列中，然后在消息过期后自动转发到死信队列中，从而达到延迟队列的效果。
RabbitMQ高级特性:死信队列
Maisu的博客
04-07 1805
什么是死信队列?死信队列,英文缩写DLX,Dead Letter Exchange(死信交换机),当消息成为Dead message(消息过期)后,可以被重新发送到另一个交换机,这个交换机就算是DLX,其实死信交换机(队列)和正常交换机(队列)没有什么区别为什么叫死信队列但是翻译过来叫死信交换机呢,因为RabbitMQ比较特殊,其他MQ只有队列没有交换机这个概念的正常来说,队列设置了过期时间。
RabbitMQ教程：入门、高级特性及集群搭建
不过，根据提供的标题和描述，可以确定压缩包内应该包含了关于RabbitMQ入门、与Spring_SpringBoot整合、高级特性、安装说明以及集群搭建的相关教程和演示文件。这些文件可能是PDF、PPT、或者是其他格式的课件和示例...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值