【RabbitMq03】死信队列

最新推荐文章于 2024-08-03 21:27:32 发布
最新推荐文章于 2024-08-03 21:27:32 发布
阅读量187 收藏 2
点赞数
文章标签： 死信队列 rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_40964170/article/details/119208511
版权

死信的概念

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

应用场景

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

死信的来源

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

代码架构图
在这里插入图片描述

举个例子

一、TTL 过期

消费者1 消息

package com.lian.dead;

import com.lian.RabbitMqUtils;
import com.rabbitmq.client.*;

import java.util.HashMap;
import java.util.Map;

public class Consumer01 {

    //声明普通交换机名称
    private final static String NORMAL_EXCHANGE = "normal_exchange";
    //声明死信交换机名称
    private final static String DEAD_EXCHANGE = "dead_exchange";

    //声明普通队列名称
    private final static String NORMAL_QUEUE = "normal_queue";
    //声明死信队列名称
    private final static String DEAD_QUEUE = "dead_queue";

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

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

        //正常队列绑定死信队列信息，因为正常队列消息会变为死信
        Map<String, Object> arguments = new HashMap<>();
        //正常队列设置死信交换机 参数 key 是固定值
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //正常队列设置死信 routing-key 参数 key 是固定值
        arguments.put("x-dead-letter-routing-key", "lisi");
        //设置过期时间 10s,可以在消费者正常队列处设置，也可以在生产者发送处设置
        //map.put("x-message-ttl",100000);

        //声明死信和普通队列
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定普通的交换机和队列，交换机使用 路由key（routingKey） 和队列绑定
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        //绑定死信的交换机和死信队列，和路由key
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待接收消息");

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Consumer1 accept message is: "+ new String(message.getBody(),"UTF-8"));
            /**
             * 手动应答，消费者读取完mq消息后，要给生产者一个答复
             * 1、消息的标记 tag
             * 2、是否批量应答 false代表不批量应答信道中的消息  true代表批量
             */
            //channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = (consumerTag)->{

        };
        //采用手动应答,默认是自动true
        //boolean autoAck = false;
        //接收消息
        channel.basicConsume(NORMAL_QUEUE,true,deliverCallback,cancelCallback);
    }
}

生产者

package com.lian.dead;

import com.lian.RabbitMqUtils;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.Channel;

/**
 * 生产者发送10条消息
 * 设置过期时间10s钟，如果没有消费者消费消息的话
 * 消息就自动转为死信消息
 */
public class Producer {

    //声明普通交换机名称
    private final static String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        //死信消息，设置TTL时间 time to live 存活时间 AMQP advanced message queue protocol 高级消息队列协议
        AMQP.BasicProperties properties = new AMQP.BasicProperties()
                .builder().expiration("10000")
                .build();

        for (int i = 1; i < 11; i++) {
            String message = "info" + i;
            /**
             * 发送消息
             * 1、交换机名称
             * 2、路由key routingKey
             * 3、是否持久化消息
             * 4、消息
             */
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }
    }
}

消费者2

package com.lian.dead;

import com.lian.RabbitMqUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.util.HashMap;
import java.util.Map;

/**
 * 消费者2只负责 接收私信队列的消息
 */
public class Consumer02 {

    //声明普通队列名称
    private final static String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception {
        //创建信道
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("等待接收消息");

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Consumer2 accept message is: "+ new String(message.getBody(),"UTF-8"));
        };

        CancelCallback cancelCallback = (consumerTag)->{

        };
        //接收消息
        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);
    }
}

在这里插入图片描述

二、队列达到最大长度

因为我们对队列进行了修改，一定要先将rabbitmq控制台的原有队列删除，否则会报错

生产者

public class Producer2 {

    //声明普通交换机名称
    private final static String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        for (int i = 1; i < 11; i++) {
            String message = "info" + i;
            /**
             * 发送消息
             * 1、交换机名称
             * 2、路由key routingKey
             * 3、是否持久化消息
             * 4、消息
             */
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }
    }
}

消费者1

//设置正常队列的长度限制，总共发送11条数据，超出6条以外的数据就进入死信队列
arguments.put("x-max-length",6);

完整代码

package com.lian.dead;

import com.lian.RabbitMqUtils;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.CancelCallback;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;

import java.util.HashMap;
import java.util.Map;

public class Consumer03 {

    //声明普通交换机名称
    private final static String NORMAL_EXCHANGE = "normal_exchange";
    //声明死信交换机名称
    private final static String DEAD_EXCHANGE = "dead_exchange";

    //声明普通队列名称
    private final static String NORMAL_QUEUE = "normal_queue";
    //声明死信队列名称
    private final static String DEAD_QUEUE = "dead_queue";

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

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

        //正常队列绑定死信队列信息，因为正常队列消息会变为死信
        Map<String, Object> arguments = new HashMap<>();
        //正常队列设置死信交换机 参数 key 是固定值
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //正常队列设置死信 routing-key 参数 key 是固定值
        arguments.put("x-dead-letter-routing-key", "lisi");
        //设置正常队列的长度限制，总共发送11条数据，超出6条以外的数据就进入死信队列
        arguments.put("x-max-length",6);
        //设置过期时间 10s,可以在消费者正常队列处设置，也可以在生产者发送处设置
        //map.put("x-message-ttl",100000);

        //声明死信和普通队列
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定普通的交换机和队列，交换机使用 路由key（routingKey） 和队列绑定
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        //绑定死信的交换机和死信队列，和路由key
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"lisi");
        System.out.println("等待接收消息");

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Consumer1 accept message is: "+ new String(message.getBody(),"UTF-8"));
            /**
             * 手动应答，消费者读取完mq消息后，要给生产者一个答复
             * 1、消息的标记 tag
             * 2、是否批量应答 false代表不批量应答信道中的消息  true代表批量
             */
            //channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
        };

        CancelCallback cancelCallback = (consumerTag)->{

        };
        //采用手动应答,默认是自动true
        //boolean autoAck = false;
        //接收消息
        channel.basicConsume(NORMAL_QUEUE,true,deliverCallback,cancelCallback);
    }
}

消费者2

/**
 * 消费者2只负责 接收私信队列的消息
 */
public class Consumer02 {

    //声明普通队列名称
    private final static String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception {
        //创建信道
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("等待接收消息");

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Consumer2 accept message is: "+ new String(message.getBody(),"UTF-8"));
        };

        CancelCallback cancelCallback = (consumerTag)->{

        };
        //接收消息
        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);
    }
}

测试

1、先启动消费者1，自当在rabbitmq控制台生成了 正常队列、死信队列等，然后将其关闭，模拟异常
在这里插入图片描述

2、启动生产者发送10条数据

因为做了 队列最大长度限制，所以超出6条的消息就进入 死信队列中
在这里插入图片描述
3、启动消费者2

死信的4条数据被消费者2消费
在这里插入图片描述
消费者2控制台打印

Consumer2 accept message is: info1
Consumer2 accept message is: info2
Consumer2 accept message is: info3
Consumer2 accept message is: info4

三、消息被拒

消费者1

public class Consumer04 {

    //声明普通交换机名称
    private final static String NORMAL_EXCHANGE = "normal_exchange";
    //声明死信交换机名称
    private final static String DEAD_EXCHANGE = "dead_exchange";

    //声明普通队列名称
    private final static String NORMAL_QUEUE = "normal_queue";
    //声明死信队列名称
    private final static String DEAD_QUEUE = "dead_queue";

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

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

        //正常队列绑定死信队列信息，因为正常队列消息会变为死信
        Map<String, Object> arguments = new HashMap<>();
        //正常队列设置死信交换机 参数 key 是固定值
        arguments.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //正常队列设置死信 routing-key 参数 key 是固定值
        arguments.put("x-dead-letter-routing-key", "lisi");
        //设置正常队列的长度限制，总共发送10条数据，超出6条以外的数据就进入死信队列
        //arguments.put("x-max-length",6);
        //设置过期时间 10s,可以在消费者正常队列处设置，也可以在生产者发送处设置
        //map.put("x-message-ttl",100000);

        //声明死信和普通队列
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,arguments);
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //绑定普通的交换机和队列，交换机使用 路由key（routingKey） 和队列绑定
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"zhangsan");
        //绑定死信的交换机和死信队列，和路由key
        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("Consumer1 accept message is: "+ msg +"this message was rejected");
                /**
                 * 信道拒绝
                 * 1、消息的 标志号
                 * 2、false 代表不放回到正常队列，那就成了死信
                 */
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else {
                System.out.println("Consumer1 accept message is: " + msg);
                /**
                 * 手动应答
                 * 1、消息标志号
                 * 2、false 代表不批量应答
                 * 3、接收消息时 要同步改为 false，代表 手动应答
                 */
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }
        };

        CancelCallback cancelCallback = (consumerTag)->{

        };
        //采用手动应答,默认是自动true
        //boolean autoAck = false;
        //接收消息
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,cancelCallback);
    }
}

生产者不变

public class Producer2 {

    //声明普通交换机名称
    private final static String NORMAL_EXCHANGE = "normal_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitMqUtils.getChannel();
        for (int i = 1; i < 11; i++) {
            String message = "info" + i;
            /**
             * 发送消息
             * 1、交换机名称
             * 2、路由key routingKey
             * 3、是否持久化消息
             * 4、消息
             */
            channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",null,message.getBytes());
            System.out.println("生产者发送消息:"+message);
        }
    }
}

消费者2不变

/**
 * 消费者2只负责 接收私信队列的消息
 */
public class Consumer02 {

    //声明普通队列名称
    private final static String DEAD_QUEUE = "dead_queue";

    public static void main(String[] args) throws Exception {
        //创建信道
        Channel channel = RabbitMqUtils.getChannel();
        System.out.println("等待接收消息");

        DeliverCallback deliverCallback = (consumerTag, message)->{
            System.out.println("Consumer2 accept message is: "+ new String(message.getBody(),"UTF-8"));
        };

        CancelCallback cancelCallback = (consumerTag)->{

        };
        //接收消息
        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback);
    }
}

测试

发送10条数据，9条被消费，1条进入死信队列
在这里插入图片描述

廉小雨
关注
springboot整合rabbitmq使用死信队列
11-06
在这个场景中，我们将重点讨论如何在Spring Boot中整合RabbitMQ，并利用死信队列（Dead-Letter Queue，DLQ）来处理异常消息。 首先，我们需要在Spring Boot项目中引入RabbitMQ的相关依赖。在`pom.xml`文件中，添加...
死信队列详解
DevCorner的Pro技术博客
06-07 7792
在消息队列中，执行异步任务时，通常是将消息生产者发布的消息存储在队列中，由消费者从队列中获取并处理这些消息。但是，在某些情况下，消息可能无法正常地被处理和消耗，例如：格式错误、设备故障等，这些未成功处理的消息就被称为“死信”。为了避免这些未成功处理的消息导致程序异常或对系统造成影响，我们需要使用死信队列当我们设置死信队列后，所有无法成功处理的消息将被捕获并重定向到指定的死信交换机中。消费者可以从该交换机中读取并处理这些“死信”。
死信队列
qq_43644198的博客
11-18 2万+
死信队列 什么是死信队列 一般来说，producer将消息投递到queue中，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信(Dead Letter)，所有的死信都会放到死信队列中。 “死信”消息会被RabbitMQ进行特殊处理，如果配置了死信队列信息，那么该消息将会被丢进死信队列中，如果没有配置，则该消息将会被丢弃。 消费者消费消息 ​ 1)正常消费–>手动ack–>MQ从队列中删除消息
Rabbitmq中的死信队列
最新发布
你我约定有三的博客
08-03 1212
消息投递到MQ中存放 消息已经过期 消费者没有及时的获取到我们消息，消息如果存放到mq服务器中过期之后，会转移到备胎死信队列存放。2.如果生产者投递消息到普通队列中，普通队列发现该消息一直没有被消费者消费。的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机。的情况下，在这时候会将该消息转移到死信（备胎）交换机中，死信（备胎）交换机。普通队列中缓存起来，普通队列对应有自己独立普通消费者。普通队列中缓存起来，普通队列对应有自己独立普通消费者。死信队列和普通队列区别不是很大。
RabbitMQ死信队列
热门推荐
半桶水的博客
04-28 2万+
目录 一、死信队列是什么 二、如何配置死信队列 三、死信消息的变化 四、死信队列应用场景 五、总结 RabbitMQ是流行的开源消息队列系统，使用erlang语言开发，由于其社区活跃度高，维护更新较快，性能稳定，深得很多企业的欢心（当然，也包括我现在所在公司【手动滑稽】）。 为了保证订单业务的消息数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中。但由于对死信队列的概念及配置不熟悉，导致曾一度陷入百度的汪洋大海，无法自拔，很多文章都看起来可行，但
Rabbitmq死信队列
Rk的博客
10-12 5674
死信队列俗称，备胎队列；消息中间件因为某种原因拒收该消息后，可以转移到死信队列中存放，死信队列也可以有交换机和路由key等。消费者在消费生产者生产的消息时发生了某些特殊情况（下文会说），导致消息无法被正常消费，存放这些未被消费的消息的队列即为死信队列。
RabbitMQ死信队列应用
长沙老码农
02-05 6613
目录 1、什么是死信队列 2、死信队列应用场景 3、延迟消息概念 3.1 消息的TTL（Time To Live） 3.2 死信交换器 3.3 延时队列 4、死信队列使用流程图 5、死信队列应用（管理控制台） 6、死信队列应用（Java代码） 6.1 RabbitMQ原生API 6.2 SpringBoot集成RabbitMQ 1、什么是死信队列 DLX, Dead-Letter-Exchange。利用DLX, 当消息在一个队列中因为业务队列处理失败(比如抛异常并且达到了re.
Spring RabbitMQ死信机制原理实例详解
08-24
在 Spring RabbitMQ 中，可以通过配置死信队列和死信交换机来实现死信机制。例如： ```java @Bean public Queue deadQueue() { return new Queue(DEAD_QUEUE_NAME, true); } @Bean public DirectExchange ...
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
六、死信队列
wang_luwei的博客
03-19 4170
文章目录死信队列1、死信的概念2、死信的来源3、死信实战3.1. 代码架构图3.2. 消息TTL 过期3.3. 队列达到最大长度3.4. 消息被拒 死信队列 1、死信的概念 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有
[MQ] 死信队列介绍与场景描述
沫洺的博客
11-20 2327
死信队列介绍与场景描述
RabbitMQ 之 死信队列
weixin_73616913的博客
05-27 3118
但是发生了上面所说的三种情况中的一种，成为了死信，然后被转换到死信交换机中，这个死信交换机也是 direct 类型，它们之间的 routingKey 是 "lisi",然后就进入了死信队列，死信队列由 C2 消费。生产者正常情况下走的是普通的交换机，这个交换机的类型是 direct ，它和普通队列之间的关系是一个叫 "zhangsan" 的路由 key， 正常情况下会被 C1 消费。应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息。，字面意思可以这样理。
【RabbitMQ笔记10】消息队列RabbitMQ之死信队列的介绍
✅ Java 开发工程师，从事 Web 应用程序的研发，擅长 Spring、SpringBoot 等技术。 ✅ 热爱编程，业余时间学习新知识，通过 CSDN 记录学习心得和笔记内容。
03-19 2801
在RabbitMQ中，并没有提供真正意义上的延迟队列，但是RabbitMQ可以设置队列、消息的过期时间，当队列或者消息到达过期时间之后，还没有被消费者消费，那么RabbitMQ会将这些消息放入另外一个队列，这个队列叫做：死信队列，而这个过期的消息就叫做：死信消息。哪些情况下，消息会变成死信消息？？？第一种情况：Queue队列已经满了，无法保存新进入的消息，那么这个消息就会被放入死信队列。第二种情况：队列中的消息被消费者拒绝消费了，并且没有设置重新放入Queue队列里面。
RabbitMQ（五）死信队列与延时队列
fox_bert的博客
06-11 2416
DLX，全称为 Dead-Letter-Exchange，可以称为死信交换机，也有人称之为死信邮箱，当消息在一个正常队列中变成死信（dead message）之后，它能被重新发送到另一个交换机中，这个交换机就是DLX，绑定DLX的队列就称之为死信队列。消息变成死信，可能由于以下原因：DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何队列上被指定。实际上就是设置某一个队列的属性，当这个队列中存在死信时，rabbitMQ就会自动的将这个消息重新发布到设置的DLX上去，进而被路由到另一个队列，即死信队
RabbitMQ中死信队列和延迟队列
Knight
03-30 2071
先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列；
RabbitMQ的死信队列和延时队列
DMaker1993的博客
12-26 3350
本文介绍并实战RabbitMQ的死信队列，以及通过RabbitMQ如何实现延时队列。
【RabbitMQ】死信（延迟队列）的使用
无法自律的人的博客
01-25 2401
持久化exchange要持久化queue要持久化message要持久化消息确认启动消费返回（@ReturnList注解，生产者就可以知道哪些消息没有发出去）生产者和Server（broker）之间的消息确认消费者和Server（broker）之间的消息确认。
SpringBoot整合RabbitMQ实现死信队列详解
"本文介绍了SpringBoot如何集成RabbitMQ并实现死信队列功能，通过具体的示例代码展示了配置和使用过程。" 在SpringBoot应用中集成RabbitMQ，可以利用其强大的消息中间件能力，提高系统的可靠性和可扩展性。死信队列...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值