RabbitMQ 高级特性——过期时间加死信队列实现延迟队列

最新推荐文章于 2024-07-17 11:24:51 发布
最新推荐文章于 2024-07-17 11:24:51 发布
阅读量947 收藏 2
点赞数 1
分类专栏： rabbitmq 文章标签： 队列 rabbitmq java spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cj_eryue/article/details/113185191
版权

目录

1.过期时间 TTL 

2.死信队列/死信交换机

2.1过期消息

2.2 消息数量达到最大限制

2.3 消费者拒收消息

3.延迟队列（重点）

1.过期时间 TTL 

TTL：time to live（存活时间/过期时间）

当消息到达存活时间后，还没有被消费，就会被自动清除；

过期时间可以对整队列设置，也可以对消息单独进行设置（如果同时设置了队列和消息的过期时间，以时间短的为准，队列过期时间到了之后，会将消息都移除 消息到达过期时间之后，只有在队列顶端的消息，才会判断是否需要移除（提高时间过期的效率））

配置：

队列的过期时间设为15s

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:/rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"
                               publisher-confirms="true"
                               publisher-returns="true" />
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>
    <!--定义rabbitTemple对象-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

    <!--ttl-->
    <rabbit:queue id="spring_queue_ttl" name="spring_queue_ttl" auto-delete="true">
    <!--设置queue的参数-->
        <rabbit:queue-arguments>
            <entry key="x-message-ttl" value="15000" value-type="java.lang.Integer"/>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <rabbit:topic-exchange name="spring_ttl_exchange" id="spring_ttl_exchange" >
        <rabbit:bindings>
            <rabbit:binding pattern="ttl.#" queue="spring_queue_ttl"/>
        </rabbit:bindings>
    </rabbit:topic-exchange>

</beans>

生产者代码：

将消息的过期时间设为5s

 /**
     * ttl 过期时间
     *      1.队列统一过期
     *      2.消息单独过期
     *
     *      如果同时设置了队列和消息的过期时间，以时间短的为准，队列过期时间到了之后，会将消息都移除
     *
     *      消息到达过其实是那之后，只有在队列顶端的消息，才会判断是否需要移除（提高时间过期的效率）
     */
@Test
    public void testTtl(){
        /*for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("spring_ttl_exchange", "ttl.test", "message ttl test ");
        }*/

        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            //消息的后置处理器，设置消息的一些参数信息
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setExpiration("5000");
                return message;
            }
        };
    
        
        for (int i = 0; i < 10; i++) {
            if(i==5) {
                rabbitTemplate.convertAndSend("spring_ttl_exchange", "ttl.test", "message ttl test",
                    messagePostProcessor);
            }else{
                rabbitTemplate.convertAndSend("spring_ttl_exchange", "ttl.test", "message ttl test ");
            }

        }  });
        }
    }

运行结果为：

  1. 如果消息不设置过期时间，消息会在队列中待15s；
  2. 如果消息设置了过期时间，消息在队列中待了5s后，就被移除了；
  3. 如果对单个消息设置了过期时间，只有当消息到达过期时间之后，且该消息在队列顶端的消息，才会被移除

2.死信队列/死信交换机

英文Dead Letter Exchange，当消息成为死信消息后，可以被重新发送到另一个交换机，这个交换机就是DLX。

消息成为死信有三种种方式：

  1. 消息到达过期时间 TTL；
  2. 消息数量达到最大限制；
  3. 消费者拒收消息，使用channel.basicNack/basicReject，并且不把消息重新放回原队列，即requeue=false.

我们来实践一下：

生产端队列以及交换机的配置

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:/rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"
                               publisher-confirms="true"
                               publisher-returns="true" />
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>
    <!--定义rabbitTemple对象-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

    <!--死信队列 -->
    <!--1声明正常的队列 spring_queue_dlx 和交换机 spring_exchange_dlx-->
    <!--2声明死信队列queue_dlx和死信交换机exchange_dlx-->
    <!--3正常队列绑定死信交换机
      设置两个参数：x-dead-letter-exchange：死信交换机名称
                x-dead-letter-routing-key：发送给死信交换机的路由key
    -->
    <!--4消息如何成为死信？   ①消息过期 ②消息数量到达最大限度③消费者拒收消息-->
    <!--1-->
    <rabbit:queue id="spring_queue_dlx" name="spring_queue_dlx" auto-delete="true">
        <!--3-->
        <rabbit:queue-arguments>
            <!--3.1 设置x-dead-letter-exchange-->
            <entry key="x-dead-letter-exchange" value="exchange_dlx"></entry>
            <!--3.1 设置x-dead-letter-routing-key-->
            <entry key="x-dead-letter-routing-key" value="dlx.test"></entry>

            <!--4.1设置消息的过期时间-->
            <entry key="x-message-ttl" value="15000" value-type="java.lang.Integer"/>
            <!--4.2设置队列的长度-->
            <entry key="x-max-length" value="10" value-type="java.lang.Integer"/>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <rabbit:topic-exchange name="spring_exchange_dlx" id="spring_exchange_dlx" >
        <rabbit:bindings>
            <rabbit:binding queue="spring_queue_dlx" pattern="test.dlx.#"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>
    <!--2-->
    <rabbit:queue id="queue_dlx" name="queue_dlx" auto-delete="true"/>
    <rabbit:topic-exchange name="exchange_dlx" id="exchange_dlx" >
        <rabbit:bindings>
            <rabbit:binding queue="queue_dlx" pattern="dlx.#"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>
</beans>

测试：

2.1过期消息

消息的过期时间我们设置了15s

<!--4.1设置消息的过期时间-->
<entry key="x-message-ttl" value="15000" value-type="java.lang.Integer"/>

@Test
    public void testDlx(){
        //1.测试过期消息
        rabbitTemplate.convertAndSend("spring_exchange_dlx", "test.dlx.test", "message dlx test ");
    }

发送消息后，可见，正常队列spring_queue_dlx接收到一条消息，死信队列queue_dlx暂时无数据 

15s后，正常队列里的消息达到过期时间，消息被发送到死信交换机：

2.2 消息数量达到最大限制

正常的消息队列最大数量我们设置了10条

<!--4.2设置队列的长度-->
<entry key="x-max-length" value="10" value-type="java.lang.Integer"/>

 @Test
    public void testDlx(){
        //2.测试消息最大数量
        for (int i = 0; i < 20; i++) {
            rabbitTemplate.convertAndSend("spring_exchange_dlx", "test.dlx.test", "message dlx test ");
        }
    }

发送消息后，15s内正常队列里面应该有10条数据，死信队列里面应该有11条数据（2.1中的测试导致死信队列中已有一条数据）

15s后，正常队列里没有消息，死信队列中应该有21条数据：

2.3 消费者拒收消息

消费者配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <bean id = "DlxListener" class="com.cjian.rabbitmq.spring_rabbit.DlxListener"/>
    <!--绑定监听器与队列的关系-->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true" acknowledge="manual" prefetch="5">
        <rabbit:listener ref="DlxListener" queue-names="spring_queue_dlx"/>
    </rabbit:listener-container>

</beans>

消费者代码：

package com.cjian.rabbitmq.spring_rabbit;

import com.rabbitmq.client.Channel;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;

import java.util.Date;

/**
 * @description: 消费者拒收消息，让消息进入死信队列
 *
 * @author: CJ
 * @time: 2021/1/27 10:05
 */
public class DlxListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //接收消息
            System.out.println(new String(message.getBody()));
            //处理业务逻辑
            //Thread.sleep(1000);
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            System.out.println("消费消息出现异常,拒绝接收");
            //拒绝签收
            //requeue参数的意思为是否重回队列
            channel.basicNack(deliveryTag,true,false);
            //使用这个也可以
            //channel.basicReject(deliveryTag,false);
            //或者这个
            //channel.basicRecover(false);
        }
    }
}

我们让生产者发送一条消息后，消费者消费出现异常，消息被移到死信队列

 

3.延迟队列（重点）

消息进入队列后不会立即被消费，只有达到指定时间后才会被消费

 

很可惜，rabbitmq并没有提供延迟队列的功能，但是经过上面的学习，我们可以利用TTL+DLX去实现

测试：

生产者配置：

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:/rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"
                               publisher-confirms="true"
                               publisher-returns="true" />
    <!--定义管理交换机、队列-->
    <rabbit:admin connection-factory="connectionFactory"/>
    <!--定义rabbitTemple对象-->
    <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

    <!--延迟队列
    1.定义正常的交换机order_exchange和队列 order_queue
    2.定义死信交换机order_exchange_dlx和队列order_queue_dlx
    3.绑定，设置正常队列的过期时间
    -->
    <!--1.定义正常的交换机order_exchange和队列 order_queue-->
    <rabbit:queue id="order_queue" name ="order_queue">
        <!--3.绑定，设置正常队列的过期时间-->
        <rabbit:queue-arguments>
            <entry key="x-dead-letter-exchange" value="order_exchange_dlx"></entry>
            <entry key="x-dead-letter-routing-key" value="order.dlx.cancel"></entry>
            <entry key="x-message-ttl" value="15000" value-type="java.lang.Integer"/>
        </rabbit:queue-arguments>
    </rabbit:queue>
    <rabbit:topic-exchange id="order_exchange" name="order_exchange">
        <rabbit:bindings>
            <rabbit:binding pattern="order.#" queue="order_queue"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>

    <!--2.定义死信交换机order_exchange_dlx和队列order_queue_dlx-->
    <rabbit:queue id="order_queue_dlx" name ="order_queue_dlx"></rabbit:queue>
    <rabbit:topic-exchange id="order_exchange_dlx" name="order_exchange_dlx">
        <rabbit:bindings>
            <rabbit:binding pattern="order.dlx.#" queue="order_queue_dlx"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>
</beans>

生产者代码：

 @Test
    public void testDelay(){
        rabbitTemplate.convertAndSend("order_exchange", "order.msg", "delay message test ");
        System.out.println("消息发送成功:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
    }

 消费者配置：

<?xml version="1.0" encoding="UTF-8"?>
<!--
  ~ Copyright (c) Huawei Technologies Co., Ltd. 2019-2021. All rights reserved.
  -->

<beans xmlns="http://www.springframework.org/schema/beans"
       xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
       xmlns:context="http://www.springframework.org/schema/context"
       xmlns:rabbit="http://www.springframework.org/schema/rabbit"
       xsi:schemaLocation="http://www.springframework.org/schema/beans
       http://www.springframework.org/schema/beans/spring-beans.xsd
       http://www.springframework.org/schema/context
       https://www.springframework.org/schema/context/spring-context.xsd
       http://www.springframework.org/schema/rabbit
       http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
    <!--加载配置文件-->
    <context:property-placeholder location="classpath:rabbitmq.properties"/>

    <!-- 定义rabbitmq connectionFactory -->
    <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                               port="${rabbitmq.port}"
                               username="${rabbitmq.username}"
                               password="${rabbitmq.password}"
                               virtual-host="${rabbitmq.virtual-host}"/>

    <bean id = "delayListener" class="com.cjian.rabbitmq.spring_rabbit.DelayListener"/>
    <!--绑定监听器与队列的关系-->
    <rabbit:listener-container connection-factory="connectionFactory" auto-declare="true" acknowledge="manual" prefetch="5">
        <rabbit:listener ref="delayListener" queue-names="order_queue_dlx"/>
       
    </rabbit:listener-container>

</beans>

消费者代码：

package com.cjian.rabbitmq.spring_rabbit;

import com.rabbitmq.client.Channel;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;

import java.text.SimpleDateFormat;
import java.util.Date;

/**
 * @description: 延迟队列测试
 *
 * @author: CJ
 * @time: 2021/1/27 11:00
 */
public class DelayListener implements ChannelAwareMessageListener {
    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            //接收消息
            System.out.println("消息接收成功:"+new SimpleDateFormat("yyyy-MM-dd HH:mm:ss").format(new Date()));
            System.out.println(new String(message.getBody()));
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            System.out.println("消费消息出现异常,拒绝接收");
            //拒绝签收
            //requeue参数的意思为是否重回队列
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

先让队列和交换机都创建成功（可以启动生产者，不发送任何消息），然后我们启动消费者，以便后面观察：

这里order_queue_dlx死信队列已被消费者绑定：

生产者发送消息：

消息首先进入正常的队列，15s后进入死信队列，然后立即被消费：

消费者消费日志：

cj_eryue
关注
专栏目录
RabbitMQ延迟队列的实现——TTL+死信队列DLX
保暖透气大裤衩LeoLee的博客
11-08 506
大伙可以到我的RabbitMQ专栏获取更多信息 demo示例这里拿 概述 什么是延迟队列 延迟队列，即消息到达队列后不会被立即消费，只有到达指定的时间后，才会被消费 场景： 下单后，30分钟为结算，自动取消该订单，被锁商品重回库存 新用户注册1小时之后，发短信问候 实现方式： 定时器：以某个时间间隔去轮询订单表中的下单时间并于当前时间比对，超过30分钟就取消该订单。该方式不优雅，性能消耗大，数据库压力大。 MQ延迟队列：当用户下单之后，订单生成，就发送一条消息到MQ延迟队列，该消息30分钟
rabbitmq通过死信队列实现延迟任务——java
qq_45735918的博客
07-29 379
很多场景下都需要延迟任务，比如一笔订单50分钟后还没支付则过期，发出去的红包24小时后未领取则自动过期，合同第一次签署失败后20秒后再尝试签署一次。。。。 本博客介绍如何使用rabbitmq通过死信队列实现延迟任务。 首先是配置rabbitmq环境，关于如何配置与mq的各种参数详解，请移步https://blog.csdn.net/echizao1839/article/details/105533214 当配置好以后，我们需要创建一个配置类，方便我们管理交换机与队列 @Configuration publ
RabbitMQ实现延迟队列
weixin_42324471的博客
03-08 3753
实现方式一：死信队列 AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是可以通过以下特性模拟出延迟队列的功能。 但是我们可以通过RabbitMQ的两个特性来曲线实现延迟队列： 1、Time To Live(TTL) RabbitMQ可以针对Queue设置x-expires 或者 针对Message设置 x-message-ttl，来控制消息的生存时间，如果超时(两者同时设置以最先到期的时间为准)，则消息变为dead letter(死信) RabbitMQ针对队列中的消息过期时间有两种方法可
RabbitMQ实现延迟任务
fangye1的博客
09-03 366
死信队列&死信交换器 死信消息： 消息被拒绝（Basic.Reject或Basic.Nack）并且设置 requeue 参数的值为 false 消息过期了 队列达到最大的长度 消息过期：在 rabbitmq 中存在2种方可设置消息的过期时间，第一种通过对队列进行设置，这种设置后，该队列中所有的消息都存在相同的过期时间，第二种通过对消息本身进行设置，那么每条消息的过期时间都不一样。如果同时使用这2种方法，那么以过期时间小的那个数值为准。当消息达到过期时间还没有被消费，那么那个消息就成为了一个 死信
MQ四兄弟：如何实现延时消息
最新发布
Hanko的专栏
07-17 833
RabbitMQ 本身并没有直接支持延时消息的功能，但是可以通过使用 RabbitMQ 插件或构建消息死信队列（Dead Letter Exchange, DLX）的方式来实现延时消息。RocketMQ 通过设置消息的 定时消息和延时消息本质相同，都是服务端根据消息设置的定时时间在某一固定时刻将消息投递给消费者消费。可以看到RocketMQ 5.x已经更新了延时消息的实现，在官方文档可以看到已经改成定时、延时消息，原本4.x文档中的延时级别对照表已经去掉了，统一成时间戳的实现。属性来发送延时消息。
RabbitMQ通过死信队列实现延迟消息
weixin_44330810的博客
01-20 1817
RabbitMQ通过死信队列实现延迟消息
利用rabbitMq的死信队列实现延时消息
奔跑的菜鸡
10-19 1925
mq死信队列
RabbitMQ设置消息和队列过期时间（五）
qq_25453181的博客
07-29 3244
设置消息过期时间 RabbitMQ设置消息的过期时间有两种方式：在队列设置所有消息的过期时间；发送消息的时候设置单个消息的过期时间，每条消息的TTL可以不同。如果两种方式同时使用则以最小时间为准。 通过队列设置TTL 通过队列设置消息TTL的方法时在channel.queueDeclare的时候添加x-message-ttl参数实现，单位毫秒。 Map<String,Object> map = new HashMap&lt...
浅谈RabbitMQ——死信队列与延迟队列
tanning11627的博客
05-25 322
死信队列 引言 死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），其实应该叫做死信交换机才更恰当。 当消息成为Dead message后，可以被重新发送到另一个交换机，这个交换机就是DLX。 总结：其实死信队列就是一个普通的交换机，有些队列的消息成为死信后，（比如过期了或者队列满了）这些死信一般情况下是会被 RabbitMQ 清理的。但是你可以配置某个交换机为此队列的死信交换机，该队列的消息成为死信后会被重新发送到此 DLX 。至于怎么处理这个DLX中的死信就是看具体
RabbitMQ中的高级队列特性：死信队列
它是一个在AMQP协议的基础上构建的消息队列，通过提供标准的消息传递功能来实现不同应用系统之间的通信。RabbitMQ提供了高度灵活的路由机制、消息确认、复制、持久化、灵活的分布式部署以及内容感知。它被广泛应用于...
RabbitMq 死信消息的过期时间的不同 会导致消费延时
m0_37801313的博客
07-02 1783
业务需求是：消息7天过期。 概述：自测没问题发布了测试版本，为了测试方便将过期时间7天修改为10分钟。但是由于之前跑的测试数据中已经发送过过期时间为7天的消息，导致后续过期时间为10分钟的消息始终无法消费。 处理方式： #未消费的消息数量 # ./rabbitmqctl list_queues Listing queues queue-question-expire 0 queue-question-expire-dl 32 #手动消费消息 # ./rabbitmqctl purge_q
mall整合RabbitMQ实现延迟消息
weixin_33842304的博客
06-11 181
摘要 本文主要讲解mall整合RabbitMQ实现延迟消息的过程，以发送延迟消息取消超时订单为例。RabbitMQ是一个被广泛使用的开源消息队列。它是轻量级且易于部署的，它能支持多种消息协议。RabbitMQ可以部署在分布式和联合配置中，以满足高规模、高可用性的需求。 项目使用框架介绍 RabbitMQ RabbitMQ是一个被广泛使用的开源消息队列。它是轻量级且易于部署的，它能支持多种消息协议...
RabbitMQ
u010536669的博客
12-18 1274
RabbitMQ
Springboot使用rabbitmq的延时队列
zoboy的博客
05-18 230
使用rabbitmq的延时消息队列处理定时业务的场景，比如下单后必须在5分钟内完成支付，否则5分钟后不让支付订单。具体实现如下： 1 发送延时消息 /** * 发送延迟消息 */ public void sendMessage(Order order) { if (order != null) { String msg = JSON.toJSONString(order); // rabb
RabbitMQ实现延时消息的两种方法
lan_kang的博客
12-17 5661
文章目录RabbitMQ实现延时消息的两种方法1、死信队列1.1消息什么时候变为死信(dead-letter)1.2死信队列的原理1.3 代码实现1.4死信队列的一个小坑2 、延时插件2.1如何实现 RabbitMQ实现延时消息的两种方法 1、死信队列 1.1消息什么时候变为死信(dead-letter) 消息被否定接收，消费者使用basic.reject 或者 basic.nack并且requeue 重回队列属性设为false。 消息在队列里得时间超过了该消息设置的过期时间（TTL）。 消息队列到达了它
SpringBoot使用RabbitMQ延时队列
lizc_lizc的博客
06-18 5986
延时队列延时队列的使用场景：1.订单业务：在电商中，用户下单后30分钟后未付款则取消订单。2.短信通知：用户下单并付款后，1分钟后发短信给用户。延时队列实现思路AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是我们可以通过RabbitMQ的两个特性来曲线实现延迟队列：特性一：Time To Live(TTL)RabbitMQ可以针对Queue设置x-expires 或者 针对Me...
RabbitMQ 消息延时失效的个人问题解决
shadder1的博客
12-28 2814
RabbitMQ 消息延时失效的个人问题解决 RabbitMQ 消息延时失效的个人问题解决 今天我在学习尚硅谷rabbitmq课程视频的时候,遇到了一个让我非常苦恼的问题: ** 问题详情 ** 我在学习至延迟队列的时候,根据自己的学习心得写了模式和尚硅谷老师一样的代码： 配置中心的代码如下: @Configuration public class DelayedMessageConfig { /** * 延迟交换机 */ public static final Str
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值