Rabbitmq死信队列

最新推荐文章于 2024-04-27 17:24:55 发布
最新推荐文章于 2024-04-27 17:24:55 发布
阅读量342 收藏 3
点赞数 3
分类专栏： 微服务 文章标签： rabbitmq spring boot
原文链接：https://www.freesion.com/article/98691194274/
版权

Springboot与Rbbitmq整合

死信队列定义

消息中间件中的消息被拒绝时，它将被重新publish到另一个交换机上，这个交换机我们就叫做死信交换机，死信交换机将被拒绝的消息投递到一个队列上，该队列就是死信队列。死信队列和普通队列一样，有交换机和路由key。

在这里插入图片描述

产生死信队列的几种情况

  • 队列达到最大长度
  • 消息ttl过期
  • 消息被拒绝（basic.reject/ basic.nack）并且requeue=false

应答模式

应答模式分为两种，手动签收和自动签收，自动应答就是消费者消费了一条消息就自动告诉队列删除消息。这样的弊端就是不管消费逻辑有没有成功，都会将消息删除，这样就会造成消息丢失。而使用手动签收后，就是在消费逻辑处理完成后，手动告诉队列消费成功，然后队列移除该条消息。

开启手动应答模式

spring.rabbitmq.listener.simple.acknowledge-mode = manual

代码实现

  1. 新建项目springboot-rabbitmq，并引入pom依赖

      <dependency>
  	  <groupId>org.springframework.boot</groupId>
      <artifactId>spring-boot-starter-amqp</artifactId>
  </dependency>

  2. 在配置文件中添加rabbitmq相关配置

    spring:
    rabbitmq:
        host: 192.168.0.130
        username: guest
        password: guest
        virtual-host: test
        template:
            retry:
                enabled: true
        listener:
            simple:
                acknowledge-mode: manual
                default-requeue-rejected: false
            type: simple
        publisher-returns: true
        publisher-confirm-type: correlated

    配置参数：

     1. rabbitmq.publisher-confirm-type=correlated
    # NONE 值是禁用发布确认模式，是默认值;
    # CORRELATED 值是发布消息成功到交换机后会触发回调方法;
    # SIMPLE 值有两种结果，其一效果和 CORRELATED 值一样会触发回调方法，其二在发布消息成功后
     	使用rabbitTemplate调用waitForConfirms或waitForConfirmsOrDie方法等待节点返回发送结果
   		根据返回结果来判定下一步的逻辑，要注意的点是waitForConfirmsOrDie 方法如果返回false 则会关闭channel，则接下来无法发送消息到broker;
 2. rabbitmq.publisher-returns=true
	Return 消息机制用于处理一个不可路由的消息。在某些情况下，
	如果我们在发送消息的是否，当前的 exchange 不存在或者指定路由 key 路由找不到，
	这个时候需要使用 Return 来监听这种不可达的消息。
 3.  rabbitmq.listener.simple.acknowledge-mode=manual
	开启手动应答
 4. rabbitmq.template.retry.enabled=true
 	是否开启重试
 5. rabbitmq.listener.simple.default-requeue-rejected=false
	值为false，如果达到重试次数上限，将消息放入到死信队列中

  3. 创建rabbitmq配置文件

    import com.lee.constants.RabbitConstants;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

//配置队列信息
@Configuration
public class RabbitQueueConfig {

    //队列过期时间
    private int orderQueueTTL = 3000;

    // 配置普通队列
    @Bean
    public Queue orderQueue() {
        Map<String,Object> deadParamsMap = new HashMap<String, Object>();
        // 设置死信队列的Exchange
        deadParamsMap.put("x-dead-letter-exchange",RabbitConstants.DEAD_EXCHANGE);
        //设置死信队列的RouteKey
        deadParamsMap.put("x-dead-letter-routing-key",RabbitConstants.DEAD_ROUTE_KEY);
        // 设置对接过期时间"x-message-ttl"
//        deadParamsMap.put("x-message-ttl",orderQueueTTL);
        // 设置对接可以存储的最大消息数量
        deadParamsMap.put("x-max-length",20);
//        return QueueBuilder.durable(RabbitConstants.ORDER_QUEUE)
//                .withArguments(deadParamsMap)
//                .build();
        return new Queue(RabbitConstants.ORDER_QUEUE,true,false,false,deadParamsMap);
    }

    // 普通交换机
    @Bean
    public TopicExchange orderTopicExchange() {
        return new TopicExchange(RabbitConstants.ORDER_EXCHANGE);
    }

    // 绑定
    @Bean
    public Binding orderBinding() {
        return BindingBuilder.bind(orderQueue())
                .to(orderTopicExchange())
                .with(RabbitConstants.ORDER_ROUTE_KEY);
    }

    //配置死信队列
    @Bean
    public Queue deadQueue() {
//        return QueueBuilder.durable(RabbitConstants.DEAD_QUEUE)
                .withArguments(deadParamsMap)
//                .build();
        return new Queue(RabbitConstants.DEAD_QUEUE);
    }

    // 死信交换机
    @Bean
    public DirectExchange deadExchange() {
        return new DirectExchange(RabbitConstants.DEAD_EXCHANGE);
    }

    // 死信  绑定
    @Bean
    public Binding deadBinding() {
        return BindingBuilder.bind(deadQueue())
                .to(deadExchange())
                .with(RabbitConstants.DEAD_ROUTE_KEY);
    }
}

  4. 常量类定义

    //定义个常量类
public class RabbitConstants {

    //订单队列
    public static final String ORDER_ROUTE_KEY = "order_route_key2";
    public static final String ORDER_EXCHANGE = "order_exchange2";
    public static final String ORDER_QUEUE = "order_queue_test2";

    //死信队列
    public static final String DEAD_QUEUE = "dead_queue2";
    public static final String DEAD_EXCHANGE = "dead_exchange2";
    public static final String DEAD_ROUTE_KEY = "dead_route_key2";
}

  5. 测试Service
    模式发送500个消息，队列大小为20

    @Service
public class OrderProducerService implements RabbitTemplate.ConfirmCallback,RabbitTemplate.ReturnCallback {

    @Autowired
    private RabbitTemplate rabbitTemplate ;


    @PostConstruct
    public void setCallback() throws InterruptedException {
        // 设置返回回调
        rabbitTemplate.setReturnCallback(this);
        // 设置确认回调
        rabbitTemplate.setConfirmCallback(this);
        // 模拟消息发送
//        Runnable runnable = new Runnable() {
//            public void run() {
//                send("这是我发送的测试消息，测试id="+ UUID.randomUUID().toString());
//            }
//        };
//        ScheduledExecutorService scheduledExecutorService = Executors.newScheduledThreadPool(1);
//        scheduledExecutorService.scheduleAtFixedRate(runnable,20,5, TimeUnit.SECONDS);
        for (int x=0;x<500;x++) {
            Thread.sleep(100);
            send("这是我发送的测试消息，测试id="+ UUID.randomUUID().toString());
        }
    }

    private void send(String message) {
        CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
        rabbitTemplate.convertAndSend(RabbitConstants.ORDER_EXCHANGE, RabbitConstants.ORDER_ROUTE_KEY, message, correlationData);
    }

    /**
     * 回调确认消息是否发送成功  confirm机制只保证消息到达交换机，不保证消息可以路由到正确的queue，如果交换机错误，就会触发confirm机制
     * @param correlationData
     * @param ack
     * @param s
     */
    public void confirm(CorrelationData correlationData, boolean ack, String s) {
        System.out.println("消息发送成功,发送ack确认,id="+correlationData.getId());
        if (ack){
            System.out.println("发送成功");
        }else {
            System.out.println("发送失败");
        }
    }

    /**
     *  Return 消息机制用于处理一个不可路由的消息。在某些情况下，如果我们在发送消息的是否，当前的 exchange 不存在或者指定路由 key 路由找不到，
     *      *  这个时候需要使用 Return 来监听这种不可达的消息
     * @param message
     * @param replyCode
     * @param replyText
     * @param exchange
     * @param routingKey
     */
    public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
        System.out.println("消息丢失, 没有投递成功");
    }

    // 监听死信队列
    @RabbitListener(bindings = @QueueBinding(value = @Queue(value = RabbitConstants.DEAD_QUEUE),exchange = @Exchange(value = RabbitConstants.DEAD_EXCHANGE),
            key = RabbitConstants.DEAD_ROUTE_KEY))
    public void deadQueueListener(Message message, Channel channel) throws InterruptedException, IOException {
        System.out.println("死信队列");
        String receivedRoutingKey = message.getMessageProperties().getReceivedRoutingKey();
        String msg = new String(message.getBody());
        System.out.println("路由key= [ "+receivedRoutingKey+" ]接收到的消息= [ "+msg +" ]");
        //Thread.sleep(5000);
        // 发送ack给消息队列，收到消息了
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);

    }

    // 监听订单队列
    @RabbitListener(queues = RabbitConstants.ORDER_QUEUE)
    public void orderQueueListener(Message message, Channel channel) throws IOException, InterruptedException {
        System.out.println("正常队列");
        String receivedRoutingKey = message.getMessageProperties().getReceivedRoutingKey();
        String msg = new String(message.getBody());
        System.out.println("路由key= [ "+receivedRoutingKey+" ]接收到的消息= [ "+msg +" ]");
        // 休眠 当队列消息ttl达到5000时，交由死信队列
        Thread.sleep(1000);
        //发送ack给消息队列,收到消息了
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
    }
}

  6. 测试请求

    Rabbitmq控制台
    在这里插入图片描述
    业务控制台消费
    在这里插入图片描述

参考文章链接：
https://www.freesion.com/article/98691194274/
https://segmentfault.com/a/1190000022109462

项目地址：spring-cloud-nacos

陆小叁
关注
  • 3
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
【ASP.NET编程知识】运用.NetCore实例讲解RabbitMQ死信队列,延时队列.docx
05-21
【ASP.NET编程知识】运用.NetCore实例讲解RabbitMQ死信队列,延时队列.docx
RabbitMQ死信队列应用1
08-03
1、什么是死信队列 2、死信队列应用场景 3、延迟消息概念 4、死信队列使用流程图 5、死信队列应用（管理控制台） 6、死信队列应用（Java代码）
RabbitMQ笔记（四）SpringBoot整合RabbitMQ之死信队列详细使用
嘉禾嘉宁papa
09-24 5190
目录一、简介二、Maven依赖三、消息确认3.1 消息发布确认ConfirmCallback3.2 消息到达确认ReturnsCallback四、核心配置类五、配置文件六、测试类TestProductService结语 一、简介   本文主要用使用Spring Boot（2.5.2）来整合RabbitMQ（2.5.2），使用simple容器实现一个生产者。本文的前提是有一个安装好的RabbitMQ的环境，及我的上一篇文章里消费者服务：   链接: RabbitMQ笔记（一）SpringBoot整合Rabbi
Rabbitmq死信队列详解
我还可以
06-19 2392
死信，顾名思义就是无法被消费的消息。一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费；这样的消息如果没有后续的处理，就变成了死信，接收死信消息的队列就叫死信队列；一个消息如果满足下列条件之一，会进入到死信路由(注意是路由，不是队列，一个路由可以对应多个队列)：一旦某个队列中有消息满足了成为死信的条件，如果该队列设置了死信交换机(Dead Letter Exchange)和死信
支付状态一致性-RabbitMQ死信队列
03-19
支付状态一致性-RabbitMQ死信队列
rabbitmq的死信队列
weixin_42132143的博客
07-03 328
死信队列的概念： 用来存放变成死信的消息的队列 死信产生的途径： 消息被否定确认，使用 channel.basicNack 或 channel.basicReject ，并且此时requeue 属性被设置为false。 消息在队列的存活时间超过设置的TTL时间 消息队列的消息数量已经超过最大队列长度 如何配置死信队列 配置业务队列，绑定到业务交换机上 为业务队列配置死信交换机和路由key 为死信交换机配置死信队列 在需要使用死信的业务队列中配置一个死信交换机，这里同一个项目的死信交换机可以
Rabbit @RabbitListener消息队列注解
热门推荐
旭旭1998的博客
04-14 4万+
@RabbitListener(bindings = @QueueBinding( value = @Queue(value = queueName, durable = "true", ignoreDeclarationExceptions = "true"), exchange = @Exchange(value = EventConfig.exchangeGR, type = ExchangeTypes.FANOUT, durable = "true")
@RabbitListener的作用详解
IsAmant的博客
04-13 2895
@RabbitListener注解
RabbitMQ实现死信队列
lianaozhe的博客
02-27 1532
死信队列其实并没有什么神秘的地方，不过是绑定在死信交换机上的普通队列，而死信交换机也只是一个普通的交换机，不过是用来专门处理死信的交换机。业务消息被投入业务队列消费者消费业务队列的消息，由于处理过程中发生异常，于是进行了nck或者reject操作被nck或reject的消息由RabbitMQ投递到死信交换机中死信交换机将消息投入相应的死信队列死信队列的消费者消费死信消息本篇文章到此结束！希望对您有所帮助。
【RabbitMQ】@RabbitListener的使用及造成报错死循环的分析
chenghan_yang的博客
02-10 1万+
问题复现： docker 下清空对应的队列信息 exec rabbitmq /bin/bash #rabbitmq是容器名，也可以指定为Id rabbitmqctl purge_queue queue.order # queue.order是队列名 RabbitMQ控制台新建消息，等待消费者消费 http://localhost:15672 前置知识： 一、 @RabbitListener的使...
rabbitMQ 死信队列 完整例子
03-19
rabbitMQ 死信队列 完整例子
Spring RabbitMQ死信机制原理实例详解
08-24
主要介绍了Spring RabbitMQ死信机制原理实例详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
spring boot 整合rabbit mq 死信队列
m0_37723564的博客
04-14 2193
前言 在电商开发中我们经常会遇到这样的一些功能需求。例如，当一个订单在30分钟后未支付就需要关闭这个订单；当一个订单7天后用户没有点击确认收货，就系统自动确认。我们可以把这类任务归纳为是一个系统事件，通过触发某个时间条件来执行该事件。我们可以先抛开rabbitmq这个中间件，思考下应该如何设计这个任务。 首先这些事件的触发不应该影响我们的主流程，比如用户生成了订单，但是即使用户不支付，他依然可以去做别的事情，比如浏览商品或者参与其它促销活动。也就是这类事件相对于我们的用户主线程它是独立的，非阻塞的，异步的。
rabbitmq 死信队列的使用方式
怵生的博客
02-01 1万+
一.代码+配置 1.首先建立一个队列，标示为死信队列 Connection connection = connectionFactory.newConnection(); Channel channel = connection.createChannel(); channel.exchangeDeclare("some.exchange.name", "direct"); Map args
消息中间件之RabbitMQ（三）：死信队列和延迟队列
1周是1年的2%
03-23 1987
dead queue
RabbitMQ 死信队列实现
weixin_46058921的博客
05-04 1316
➢ 使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到 queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。消息的可靠投递小结 ➢ 设置ConnectionFactory的publisher-confirms=“true” 开启 确认模式。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。明天在研究下回调啥的。
SpringBoot RabbitMQ 死信队列
天行健，君子以自强不息；地势坤，君子以厚德载物。
04-27 1119
1. 死信定义无法被消费的消息，称为死信。如果死信一直留在队列中，会导致一直被消费，却从不消费成功，专门有一个存放死信的队列，称为死信队列(DDX, dead-letter-exchange)。死信队列DLX，Dead Letter Exchange的缩写，又死信邮箱、死信交换机。其实DLX就是一个普通的交换机，和一般的交换机没有任何区别。当消息在一个队列中变成死信（dead message）时，...
rabbitmq死信队列详解（亲手实践）
爪哇人的博客
06-04 3241
因为在声明普通队列的时候，已经说明了队列最大长度为5，那么多余的消息就会根据配置的参数找到对应的交换机进而找到对应的路由，然后路由到对应的队列（死信队列）。死信队列其实和普通的队列一样，只不过里面存放的消息都是普通队列过期没有消费的。以上只是声明了一个普通队列queueB，然后在该队列设置了过期时间40s，和死信交换机和死信路由key。死信队列就是一个普通的队列，只不过声明普通队列的时候指定了死信交换机，二者才产生了联系。可以发现，发送给普通队列的消息，超时没有被消费，都进入到了死信队列中。
RabbitMq基础概念知识复习
最新发布
m0_72363694的博客
04-27 369
消息拥有消息头和消息体，消息具有rounting key，主题交换机和扇形交换机都是分布与订阅的实现方式，主题交换机用于匹配接收的消息的rount key 动态匹配模式匹配到多个符合的队列，扇形fanout交换机则不会使用消息的路由key，即便在绑定队列的时候指定了Routing key，也不会有任何效果，它会向所有绑定到当前交换机的 队列广播消息，该交换机绑定队列的时候所有的rounting key为空，这样所有被绑定的队列都能收到交换机的消息，实现广播功能。4 rabbitMq应用场景，异步！
RabbitMQ 死信队列
09-14
RabbitMQ 死信队列是指当消息在队列中无法被正常消费时，将被发送到特定的队列中进行处理的机制。这种情况可能发生在以下几种情况下： 1. 消息被拒绝（reject）并且设置了重新入队（requeue=false）的情况下。 2. ...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值