如何使用 SpringBoot + RabbitMQ 做延时队列

最新推荐文章于 2024-06-08 14:55:47 发布

置顶 baby_Xiao

最新推荐文章于 2024-06-08 14:55:47 发布

阅读量588

点赞数 10

文章标签： spring intellij idea 队列 rabbitmq

本文链接：https://blog.csdn.net/baby_Xiao/article/details/103614741

版权

使用 SpringBoot + RabbitMQ 做延时队列

什么是延时队列

顾名思义是带有延时功能的消息队列，

延时队列应用场景

定时发公告
用户下单30分钟后未付款自动关闭订单
用户下单后延时短信提醒
延时关闭空闲客户端连接

延迟队列实现前提

安装rabbitmq

下载并安装erlang
下载并安装RabbitMQ

安装这两个的原因：RabbitMQ是实现了高级消息队列协议（AMQP）的开源消息代理软件（亦称面向消息的中间件）。RabbitMQ服务器是用Erlang语言编写的，而集群和故障转移是构建在开放电信平台框架上的。所有主要的编程语言均有与代理接口通讯的客户端库。

这里可以参考一下windows安装rabbitmq安装详细步骤
其中包含了这两个步骤(链接里描述得比较详细，跟着操作就完事,如果你的电脑用户中文命名导致启动不了服务，可以参考一下这个安装RabbitMQ电脑用户中文命名导致启动不了服务解决方案（可以解决）)

延时队列实现思路

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

RabbitMQ两个特性(了解即可)

Time To Live(TTL)
Dead Letter Exchanges（DLX）

延时队列实现方案

DelayQueue是一个无界阻塞队列，只有消息到期才能从中获取到消息。以下是我实现的步骤

SpringBoot整合RabbitMQ

新建一个这样的Spring Initializr项目(测试项目可不选MySQL，JDBC等与数据库相关的选项)
在 pom.xml中添加 spring-boot-starter-amqp的依赖(这里是所有需要的jar包)

<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>
		</dependency>
 
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

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


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

注：这里的用户名和密码为下图页面中输入的用户名和密码 rabbitmq

具体编码实现

1. 配置队列

package com.rabbit.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.context.annotation.Configuration;
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;


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


/**
 * @author 笑笑小太阳
 * @date 2019/12/19 11:32
 */
  @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);
        }

}

2. Order实体类

package com.rabbit.model;

import lombok.Data;

import java.io.Serializable;

/**
 * @author 笑笑小太阳
 * @date 2019/12/19 11:35
 */
@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.rabbit.constant;


import com.rabbit.config.DelayRabbitConfig;
import com.rabbit.model.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 笑笑小太阳
 * @date 2019/12/19 11:44
 */
@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("###########################################");
    }
}

4.发送者

package com.rabbit.constant;

import com.rabbit.config.DelayRabbitConfig;
import com.rabbit.model.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;

/**
 * @author 笑笑小太阳
 * @date 2019/12/19 11:47
 */

@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. 测试结果

先写controller层运行代码

package com.rabbit.controller;

import com.rabbit.constant.DelaySender;
import com.rabbit.model.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * @author 笑笑小太阳
 * @date 2019/12/19 11:48
 */


@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";
    }
}

postman中访问http://localhost:8080/sendDelay，查看结果是ok的
控制台日志输出欧克

如果有疑问，可以私信我

baby_Xiao

关注

10
点赞
踩
4

收藏

觉得还不错? 一键收藏
2
评论
如何使用 SpringBoot + RabbitMQ 做延时队列

使用 SpringBoot + RabbitMQ 做延时队列什么是延时队列顾名思义是带有延时功能的消息队列，延时队列应用场景定时发公告用户下单30分钟后未付款自动关闭订单用户下单后延时短信提醒延时关闭空闲客户端连接延迟队列实现前提安装rabbitmq下载并安装erlang下载并安装RabbitMQ这里可以参考一下windows安装rabbitmq安装详细步骤...
复制链接

扫一扫