SpringBoot+RabbitMQ实现延时队列

最新推荐文章于 2024-06-06 09:45:17 发布

HuntLee770090834

最新推荐文章于 2024-06-06 09:45:17 发布

阅读量538

点赞数 1

本文链接：https://blog.csdn.net/Hunt_Lee/article/details/103641322

版权

springboot整合RabbitMQ做延时队列

延时队列的使用场景：

1.订单业务：在电商中，用户下单后30分钟后未付款则取消订单。

2.短信通知：用户下单并付款后，1分钟后发短信给用户。

延时队列实现思路

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

特性一：Time To Live(TTL)

RabbitMQ可以针对Queue设置x-expires 或者针对Message设置 x-message-ttl，来控制消息的生存时间，如果超时(两者同时设置以最先到期的时间为准)，则消息变为dead letter(死信)
RabbitMQ针对队列中的消息过期时间有两种方法可以设置。
A: 通过队列属性设置，队列中所有消息都有相同的过期时间。
B: 对消息进行单独设置，每条消息TTL可以不同。

如果同时使用，则消息的过期时间以两者之间TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的 TTL值，就成为dead letter

特性二：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

基础运行时序图：

Windows下安装Rabbit MQ在这里我就不细说了

大家可以参照下面这篇博客https://blog.csdn.net/m0_37034294/article/details/82839494

好，进入正题，搭建一个spring boot框架

然后添加 spring-boot-starter-amqp的依赖

pom.xml

<!--       添加 spring-boot-starter-amqp的依赖-->
        <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>

application.yml

#����rabbitmq�������
spring:
  rabbitmq:
    host: localhost
    port: 5672
    username: guest
    password: guest
  datasource:
    driver-class-name: com.mysql.cj.jdbc.Driver
    url: jdbc:mysql://localhost:3306/ktoa?useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC
    password: root
    username: root

创建订单实体类（pojo）

package com.hunt.springbootrabbitmq.pojo;

import lombok.Data;

import java.io.Serializable;

/**
 * 作者：HuntLee
 * 日期：2019-12-19 16:27
 * <p>
 * Hint：
 */
@Data
public class Order implements Serializable {
    private String orderId; // 订单id

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

    private String orderName; // 订单名字
}

接下来创建工具包开始配置队列（config）

在这里插入图片描述

DelayRabbitConfig.java

package com.hunt.springbootrabbitmq.config;

/**
 * 作者：HuntLee
 * 日期：2019-12-19 16:29
 * <p>
 * Hint：配置队列
 */
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


    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);
    }

}

DelayReceiver.java

package com.hunt.springbootrabbitmq.config;

/**
 * 作者：HuntLee
 * 日期：2019-12-19 16:34
 * <p>
 * Hint：接收者
 */


import com.hunt.springbootrabbitmq.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("【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("###########################################");
    }
}

DelaySender.java

package com.hunt.springbootrabbitmq.config;

/**
 * 作者：HuntLee
 * 日期：2019-12-19 16:35
 * <p>
 * Hint：发送者
 */


import com.hunt.springbootrabbitmq.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;

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

controller层

package com.hunt.springbootrabbitmq.controller;

/**
 * 作者：HuntLee
 * 日期：2019-12-19 16:36
 * <p>
 * Hint：
 */


import com.hunt.springbootrabbitmq.config.DelaySender;
import com.hunt.springbootrabbitmq.pojo.Order;
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;

@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("vivo");

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

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

查看控制台输出

在这里插入图片描述

HuntLee770090834

关注

1
点赞
踩
1

收藏

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

springboot整合RabbitMQ做延时队列延时队列的使用场景： 1.订单业务：在电商中，用户下单后30分钟后未付款则取消订单。 2.短信通知：用户下单并付款后，1分钟后发短信给用户。延时队列实现思路 AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是我们可以通过RabbitMQ的两个特性来曲线实现延迟队列：特性一：Time To Live(TTL)...
复制链接

扫一扫