rabbitMQ学习-死信队列

最新推荐文章于 2024-03-17 12:12:11 发布
最新推荐文章于 2024-03-17 12:12:11 发布
阅读量1.1k 收藏
点赞数 1
分类专栏： # rabbitMQ 文章标签： java-rabbitmq rabbitmq 学习
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45922256/article/details/127797219
版权

死信队列

死信：顾名思义就是无法被消费的消息，一般情况下，product将消息投递到broker或者直接到queue里，consumer从queue取出消息，进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成死信，有死信自然就有死信队列。

一般应用场景：为了保证订单业务中的消息数据不丢失，需要使用rabbitMQ的死信队列机制，当消息消费发生异常的时候，将消息投入死信队列中，还有比如说：用户在商场下单成功并点击去支付后在指定时间未支付时自动失效。

死信的来源

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

死信实战

在这里插入图片描述

消息TTL过期
在这里插入图片描述

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

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();
        //死信消息，设置TTL时间
        AMQP.BasicProperties properties =
                new AMQP.BasicProperties()
                        .builder().expiration("10000").build();

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


/*
死信
    消费者
 */
public class Consumer01 {

    //普通交换机的名称
    private static  final  String NORMAL_EXCHANGE = "normal_exchange";
    //死信交换机的名称
    private  static  final String DEAD_EXCHANGE = "dead_exchange";
    //普通队列名称
    private static  final  String NORMAL_QUEUE = "normal_queue";
    //死信队列名称
    private static  final  String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();

        //声明死信和普通交换机类型 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);

        // 普通队列
        Map<String,Object> argument = new HashMap<>();
        //过期时间10秒过期   可以不设置，可以交给队列自动去
       // argument.put("x-message-ttl",100000);
        //正常队列设置死信交换机
        argument.put("x-dead-lettle-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        argument.put("x-dead-lettle-routing-key","lisi");

        channel.queueDeclare(NORMAL_QUEUE,false,false,false,argument);

        ///
        //声名死信队列
        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 = (consumer,message)->{
            System.out.println("Consumer 01接受到消息是：" + new String(message.getBody(),"UTF-8"));
        };

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

public class Consumer02 {

    //死信队列名称
    private static  final  String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();

        System.out.println("等待接受......");

        //绑定死信的交换机和死信的对列
        DeliverCallback deliverCallback = (consumer,message)->{
            System.out.println("Consumer 02接受到消息是：" + new String(message.getBody(),"UTF-8"));
        };

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

解决进不去死信队列的原因了，就是我没给他把过期时间值传进去，导致出现问题。

队列达到最大长度
消息生成者代码去掉TTL属性。

public class Consumer01 {

    //普通交换机的名称
    private static  final  String NORMAL_EXCHANGE = "normal_exchange";
    //死信交换机的名称
    private  static  final String DEAD_EXCHANGE = "dead_exchange";
    //普通队列名称
    private static  final  String NORMAL_QUEUE = "normal_queue";
    //死信队列名称
    private static  final  String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();

        //声明死信和普通交换机类型 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);

        // 普通队列
        Map<String,Object> argument = new HashMap<>();
        //过期时间10秒过期   可以不设置，可以交给队列自动去
       // argument.put("x-message-ttl",10000);
        //正常队列设置死信交换机
        argument.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        argument.put("x-dead-letter-routing-key","lisi");

        //设置正常队列的长度的限制
        argument.put("x-max-length",6);


        channel.queueDeclare(NORMAL_QUEUE,false,false,false,argument);

        ///
        //声名死信队列
        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 = (consumer,message)->{
            System.out.println("Consumer 01接受到消息是：" + new String(message.getBody(),"UTF-8"));
        };

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

}

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

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();
        //死信消息，设置TTL时间 单位是ms
     //   AMQP.BasicProperties properties =
      //          new AMQP.BasicProperties()
                        //.builder().expiration("10000").build();

        for (int i = 0; i < 11; i++) {
            String message = "info "+ i;
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }
    }
}

在这里插入图片描述
消息被拒绝
一旦消费者拒绝接受，就会成为死信队列。

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

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();
        //死信消息，设置TTL时间 单位是ms
      //演示长度  AMQP.BasicProperties properties =
         //   new AMQP.BasicProperties()
           //             .builder().expiration("10000").build();

        for (int i = 0; i < 11; i++) {
            String message = "info "+ i;                        //properties
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }
    }
}

public class Consumer01 {

    //普通交换机的名称
    private static  final  String NORMAL_EXCHANGE = "normal_exchange";
    //死信交换机的名称
    private  static  final String DEAD_EXCHANGE = "dead_exchange";
    //普通队列名称
    private static  final  String NORMAL_QUEUE = "normal_queue";
    //死信队列名称
    private static  final  String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();

        //声明死信和普通交换机类型 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        channel.exchangeDeclare(DEAD_EXCHANGE,BuiltinExchangeType.DIRECT);

        // 普通队列
        Map<String,Object> argument = new HashMap<>();
        //过期时间10秒过期   可以不设置，可以交给队列自动去
       // argument.put("x-message-ttl",10000);
        //正常队列设置死信交换机
        argument.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信RoutingKey
        argument.put("x-dead-letter-routing-key","lisi");

        //设置正常队列的长度的限制
      //演示拒绝  argument.put("x-max-length",6);


        channel.queueDeclare(NORMAL_QUEUE,false,false,false,argument);

        ///
        //声名死信队列
        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 = (consumer,message)->{
       //拒绝消息在这里写
            String message1 = new String(message.getBody(),"UTF-8");
           //指定你要拒绝的消息
            if(message1.equals("info 5")){
                System.out.println("此消息是被拒绝的"+ message1);
                //拒接接收，且不放回队列，避免队列重新发送
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else {

                System.out.println("Consumer 01接受到消息是：" + new String(message.getBody(),"UTF-8"));
               //   接收且不放回
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }

        };
        //开启手动应答,                      //true是自动应答。
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,consumer->{});
    }

}

public class Consumer02 {

    private  static  final String DEAD_EXCHANGE = "dead_exchange";

    //死信队列名称
    private static  final  String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        Channel channel = GetConnection.getChannel();
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待接受......");

        //绑定死信的交换机和死信的对列
        DeliverCallback deliverCallback = (consumer,message)->{
            System.out.println("Consumer 02接受到消息是：" + new String(message.getBody(),"UTF-8"));
        };
        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,consumer->{});
    }
}
Miaow.Y.Hu
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
RabbitMQ学习-实战.docx
06-26
RabbitMQ学习-实战.docx  搭建RabbitMQ的环境  学习RabbitMQ的队列学习Spring-Rabbit
Spring RabbitMQ死信机制原理实例详解
08-24
主要介绍了Spring RabbitMQ死信机制原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
RabbitMQ——死信队列和延迟队列
最新发布
万里顾一程的博客
03-17 1107
延迟队列是一种消息队列中的一种特殊类型，它允许消息在一定的延迟时间后再被消费。死信队列（Dead Letter Queue，DLQ）是 RabbitMQ 中的一种重要特性，用于处理无法被消费的消息，防止消息丢失。生产者发送消息到正常队列，而消费者负责消费正常队列的消息。当消息被消费者拒绝并不再重新投递时，消息会被发送到死信队列。在消息队列中，当消息满足一定条件而无法被正常消费时，这些消息会被发送到死信队列。1、把下载好的插件从服务器拷贝到 RabbitMQ 容器内plugins目录。2、进入容器查看插件。
消息队列RabbitMQ学习-1
01-20
消息队列RabbitMQ学习 为什么学习RabbitMQ 每一种技术的出现，都是为了解决业务需求而产生的。通常的背景是，在某种业务场景下，出现了某种问题，怎么解决这种问题，一个新的技术产生了。下面举个单体架构的例子来说明。 1.1单体架构的缺点 上面这种单体架构中，所有的业务都堆积在一个项目中，最终打成一个war包进行部署。 在服务的高可用方面，通过nginx做一个集群 这种结构，最开始出现问题的是数据库。当数据量激增，数据查询变得缓慢，需要开始对mysql进行优化，如：增加索引 为了防止单点故障，数据库采用主从复制，还会采用读写分离，分库分表等技术，但是这种情况下，系统架构依然有问题； 在
RabbitMQ死信队列应用1
08-03
1、什么是死信队列 2、死信队列应用场景 3、延迟消息概念 4、死信队列使用流程图 5、死信队列应用（管理控制台） 6、死信队列应用（Java代码）
rabbitmq死信队列详解（亲手实践）
爪哇人的博客
06-04 3332
因为在声明普通队列的时候，已经说明了队列最大长度为5，那么多余的消息就会根据配置的参数找到对应的交换机进而找到对应的路由，然后路由到对应的队列（死信队列）。死信队列其实和普通的队列一样，只不过里面存放的消息都是普通队列过期没有消费的。以上只是声明了一个普通队列queueB，然后在该队列设置了过期时间40s，和死信交换机和死信路由key。死信队列就是一个普通的队列，只不过声明普通队列的时候指定了死信交换机，二者才产生了联系。可以发现，发送给普通队列的消息，超时没有被消费，都进入到了死信队列中。
RabbitMq死信队列
qq_28227405的博客
01-25 1392
死信队列是指消息被投递到队列后，由于各种原因导致队列中的消息无法被消费掉，这样的消息如果没有后续处理就变成了死信，有死信自然就有了死信队列。 如果是固定的过期时间则可以通过队列设置过期时间的方式实现。当过期时间不固定且有很多的过期时间且不希望有过多的过期队列时则可以使用插件的方式（rabbitmq_delayed_message_exchange插件）实现延迟队列的效果。一定不能通过设置生产者的过期时间来实现消息的任意过期时间的目的，否则就会出现我们示例中的问题。
RabbitMQ之死信队列
m0_55993923的博客
05-20 697
​ 死信，就是无法被消费的消息。​ 一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，如果没有后续的处理，就变成了死信。​ 应用场景：为了保证订单业务的数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中。或者用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。
轻松学会搭建RabbitMq延时(死信)队列
qq_40975602的博客
06-27 723
延时（死信）队列使用场景，以及实战小用例
RabbitMQ实现死信队列
热门推荐
一恍过去
07-19 1万+
RabbitMQ实现死信队列
RabbitMQ死信队列
weixin_59074080的博客
05-14 9042
DLX，全称为Dead-Letter-Exchange , 可以称之为死信交换机，也有人称之为死信邮箱。当消息在一个队列中变成死信(dead message)之后，它能被重新发送到另一个交换机中，这个交换机就是DLX ，绑定DLX的队列就称之为死信队列。消息被拒绝消息过期队列达到最大长度DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何的队列上被指定，实际上就是设置某一个队列的属性。
支付状态一致性-RabbitMQ死信队列
03-19
支付状态一致性-RabbitMQ死信队列
RabbitMQ高级特性（五）：RabbitMQ之死信队列DLX
HaleyTiger的博客
12-27 1198
RabbitMQ高级特性（五）：RabbitMQ之死信队列DLX
RabbitMQ自学之路（八）—— RabbitMQ死信/死信队列及实现源码
互联网叫兽
06-28 6085
死信/死信队列及死信交换机是什么，和mq中队列交换机有什么关系，我这里用一张图来概括下 （图片来源网上） 从图中发现知： 生产者发送的消息会经由交换机传送到绑定的队列中，然后经由消费者接受消息，消息一旦被消费者消费后，就会移除队列中，表示整个流程的结束。 但是如果消息没有被消费成功（或者说消息变为了死信），那么正常来说和原来的（正常）队列绑定的消费者就无法消费消息，那么变为死信的消息怎么处理啦！...
Rabbitmq死信队列
Rk的博客
10-12 4578
死信队列俗称，备胎队列；消息中间件因为某种原因拒收该消息后，可以转移到死信队列中存放，死信队列也可以有交换机和路由key等。消费者在消费生产者生产的消息时发生了某些特殊情况（下文会说），导致消息无法被正常消费，存放这些未被消费的消息的队列即为死信队列。
RabbitMQ学习（八）：死信队列
m0_49499183的博客
02-17 348
死信，顾名思义就是无法被消费的消息，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息 进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有 后续的处理，就变成了死信。有死信自然也有死信队列。应用场景:1、为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息 消费发生异常时，将消息投入死信队列中。2、用户在商城下单成功并点击去支付后在指定时 。
RabbitMQ的死信队列详解
wdquan19851029的专栏
07-14 3824
RabbitMQ的死信队列详解，全面了解 RabbitMQ的功能
RabbitMQ系列（15）--死信队列的简介与死信队列和死信消费者的实现
m0_64284147的博客
07-06 2727
(21)查看Consumer01控制台的输出，观察dead_queue队列消息数量的变化，因为没有开启Consumer02消费dead_queue队列，可以看到dead_queue队列堆积了1条消息，查看这条消息，可以看出就是我们拒绝掉的info5，这证明消费者拒绝消费消息info5后，消息info5从normal_queue队列移到了dead_queue队列里，由此可见当消息被拒绝消费后，死信队列成功运行。(18)修改Consumer01的代码，注释掉限制队列长度的代码，修改消息应答的部分代码。
rabbitmq中的死信队列
09-14
RabbitMQ中的死信队列（Dead Letter Queue，DLQ）是用于处理消息投递失败或被拒绝的情况。当消息无法被消费者处理时，可以将其发送到一个特定的队列，这个队列就是死信队列。 使用死信队列可以有以下几个优点： 1. 错误处理：当消息无法被消费者成功处理时，可以将其发送到死信队列，方便进行错误处理和排查。 2. 重试机制：在死信队列中可以配置一些重试逻辑，例如延时重试或指数退避等，提高消息的处理成功率。 3. 延迟队列：死信队列还可以作为延迟队列使用，将消息发送到死信队列后，在一定时间后再重新投递给其他队列进行处理。 要使用死信队列，需要在声明队列和交换机时设置一些属性。具体步骤如下： 1. 声明死信交换机（Dead Letter Exchange，DLX）和死信队列（DLQ）。 2. 将DLQ绑定到DLX。 3. 在声明普通队列时，通过设置`x-dead-letter-exchange`和`x-dead-letter-routing-key`参数来指定死信交换机和路由键。 这样当消息被拒绝或者过期时，就会被发送到DLQ中进行后续处理。 以上就是关于RabbitMQ中死信队列的简要介绍，希望能对你有所帮助。如有更多疑问，请继续提问。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Miaow.Y.Hu

赏一口饭吃吧，大大们

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值