SpringBoot+RabbitMQ实现延时队列

最新推荐文章于 2024-09-05 15:58:16 发布
最新推荐文章于 2024-09-05 15:58:16 发布
阅读量513 收藏 4
点赞数 6
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44990033/article/details/103616093
版权

Springboot+rabbitmq实现延时队列

什么是延迟队列

延迟队列存储的对象肯定是对应的延时消息，所谓“延时消息”是指消息被发送以后，并不想让消费者拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。

使用场景：

  1. 在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。
  2. 定时发送公告
  3. 系统创建了预约之后，需要在预约时间到达前一小时提醒被预约的双方参会
  4. 系统中的业务失败之后，需要重试

rabbitmq安装

  1. 下载并安装erlang（RabbitMQ服务端代码是使用并发式语言Erlang编写的，安装Rabbit MQ的前提是安装Erlang）
    下载地址 ：http://www.erlang.org/downloads
  2. 安装之后记得配置系统的环境变量
    变量名：ERLANG_HOME
    变量值：刚才erlang的安装地址
    打开cmd，再输入erl，看到版本号就说明erlang安装成功了。
  3. 安装RabbitMQ
    下载地址：http://www.rabbitmq.com/download.html
  4. RabbitMQ安装好后接下来安装RabbitMQ-Plugins。打开命令行cd，输入RabbitMQ的sbin目录。
  5. 打开sbin目录，双击rabbitmq-server.bat
  6. 等几秒钟看到这个界面后，访问http://localhost:15672
  7. 默认用户名和密码都是guest

延时队列实现思路

AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是我们可以通过RabbitMQ的两个特性来曲线实现延迟队列：

特性一：Time To Live(TTL)
RabbitMQ可以针对Queue设置x-expires或则针对Message设置x-message-ttl,来孔子消息的生存时间，如果超市，则消息变为dead letter死信
设置消息TTL有两种方式：
1. 创建队列时指定x-message-ttl,此时队列所有的消息具有统一过期时间
2. 发送消息为每个消息设置expiration，此时消息之间过期时间不同
特性二：Dead Letter Exchanges（DLX）
RabbitMQ的Queue可以配置x-dead-letter-exchange 和x-dead-letter-routing-key（可选）两个参数，如果队列内出现了dead letter，则按照这两个参数重新路由转发到指定的队列。
x-dead-letter-exchange：出现dead letter之后将dead letter重新发送到指定exchange
x-dead-letter-routing-key：出现dead letter之后将dead letter重新按照指定的routing-key发送
队列出现dead letter的情况有：
消息或者队列的TTL过期
队列达到最大长度

消息被消费端拒绝（basic.reject or basic.nack）并且requeue=false

SpringBoot整合RabbitMQ

实现逻辑

在这里插入图片描述
1、exchange_delay_begin：缓冲队列exchange交换器，用于将消息转发至缓存消息队列 queue_delay_begin 。

2、exchange_delay_done：死信（dead-letter）队列exchange交换器，用于将队列 queue_delay_begin 转发到死信队列。

3、queue_delay_begin：缓冲消息队列，等待消息过期。

4、queue_delay_done：死信消息队列，消费者能够真正消费信息。

具体实现
在 application.yml文件中配置rabbitmq相关内容

   <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
            <optional>true</optional>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
            <exclusions>
                <exclusion>
                    <groupId>org.junit.vintage</groupId>
                    <artifactId>junit-vintage-engine</artifactId>
                </exclusion>
            </exclusions>
        </dependency>
    </dependencies>

在 application.yml文件中配置rabbitmq相关内容

spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest

具体编码实现
1.配置队列

package com.li.demo.util;

import lombok.extern.slf4j.Slf4j;
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;

/*
 * @author li
 * @date 2019/12/19 9:26
 */
@Configuration
@Slf4j
public class DelayRabbitConfig {
    /**
     * 延迟队列 TTL 名称
     */
    private static final String ORDER_DELAY_QUEUE = "user.order.delay.queue";
    /**
     * DLX，dead letter发送到的 exchange
     * 延时消息就是发送到该交换机的
     */
    public static final String ORDER_DELAY_EXCHANGE = "user.order.delay.exchange";
    /**
     * routing key 名称
     * 具体消息发送在该 routingKey 的
     */
    public static final String ORDER_DELAY_ROUTING_KEY = "order_delay";

    public static final String ORDER_QUEUE_NAME = "user.order.queue";
    public static final String ORDER_EXCHANGE_NAME = "user.order.exchange";

    public static final String ORDER_ROUTING_KEY = "order";

    /**
     * 延迟队列配置
     * <p>
     * 1、params.put("x-message-ttl", 5 * 1000);
     * 第一种方式是直接设置 Queue 延迟时间 但如果直接给队列设置过期时间,这种做法不是很灵活,（当然二者是兼容的,默认是时间小的优先）
     * 2、rabbitTemplate.convertAndSend(book, message -> {
     * message.getMessageProperties().setExpiration(2 * 1000 + "");
     * return message;
     * });
     * 第二种就是每次发送消息动态设置延迟时间,这样我们可以灵活控制
     **/
    @Bean
    public Queue delayOrderQueue() {
        Map<String, Object> params = new HashMap<>();
        // x-dead-letter-exchange 声明了队列里的死信转发到的DLX名称，
        params.put("x-dead-letter-exchange", ORDER_EXCHANGE_NAME);
        // x-dead-letter-routing-key 声明了这些死信在转发时携带的 routing-key 名称。
        params.put("x-dead-letter-routing-key", ORDER_ROUTING_KEY);
        return new Queue(ORDER_DELAY_QUEUE, true, false, false, params);
    }
    /**
     * 需要将一个队列绑定到交换机上，要求该消息与一个特定的路由键完全匹配。
     * 这是一个完整的匹配。如果一个队列绑定到该交换机上要求路由键 “dog”，则只有被标记为“dog”的消息才被转发，
     * 不会转发dog.puppy，也不会转发dog.guard，只会转发dog。
     * @return DirectExchange
     */
    @Bean
    public DirectExchange orderDelayExchange() {
        return new DirectExchange(ORDER_DELAY_EXCHANGE);
    }
    @Bean
    public Binding dlxBinding() {
        return BindingBuilder.bind(delayOrderQueue()).to(orderDelayExchange()).with(ORDER_DELAY_ROUTING_KEY);
    }

    @Bean
    public Queue orderQueue() {
        return new Queue(ORDER_QUEUE_NAME, true);
    }
    /**
     * 将路由键和某模式进行匹配。此时队列需要绑定要一个模式上。
     * 符号“#”匹配一个或多个词，符号“*”匹配不多不少一个词。因此“audit.#”能够匹配到“audit.irs.corporate”，但是“audit.*” 只会匹配到“audit.irs”。
     **/
    @Bean
    public TopicExchange orderTopicExchange() {
        return new TopicExchange(ORDER_EXCHANGE_NAME);
    }

    @Bean
    public Binding orderBinding() {
        // TODO 如果要让延迟队列之间有关联,这里的 routingKey 和 绑定的交换机很关键
        return BindingBuilder.bind(orderQueue()).to(orderTopicExchange()).with(ORDER_ROUTING_KEY);
    }

}
  1. routing key
    生产者在将消息发送给Exchange的时候，一般会指定一个routing key，来指定这个消息的路由规则，而这个routing key需要与Exchange Type及binding key联合使用才能最终生效。
    在Exchange Type与binding key固定的情况下（在正常使用时一般这些内容都是固定配置好的），我们的生产者就可以在发送消息给Exchange时，通过指定routing key来决定消息流向哪里。
    RabbitMQ为routing key设定的长度限制为255 bytes。
2.创建一个Order实体类

package com.li.demo.pojo;

import lombok.Data;

import java.io.Serializable;

/*
 * @author li
 * @date 2019/12/19 9:30
 */
@Data
public class Order implements Serializable {
    private static final long serialVersionUID = -2221214252163879885L;

    private String orderId; // 订单id

    private Integer orderStatus; // 订单状态 0：未支付，1：已支付，2：订单已取消

    private String orderName; // 订单名字


}


3. 接收者

package com.li.demo.util;

import com.li.demo.pojo.Order;
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

import java.util.Date;
/*
 * @author li
 * @date 2019/12/19 9:31
 * 接收者
 */
@Component
@Slf4j
public class DelayReceiver {
    @RabbitListener(queues = {DelayRabbitConfig.ORDER_QUEUE_NAME})
    public void orderDelayQueue(Order order, Message message, Channel channel) {
        log.info("###########################################");
        log.info("【orderDelayQueue 监听的消息】 - 【消费时间】 - [{}]- 【订单内容】 - [{}]",  new Date(), order.toString());
        if(order.getOrderStatus() == 0) {
            order.setOrderStatus(2);
            log.info("【该订单未支付，取消订单】" + order.toString());
        } else if(order.getOrderStatus() == 1) {
            log.info("【该订单已完成支付】");
        } else if(order.getOrderStatus() == 2) {
            log.info("【该订单已取消】");
        }
        log.info("###########################################");
    }

}
  1. Channels
    虚拟连接。它建立在上述的TCP连接中。数据流动都是在Channel中进行的。也就是说，一般情况是程序起始建立TCP连接，第二步就是建立这个Channel。
4. 发送者

package com.li.demo.util;




import com.li.demo.pojo.Order;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.Date;



import java.util.Date;


/*
 * @author li
 * @date 2019/12/19 9:32
 * 发送者
 */
@Component
@Slf4j
public class DelaySender {


    @Autowired
    private AmqpTemplate amqpTemplate;

    public void sendDelay(Order order) {
        log.info("【订单生成时间】" + new Date().toString() +"【1分钟后检查订单是否已经支付】" + order.toString() );
        this.amqpTemplate.convertAndSend(DelayRabbitConfig.ORDER_DELAY_EXCHANGE, DelayRabbitConfig.ORDER_DELAY_ROUTING_KEY, order, message -> {
            // 如果配置了 params.put("x-message-ttl", 5 * 1000); 那么这一句也可以省略,具体根据业务需要是声明 Queue 的时候就指定好延迟时间还是在发送自己控制时间
            message.getMessageProperties().setExpiration(1 * 1000 * 60 + "");
            return message;
        });
    }


}


5. 测试 http://localhost:8080/sendDelay

package com.li.demo.controller;



import com.li.demo.pojo.Order;
import com.li.demo.util.DelaySender;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.util.concurrent.DelayQueue;


/*
 * @author li
 * @date 2019/12/19 9:34
 */
@RestController
public class TestController {


    @Autowired
    private DelaySender delaySender;

    @GetMapping("/sendDelay")
    public Object sendDelay() {
        Order order1 = new Order();
        order1.setOrderStatus(0);
        order1.setOrderId("123456");
        order1.setOrderName("小米6");

        Order order2 = new Order();
        order2.setOrderStatus(1);
        order2.setOrderId("456789");
        order2.setOrderName("小米8");

        delaySender.sendDelay(order1);
        delaySender.sendDelay(order2);
        return "ok";
    }


}


一分钟之后看控制台输出

在这里插入图片描述

再看交换机和队列

交换机
Exchange
生产者将消息投递到Queue中，实际上这在RabbitMQ中这种事情永远都不会发生。实际的情况是，生产者将消息发送到Exchange（交换器），由Exchange将消息路由到一个或多个Queue中（或者丢弃）。
在这里插入图片描述
队列
Queue
Queue（队列）是RabbitMQ的内部对象，用于存储消息，用下图表示。

在这里插入图片描述

146789
关注
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
Springboot+RabbitMQ实现订单超时未支付，取消订单(实战+源码下载)
雾林小妖的博客
11-08 917
Springboot整合RabbitMQ,通过使用RabbitMQ的延时队列，死信队列等实现当订单超时后取消订单，预约超时取消预约，审批超时取消审批或发送短信或邮件消息等。
springboot+rabbitmq实现延时队列
08-29
springboot+rabbitmq实现延时队列，包括消息发送和消费确认，消费者端使用策略模式处理业务
springboot rabbitmq 延时队列
qq_38718211的博客
08-07 284
配置： spring: rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest virtual-host: / publisher-confirms: true config: package com.uban.config; import lombok....
SpringBoot教程（十五） | SpringBoot集成RabbitMq（死信队列、延迟队列）
最新发布
qq_20236937的博客
09-05 890
SpringBoot集成RabbitMq（死信队列、延迟队列）
Spring Boot（十四）RabbitMQ延迟队列
weixin_34015860的博客
11-16 180
一、前言 延迟队列的使用场景：1.未按时支付的订单，30分钟过期之后取消订单；2.给活跃度比较低的用户间隔N天之后推送消息，提高活跃度；3.过1分钟给新注册会员的用户，发送注册邮件等。 实现延迟队列的方式有两种： 通过消息过期后进入死信交换器，再由交换器转发到延迟消费队列，实现延迟功能； 使用rabbitmq-delayed-message-exchange插件实现延迟功能； 注意： 延迟插...
SpringBoot使用RabbitMQ实现延迟队列
Funky_oaNiu的博客
06-03 782
实现延迟队列，先将消息发到指定了TTL时长的队列A中，队列A没有消费者，也就是说，队列A中的消息肯定会过期，等消息过期后，就会加入到队列B，也就是死信队列，B队列是有消费者在监听的，一旦收到消息，就进行后续的逻辑处理，从而达到延迟效果。如果消息的延迟时间设置较长，可能会导致堆积的延迟消息非常多，会带来较大的CPU开销，同时延迟消息的时间会存在误差。③死信队列：延迟队列上的消息过期后，会被自动转发到死信队列中，从而最终达到延迟的目的。因此，不建议设置延迟时间过长的延迟消息，如果时间过长，建议使用任务调度。
SpringBoot+RabbitMQ实现延迟队列
LoveLacie的博客
04-08 440
一、什么是延迟队列? 先来说一下什么是延迟队列,延迟队列就是消息进入队列之后不会立即被消息,只有达到指定时间后,才会被消费. 常见需求: 1、在网上商城下单后,30分钟未支付,取消订单,回滚库存; ​ 2、新用户注册成功7天后,发送短信. 实现方法: 1、定时器 2、延迟队列 但RabbitMQ未提供延迟队列功能,但是可以使用**TTL+死信队列(DLX)**组...
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码
06-29
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码。参考博客：https://blog.csdn.net/qq_29914837/article/details/94070677
SpringBoot RabbitMQ 实现延迟队列
hsadfdsahfdsgfds的博客
03-11 166
SpringBoot RabbitMQ 实现延迟队列 一.依赖 <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot&l
SpringBoot+RabbitMQ之延迟队列
c8889987的博客
12-21 196
这里写自定义目录标题欢迎使用Markdown编辑器新的改变功能快捷键合理的创建标题，有助于目录的生成如何改变文本的样式插入链接与图片如何插入一段漂亮的代码片生成一个适合你的列表创建一个表格设定内容居中、居左、居右SmartyPants创建一个自定义列表如何创建一个注脚注释也是必不可少的KaTeX数学公式新的甘特图功能，丰富你的文章UML 图表FLowchart流程图导出与导入导出导入 欢迎使用Ma...
Springboot集成rabbitmq——实现延迟队列
tang_seven的博客
09-05 3922
springboot集成rabbitmq，并通过死信队列和延迟交换机两种形式，实现延时队列。
Springboot + rabbitMQ实现延迟队列（生产者）
qq_37557563的博客
06-09 181
Springboot + rabbitMQ实现延迟队列（生产者） 前言：在电商系统中，可能有这样一个需求，订单下单之后30分钟后，如果用户没有付钱，则系统自动取消订单。如果用常规的定时器定时去查询，这会造成很大的消耗（频繁访问数据库）。 这里选择RabbitMQ来实现类似的功能（使用队列的TTL特性） 1.这种模式大概流程，我们需要将消息先发送到ttl延迟队列内，当消息到达过期时间后会自动转发到ttl队列内配置的转发Exchange以及RouteKey绑定的队列内完成消息消费。 2.添加mave
详细介绍Spring Boot + RabbitMQ实现延迟队列
blfjvkwfn
04-29 132
https://juejin.im/post/5a12ffd451882578da0d7b3a
SpringBoot整合Rabbitmq之延时队列
桐花思雨
09-27 1321
目录延时队列概念使用场景延时队列实现 延时队列 概念 延时队列是存储延时消息的队列，延时消息就是生产者发送了一条消息，但是不希望该消息不要被立即消费，而是设置一个延时时间，等过了这个时间再消费消息 使用场景 订单在十分钟之内未支付则自动取消 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒 账单在一周内未支付，则自动结算 用户注册成功后，如果三天内没有登陆则进行短信提醒 用户发起退款，如果三天内没有得到处理则通知相关运营人员 这时候，延时队列就可以闪亮登场了，以上场景，正是延时队列的用武之
Springboot使用rabbitmq的延时队列
zoboy的博客
05-18 245
使用rabbitmq的延时消息队列处理定时业务的场景，比如下单后必须在5分钟内完成支付，否则5分钟后不让支付订单。具体实现如下： 1 发送延时消息 /** * 发送延迟消息 */ public void sendMessage(Order order) { if (order != null) { String msg = JSON.toJSONString(order); // rabb
SpringBoot + RabbitMQ 做延时队列
qq_44680160的博客
12-19 1062
SpringBoot + RabbitMQ 做延时队列
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值