用SpringBoot + RabbitMQ 做延时队列

最新推荐文章于 2022-02-20 22:14:30 发布

weixin_45454866

最新推荐文章于 2022-02-20 22:14:30 发布

阅读量330

点赞数 1

分类专栏： java

本文链接：https://blog.csdn.net/weixin_45454866/article/details/103620650

版权

java 专栏收录该内容

1 篇文章 0 订阅

订阅专栏

适用场景

订单业务：处于未支付状态的订单，一小时之后自动关闭
短信业务：XXX时间之后给用户发送通知

rabbitMQ优势

传统处理超时订单

采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求，并且当处理大量订单起来会很力不从心,而且实时性也不是特别好
当然传统的手法还可以再优化一下，即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单，然后再做其他的业务操作

jdk延迟队列 DelayQueue

采取jdk自带的延迟队列能很好的优化传统的处理方案，但是该方案的弊、端也是非常致命的，所有的消息数据都是存于内存之中，一旦宕机或重启服务队列中数据就全无了，而且也无法进行扩展。

rabbitMQ延时队列方案

rabbitmq我就不多介绍了，一台普通的rabbitmq服务器单队列容纳千万级别的消息还是没什么压力的，而且rabbitmq集群扩展支持的也是非常好的，并且队列中的消息是可以进行持久化，即使我们重启或者宕机也能保证数据不丢失

延时队列实现思路

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

特性一：
存活时间（Time-To-Live 简称 TTL）,分别有三种TTL的设置模式

x-message-ttl ,该属性是在创建队列的时候
，在arguments的map中配置；该参数的作用是设置当前队列中所有的消息的存活时间
x-expires
该属性也是在arguments中配置；其作用是设置当前队列在N毫秒中(不能为0,且为正整数)，就删除该队列；“未使用”意味着队列没有消费者，队列尚未重新声明，并且至少在有效期内未调用basicGet
(basicGet 是手动拉取指定队列中的一条消息)
List item
AMQP.BasicProperties配置中的exppiration
属性，前两者都是基于队列的TTL，该属性是基于单条消息的TLL用于配置每条消息在队列中的存活时间

特性二：
”死信交换“ 可以分开来理解；首先是 ”死信“，也就是死亡的信息，无效的信息；造成这样的信息有以下几种情况

消息被拒绝，即消费者没有成功确认消息被消费
消息TTL过期
超出队列长度限制
当出现这三种情况的时候，队列中的消息就会变为“死信”
再来理解”交换“ 也就是说，当出现"死信"的情况下 rabbitmq
可以对该"死信"进行交换到别的队列上，但是交换的前提是需要为死信配置一个交换机用于死信的交换

代码实现

安装RabbitMQ：
RabbitMQ windows安装步骤

在 pom.xml 中添加 spring-boot-starter-amqp的依赖

 <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.properties文件中配置rabbitmq相关内容

spring.rabbitmq.host=localhost
spring.rabbitmq.port=5672
#用户
spring.rabbitmq.username=guest
#密码
spring.rabbitmq.password=guest

具体编码实现
配置队列

package com.example.rabbitmq.demo.config;

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;

@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
    //Queue线性表
    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.example.rabbitmq.demo.pojo;

import lombok.Data;

import java.io.Serializable;

@Data
                    //实现序列化
public class Order implements Serializable {

    private static final long serialVersionUID = -2221214252163879885L;
    //订单id
    private String orderId;
    // 订单状态 0：未支付，1：已支付，2：订单已取消
    private Integer orderStatus;
    // 订单名字
    private String orderName;

}

3.接收者

package com.example.rabbitmq.demo.config;


import com.example.rabbitmq.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;

@Component
@Slf4j
public class DelayReceiver {
    //消费者
    @RabbitListener(queues = {DelayRabbitConfig.ORDER_QUEUE_NAME})
    public void orderDelayQueue(Order order, Message message, Channel channel) {
        log.info("---------------------------------------------");
        log.info("【提醒消息】 - 【消费时间】 - [{}]- 【订单内容】 - [{}]",  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("--------------------------------------------");
    }

}

注意：
这里Channel不要导错了
不是import java.nio.channels.Channel;
是import com.rabbitmq.client.Channel;

4.发送者


package com.lzc.rabbitmq.config;
 
import com.lzc.rabbitmq.dataobject.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;
 
@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.example.rabbitmq.demo.controller;

import com.example.rabbitmq.demo.config.DelaySender;
import com.example.rabbitmq.demo.pojo.Order;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TestController {


    @Autowired
    private DelaySender delaySender;

    @GetMapping("/sendDelay")
    public Object sendDelay() {
        Order order1 = new Order();
        //订单状态
        order1.setOrderStatus(0);
        //订单编号
        order1.setOrderId("5665855");
        //商品名称
        order1.setOrderName("回锅肉");

        Order order2 = new Order();
        order2.setOrderStatus(1);
        order2.setOrderId("456789");
        order2.setOrderName("奶茶");

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

6.测试效果在这里插入图片描述
完整项目请上码云：延时队列

weixin_45454866

关注

1
点赞
踩
1

收藏

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

适用场景订单业务：处于未支付状态的订单，一小时之后自动关闭短信业务：XXX时间之后给用户发送通知rabbitMQ优势传统处理超时订单采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求，并且当处理大量订单起来会很力不从心,而且实时性也不是特别好当然传统的手法还可以再优化一下，即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查...
复制链接

扫一扫