使用RabbitMQ完成消息延迟推送

最新推荐文章于 2024-10-04 10:18:10 发布
最新推荐文章于 2024-10-04 10:18:10 发布
阅读量1.8k 收藏 4
点赞数 1
分类专栏： MQ
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lxxiaoyuan/article/details/88780548
版权

使用RabbitMQ完成消息延迟推送

背景

本周做了一个需求，大体是这样的，一个用户领取了一条信息（公用的（领取后变成私有的）），但是如果他在设定的时间内没有使用这条信息，那么这条信息将会被释放掉，由于本人之前没有做过类似的需求，遂找前辈取经，得到了两种解决方案，一种是自己写定时器，每隔一小时或者多长时间跑一次满足释放条件的数据，然后释放掉，另一种就是使用RabbitMQ的延迟队列，在听了延迟队列的作用后果断选择此方法

什么是延迟队列

用过RabbitMQ的同学都知道，一般的队列，消息一旦入队了之后就会被消费者马上消费，而延迟队列就是说，消息进入后会根据延迟时间长短来消费，也就是超时才会被消费

实现思路

RabbitMQ允许我们为消息或者队列设置TTL（time to live），也就是过期时间。TTL表明了一条消息可在队列中存活的最大时间，单位为毫秒。也就是说，当某条消息被设置了TTL或者当某条消息进入了设置了TTL的队列时，这条消息会在经过TTL毫秒后“死亡”，成为Dead Letter。

还有另一个特性：如果队列设置了Dead Letter Exchange（DLX），那么这些Dead Letter就会被重新publish到Dead Letter Exchange，通过Dead Letter Exchange路由到其他队列。

根据这两个特性我们不难想到满足当前需求的延迟队列的实现方案，也就是TTL和DLX特性结合在一起，流程图大概是这样的：

在这里插入图片描述

创建MQ相关配置

  1. 创建一个测试的Virtual Host，我这里叫LxTestMqHost
  2. 创建对应的DLX和延迟重试的Exchange(我这里叫test_per_queue_ttl_exchange)
    在这里插入图片描述
  3. 创建实际消费队列在这里插入图片描述
  4. 创建缓冲队列并绑定DLX和消费队列
    在这里插入图片描述
  5. 创建消费失败的缓冲队列并绑定test_per_queue_ttl_exchange和消费队列还有失效时间在这里插入图片描述
  6. 绑定DLX和消费队列
    在这里插入图片描述

配置MQ代码

package com.yqn.crm.mq.config;

import org.springframework.amqp.core.*;
import org.springframework.amqp.rabbit.config.SimpleRabbitListenerContainerFactory;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.autoconfigure.amqp.RabbitProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
public class QueueConfig extends BaseConfig {
    /**
     * DLX
     */
    public final static String DELAY_EXCHANGE_NAME = "test_delay_exchange";

    /**
     * 路由到test_delay_queue_per_queue_ttl的exchange
     */
    public final static String PER_QUEUE_TTL_EXCHANGE_NAME = "test_per_queue_ttl_exchange";

    /**
     * 发送到该队列的message会在一段时间后过期进入到test_delay_process_queue
     * 每个message可以控制自己的失效时间
     */
    public final static String DELAY_QUEUE_PER_MESSAGE_TTL_NAME = "test_delay_queue_per_message_ttl";

    /**
     * 发送到该队列的message会在一段时间后过期进入到test_delay_process_queue
     * 队列里所有的message都有统一的失效时间
     */
    public final static String DELAY_QUEUE_PER_QUEUE_TTL_NAME = "test_delay_queue_per_queue_ttl";
    public final static int QUEUE_EXPIRATION = 5000;

    /**
     * message失效后进入的队列，也就是实际的消费队列
     */
    public final static String DELAY_PROCESS_QUEUE_NAME = "test_delay_process_queue";

    /**
     * 创建DLX exchange
     *
     * @return
     */
    @Bean
    DirectExchange delayExchange() {
        return new DirectExchange(DELAY_EXCHANGE_NAME);
    }

    /**
     * 创建test_per_queue_ttl_exchange
     *
     * @return
     */
    @Bean
    DirectExchange perQueueTTLExchange() {
        return new DirectExchange(PER_QUEUE_TTL_EXCHANGE_NAME);
    }

    /**
     * 创建test_delay_queue_per_message_ttl队列
     *
     * @return
     */
    @Bean
    Queue delayQueuePerMessageTTL() {
        return QueueBuilder.durable(DELAY_QUEUE_PER_MESSAGE_TTL_NAME)
                           .withArgument("x-dead-letter-exchange", DELAY_EXCHANGE_NAME) // DLX，dead letter发送到的exchange
                           .withArgument("x-dead-letter-routing-key", DELAY_PROCESS_QUEUE_NAME) // dead letter携带的routing key
                           .build();
    }

    /**
     * 创建test_delay_queue_per_queue_ttl队列
     *
     * @return
     */
    @Bean
    Queue delayQueuePerQueueTTL() {
        return QueueBuilder.durable(DELAY_QUEUE_PER_QUEUE_TTL_NAME)
                           .withArgument("x-dead-letter-exchange", DELAY_EXCHANGE_NAME) // DLX
                           .withArgument("x-dead-letter-routing-key", DELAY_PROCESS_QUEUE_NAME) // dead letter携带的routing key
                           .withArgument("x-message-ttl", QUEUE_EXPIRATION) // 设置队列的过期时间
                           .build();
    }

    /**
     * 创建test_delay_process_queue队列，也就是实际消费队列
     *
     * @return
     */
    @Bean
    Queue delayProcessQueue() {
        return QueueBuilder.durable(DELAY_PROCESS_QUEUE_NAME)
                           .build();
    }

    /**
     * 将DLX绑定到实际消费队列
     *
     * @param delayProcessQueue
     * @param delayExchange
     * @return
     */
    @Bean
    Binding dlxBinding(Queue delayProcessQueue, DirectExchange delayExchange) {
        return BindingBuilder.bind(delayProcessQueue)
                             .to(delayExchange)
                             .with(DELAY_PROCESS_QUEUE_NAME);
    }

    /**
     * 将per_queue_ttl_exchange绑定到delay_queue_per_queue_ttl队列
     *
     * @param delayQueuePerQueueTTL
     * @param perQueueTTLExchange
     * @return
     */
    @Bean
    Binding queueTTLBinding(Queue delayQueuePerQueueTTL, DirectExchange perQueueTTLExchange) {
        return BindingBuilder.bind(delayQueuePerQueueTTL)
                             .to(perQueueTTLExchange)
                             .with(DELAY_QUEUE_PER_QUEUE_TTL_NAME);
    }


    @Bean(name = "lxTestMqReleaseConnectionFactory")
    public ConnectionFactory connectionElaneFactory() {
        String virtualHost="LxTestMqHost";
        return getConnectionFactory(host, port, username, password, virtualHost);
    }


    @Bean(name = "lxTestMqRabbitListenerContainerFactory")
    public SimpleRabbitListenerContainerFactory lxTestMqRabbitListenerContainerFactory(@Qualifier("lxTestMqReleaseConnectionFactory") ConnectionFactory connectionFactory, RabbitProperties config) {
        return getFactory(connectionFactory, config);
    }

    @Bean(name = "lxTestMqReleaseTemplate")
    public RabbitTemplate orderSummaryAmqpTemplate(@Qualifier("lxTestMqReleaseConnectionFactory") ConnectionFactory connectionFactory) {
        RabbitTemplate template = new RabbitTemplate(connectionFactory);
        return template;
    }
}

测试MQ代码

package com.yqn.crm.mapper.crm;

import com.yqn.crm.mq.config.QueueConfig;
import com.yqn.crm.mq.receiver.ExpirationMessagePostProcessor;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.rabbit.annotation.Exchange;
import org.springframework.amqp.rabbit.annotation.Queue;
import org.springframework.amqp.rabbit.annotation.QueueBinding;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.messaging.handler.annotation.Payload;
import org.springframework.test.context.junit4.SpringRunner;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;

/**
 * @author 刘鑫
 * @description
 * @since 2019-03-24 17:24
 */
@RunWith(SpringRunner.class)
@SpringBootTest
public class Mqtestww {
    @Autowired
    @Qualifier("lxTestMqReleaseTemplate")
    private AmqpTemplate rabbitTemplate;

    @Test
    public void testDelayQueuePerMessageTTL() throws Exception {
        for (int i = 1; i <= 3; i++) {
            long expiration = i * 5000;//超时时间设置
            rabbitTemplate.convertAndSend(QueueConfig.DELAY_QUEUE_PER_MESSAGE_TTL_NAME,
                    (Object) ("测试手动设置超时时间" + expiration), new ExpirationMessagePostProcessor(expiration));//可以将想要的参数放到message中，参数可以是json类型的所以可以将对象传上去
        }
    }

    @Test
    public void testDelayQueuePerQueueTTL() throws InterruptedException {
        for (int i = 1; i <= 3; i++) {
            rabbitTemplate.convertAndSend(QueueConfig.DELAY_QUEUE_PER_QUEUE_TTL_NAME,
                    "测试自动超时时间 " + QueueConfig.QUEUE_EXPIRATION);
        }
    }


    /*/**
     * @author 凑合看
     * @description 测试接收消息
     * @since 2019-03-24 19:05
     * @param [msg, channel, message]
     * @return void
     **/
    @RabbitListener(bindings =
    @QueueBinding(value = @Queue(name = QueueConfig.DELAY_PROCESS_QUEUE_NAME),
            exchange = @Exchange(name = QueueConfig.DELAY_EXCHANGE_NAME)),
            containerFactory = "lxTestMqRabbitListenerContainerFactory")
    public void consumer(@Payload String msg, Channel channel, Message message) throws Exception {
        Throwable throwable = null;
        try {
            String test = msg;//将msg消息打印下来，如果推送消息的时候message中放的是一个对象，也可以使用json来转成想要的对象
            System.out.println(test);
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (Exception e) {
            // 如果发生了异常，则将该消息重定向到缓冲队列，会在一定延迟之后自动重做
            channel.basicPublish(QueueConfig.PER_QUEUE_TTL_EXCHANGE_NAME, QueueConfig.DELAY_QUEUE_PER_QUEUE_TTL_NAME, null,
                    "触发异常，延迟再来".getBytes());
        }
    }

}

重点总结

  1. 创建mq配置的时候一定要注意绑定DLX和消费队列，如果需要用到异常处理的缓冲队列也一定要记得绑定对应的关系
  2. 个人认为推送消息时的messge非常重要，可以放想要使用的参数上去，然后消费的时候可以使用参数做处理，会方便很多
  3. 其实精华就是两个队列是一组，一个队列用来缓存消息并绑定超时时间，另一个队列是真正的消费队列，中间用一个DLX关联起来，缓存队列绝对不能被直接消费

此致，敬礼！！！

贼不走空？
关注
专栏目录
RabbitMQ 延迟队列，消息延迟推送
06-26 229
应用场景# 目前常见的应用软件都有消息的延迟推送的影子，应用也极为广泛，例如： 淘宝七天自动确认收货。在我们签收商品后，物流系统会在七天后延时发送一个消息给支付系统，通知支付系统将款打给商家，这个过程持续七天，就是使用了消息中间件的延迟推送功能。 12306 购票支付确认页面。我们在选好票点击确定跳转的页面中往往都会有倒计时，代表着 30 分钟内订单不确认的话将会自动取消订单。其实在下订单那一刻开始购票业务系统就会发送一个延时消息给订单系统，延时30分钟，告诉订单系统订单未完成，如果我们在30分钟内完
Rabbit MQ篇：RabbitMQ实现消息延迟推送
欢迎来到我的博客
08-28 296
另外这里的消息延迟主要发生在交换机延迟推送消息到队列中，而非队列延迟推送到消费者。之前我们一般采用死信队列+TTL过期时间来实现延迟队列。如果开启了消息确认机制，比如确认消息是否发到了交换机（下拉选项，如果有则表示插件安装已经生效了。配置和依赖这里就不贴出了，可以参考以往。选择对应版本下载（要和安装的。的安装路径，将下载的插件放到。官方提供了延迟队列的插件。这里指定延迟5秒推送消息。自定义类型，这里指定为。
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
主要介绍了RabbitMQ延迟队列及消息延迟推送实现详解,文中通过示例代码介绍的非常详细，对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下
RabbitMQ篇（延迟队列）
最新发布
wlcass zhengge blog
10-04 1870
延时队列相比于普通队列最大的区别就体现在其延时的属性上，普通队列的元素是先进先出，按入队顺序进行处理，而延时队列中的元素在入队时会指定一个延迟时间，表示其希望能够在经过该指定时间后处理。从某种意义上来讲，延迟队列的结构并不像一个队列，而更像是一种以时间为权重的有序堆结构。
RabbitMQ高级特性之延时消息/队列
JavaEdge全是干货的技术号
11-14 1361
RabbitMQ本身没有延时队列功能，无法直接指定一个队列类型为延时队列，然后去延时处理。有两种实现方案：插件和功能搭配。 这里只介绍其二。可以将TTL+DLX相结合，就能组成一个延时队列。 案例 下完订单后20min未付款，就关闭该订单，如果使用RabbitMQ，就需要结合TTL+DLX。 解决方案 先把订单消息设置好15分钟TTL，到点过期后队列将消息转发给DLX，再将消息分发给我们配置的所绑定的队列，再定义消费者去消费这个队列中的消息，就做到了延时十五分钟消费。 ...
vue使用stompjs实现mqtt消息推送通知
10-19
Vue.js作为一个轻量级的前端框架，结合Stompjs和MQTT协议，可以构建高效、低延迟的消息推送系统。本篇文章将详细介绍如何在Vue项目中使用Stompjs来实现MQTT消息推送通知。 首先，我们需要了解MQTT（Message Queuing...
RabbitMQ 延迟队列，消息延迟推送的实现
KHOST的博客
02-03 541
目录 应用场景 消息延迟推送的实现 测试结果 应用场景 目前常见的应用软件都有消息的延迟推送的影子，应用也极为广泛，例如： 淘宝七天自动确认收货。在我们签收商品后，物流系统会在七天后延时发送一个消息给支付系统，通知支付系统将款打给商家，这个过程持续七天，就是使用了消息中间件的延迟推送功能。 12306 购票支付确认页面。我们在选好票点击确定跳转的页面...
RabbitMQ实现消息的延迟推送或延迟发送
qq_45509892的博客
11-25 4547
使用RabbitMQ实现消息的延迟推送
Rabbitmq延迟消息
WuTing的专栏
11-10 2272
Rabbitmq延迟消息，定时推送
RabbitMQ延迟消息
卑微的小白
10-27 1765
RabbitMQ中没有对消息延迟进行实现，但是我们可以通过TTL以及死信路由来实现消息延迟。 TTL（Time To Live 消息过期时间） 如果消息一直存放在队列中没有被消费并且超过了过期时间则消息将变成死信（Dead Message），后续将无法被消费。 消息成为死信的几种情况： 1、消息被Consumer拒收，并且reject方法里的参数requeue为false，则消息不会被重新放回队列，不会被其他消费者消费。 2、消息以及队列的过期时间到了 3、队列的长度满了，排在前面的消息会被丢弃或者扔到死信
rabbitMQ 延迟消息
qq690452074的专栏
08-06 277
参考 https://www.jianshu.com/p/7e5f0742c8e3 https://blog.csdn.net/linsongbin1/article/details/80178122 原理图解 rabbitMQ延迟消息原理.png 若想不借助插件实现rabbitMQ的延迟消息，实际就是利用一个没有消费者的Queue1，等待消息过期后，通过交换机转发到Queue2来进行消费，消息的延迟时间就是消息在Queue1中的存活时间 概述 曾经去网易面试的时...
RabbitMQ常见问题之延迟消息
m0_51390969的博客
01-17 1067
这个插件只能在消息上设置延迟时间，没有队列设置延迟时间的概念，不过都是一样的。属性，指定了一个交换机，那么队列中的死信就会投递到这个交换机中，而。机制可以用死信交换机模拟延迟队列，但是设计上比较牵强，性能不好。当一个队列中的消息满足下列情况之一时，可以成为死信（直接运行测试，可能会报错，因为。这个交换机称为死信交换机(这是官方提供的一些额外插件。目录下，然后进入容器，执行。方面，消息发送的时间为。方面消息消费的时间为。
RabbitMQ（五）之延迟消息
jinkkkkkkk的博客
10-21 1312
生产者发送消息时指定一个时间，消费者不会立刻收到消息，而是在才收到消息。：设置在一定时间之后才执行的任务延迟消息的实现有两种：死信交换机，延迟消息插件。
RabbitMQ实现延迟消息的两种方法（提供延迟插件）
一个好学的低级程序猿
08-17 480
MQ实现延迟消息的两种方法
Rabbitmq延迟消息队列异常
LMC技术人生专栏
12-20 1665
  引起此异常的原因是，给队列设置过期时间的时候，第一次设置10秒，第二次想设置20秒，但是队列只会保存第一次设置的值，这样你后面设置的值就冲突了，也覆盖不了，所以报错 粗暴点的解决办法就是， ’ 1 RabbitMQ后台管理界面，删除掉队列，重新运行服务器，重新生成队列就OK 2  通过 policy 来设置这个参数也可以不用删除队列。 method: #method&lt;channe...
firefly框架分析之netconnect package(三)
9527的专栏
10-10 1204
manager.py库 用来管理connection连接 class ConnectionManager: 包括一个管理connection对象的字典 def getNowConnCnt(self): 获取当前连接数量 def addConnection(self, conn): 根据conn创建connection对象，并加到字典中
RabbitMQ 延时消息实现方式
web18484626332的博客
08-02 268
先声明一个消费队列queue_dlx，用来接收死信消息，并提供消费；然后声明一个死信exchange_dlx,绑定queue_dlx，接收消息后路由至queue_dlx；声明一个延迟队列，queue_delay,用来接收业务消息，但不提供消费，等待消息死亡后转至死信exchange。（即延迟）声明一个exchange，由业务发送消息到exchange，然后转至queue_delay.一个消息的流程大概是RabbitMQ实现固定延时等级的延时消息。...
实战，SpringBoot + RabbitMQ死信队列实现超时关单
Java_zhujia的博客
11-10 1360
第三方支付平台的支付连接都是有时效性，创建订单后，需要在一定的时间内支付完成， 比如微信支付、支付宝支付等。当然也可以不关闭订单，做订单二次支付的操作，但业务链路会更加复杂，所以一般会直接关闭
RabbitMq消息方式推送
06-21
在RabbitMQ中，消息可以通过多种方式被推送： 1. 发布/订阅模式：在这个模式下，生产者发布消息到一个特定的交换机(exchange)，交换机会根据预设的规则将消息路由到多个队列（queue）。消费者订阅这些队列，他们只...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值