RabbitMQ死信队列应用场景之模拟未支付订单自动取消

最新推荐文章于 2024-07-05 04:00:00 发布
最新推荐文章于 2024-07-05 04:00:00 发布
阅读量5k 收藏 34
点赞数 11
分类专栏： # RabbitMQ 文章标签： 超时自动取消订单 未支付取消订单 RabbitMQ 死信队列应用场景
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Weixiaohuai/article/details/97268109
版权

一、简介

在前面的博客中已经介绍了死信队列的使用方法，具体可以参考https://blog.csdn.net/Weixiaohuai/article/details/94760975这篇文章。

      场景介绍：我们都经常在淘宝上买东西，当我们提交订单后，如果某个时间段之内我们没有支付，淘宝肯定不会帮我们一直保留那个订单，如果超过半个小时我们未支付的话，淘宝会自动帮我们取消订单。在没有用RabbitMQ消息队列之前，我们可以通过设置一个定时任务，设定一个定时规则去轮询数据库查询超过半个小时而且未支付的订单，然后修改订单状态为已取消，这也是一个解决方案，但是需要轮询数据库，增加了对数据库的压力。

       在学习了死信队列之后，其实这种场景可以使用死信队列来做，就是用户提交订单之后，发送一条消息并且设置消息过期时间为半个小时(或其他时间)，如果超过设置的这个时间，那么消息自动变成死信，就会被转发到死信队列中，这时候我们可以监听死信队列中的消息，然后查询一下订单的状态，如果还是未支付的话，那么更新订单的状态为已取消。

 

二、示例

本文采用springboot + mybatis实现。

【a】pom.xml依赖：

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>1.5.21.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.wsh.springboot</groupId>
    <artifactId>springboot_rabbitmq_deadqueue_demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>springboot_rabbitmq_deadqueue_demo</name>
    <description>Demo project for Spring Boot</description>

    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <dependency>
            <groupId>org.mybatis.spring.boot</groupId>
            <artifactId>mybatis-spring-boot-starter</artifactId>
            <version>1.3.3</version>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

        <dependency>
            <groupId>mysql</groupId>
            <artifactId>mysql-connector-java</artifactId>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
    </dependencies>

    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
            </plugin>
        </plugins>
    </build>

</project>

【b】application.yml配置文件：

server:
  port: 9099
spring:
  application:
    name: rabbitmq_deadqueue_demo
  rabbitmq:
    host: localhost
    virtual-host: /vhost
    username: wsh
    password: wsh
    publisher-confirms: true
    port: 5672
  datasource:
    username: root
    password: wsh0905
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://127.0.0.1:3306/rabbitmq_dead_queue?characterEncoding=utf8

mybatis:
  mapper-locations: classpath:mapping/*Mapper.xml
  type-aliases-package: com.example.entitycom.wsh.springboot.springboot_rabbitmq_deadqueue_demo.entity

logging:
  level:
    com:
      example:
        mapper : debug

【c】数据库表创建脚本：

/*
SQLyog Ultimate v11.24 (32 bit)
MySQL - 5.5.44 : Database - rabbitmq_dead_queue
*********************************************************************
*/


/*!40101 SET NAMES utf8 */;

/*!40101 SET SQL_MODE=''*/;

/*!40014 SET @OLD_UNIQUE_CHECKS=@@UNIQUE_CHECKS, UNIQUE_CHECKS=0 */;
/*!40014 SET @OLD_FOREIGN_KEY_CHECKS=@@FOREIGN_KEY_CHECKS, FOREIGN_KEY_CHECKS=0 */;
/*!40101 SET @OLD_SQL_MODE=@@SQL_MODE, SQL_MODE='NO_AUTO_VALUE_ON_ZERO' */;
/*!40111 SET @OLD_SQL_NOTES=@@SQL_NOTES, SQL_NOTES=0 */;
CREATE DATABASE /*!32312 IF NOT EXISTS*/`rabbitmq_dead_queue` /*!40100 DEFAULT CHARACTER SET utf8 */;

USE `rabbitmq_dead_queue`;

/*Table structure for table `order_info` */

DROP TABLE IF EXISTS `order_info`;

CREATE TABLE `order_info` (
  `pkid` varchar(50) NOT NULL COMMENT '主键ID',
  `order_id` varchar(50) DEFAULT NULL COMMENT '订单ID',
  `order_status` varchar(10) DEFAULT NULL COMMENT '订单状态 0：未支付  1：已支付 2 已取消',
  PRIMARY KEY (`pkid`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8;

/*!40101 SET SQL_MODE=@OLD_SQL_MODE */;
/*!40014 SET FOREIGN_KEY_CHECKS=@OLD_FOREIGN_KEY_CHECKS */;
/*!40014 SET UNIQUE_CHECKS=@OLD_UNIQUE_CHECKS */;
/*!40111 SET SQL_NOTES=@OLD_SQL_NOTES */;

【d】实体类：

import java.io.Serializable;

public class OrderInfo implements Serializable {
    private String pkid;
    private String orderId;
    private String orderStatus;

    public String getPkid() {
        return pkid;
    }

    public void setPkid(String pkid) {
        this.pkid = pkid;
    }

    public String getOrderId() {
        return orderId;
    }

    public void setOrderId(String orderId) {
        this.orderId = orderId;
    }

    public String getOrderStatus() {
        return orderStatus;
    }

    public void setOrderStatus(String orderStatus) {
        this.orderStatus = orderStatus;
    }
}

【e】Mybatis Mapper接口：

@Repository
public interface OrderInfoMapper {

    String findByOrderStatus(@Param("orderId") String orderId);

    void updateOrderStatus(@Param("orderId") String orderId);

    void saveOrderInfo(@Param("pkid") String pkid, @Param("orderId") String orderId, @Param("orderStatus") String orderStatus);
}

【f】Mapper.xml：

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN" "http://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.wsh.springboot.springboot_rabbitmq_deadqueue_demo.repository.OrderInfoMapper">

    <select id="findByOrderStatus" resultType="String">
      select order_status from order_info where order_id = #{orderId}
    </select>

    <update id="updateOrderStatus">
          update order_info t set t.order_status = '2' where t.order_id = #{orderId}
    </update>

    <insert id="saveOrderInfo">
        insert into order_info(pkid,order_id,order_status) values(#{pkid},#{orderId},#{orderStatus})
    </insert>

</mapper>

【g】启动类加上扫描mapper路径：

@SpringBootApplication
//扫描的mapper文件路径
@MapperScan("com.wsh.springboot.springboot_rabbitmq_deadqueue_demo.repository")
public class SpringbootRabbitmqDeadqueueDemoApplication {

    public static void main(String[] args) {
        SpringApplication.run(SpringbootRabbitmqDeadqueueDemoApplication.class, args);
    }

}

【h】RabbitMQ配置类：

import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;

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

/**
 * @Description: RabbitMQ配置类
 * @Author: weixiaohuai
 * @Date: 2019/7/24
 * @Time: 20:59
 * <p>
 */
@Component
public class RabbitMQConfig {
    private static final String DEAD_LETTERS_QUEUE_NAME = "dead_letters_queue_name";
    private static final String DEAD_LETTERS_EXCHANGE_NAME = "dead_letters_exchange_name";
    private static final String QUEUE_NAME = "test_dlx_queue_name";
    private static final String EXCHANGE_NAME = "test_dlx_exchange_name";
    private static final String ROUTING_KEY = "order.add";

    /**
     * 声明死信队列、死信交换机、绑定队列到死信交换机
     * 建议使用FanoutExchange广播式交换机
     */
    @Bean
    public Queue deadLettersQueue() {
        return new Queue(DEAD_LETTERS_QUEUE_NAME);
    }

    @Bean
    public FanoutExchange deadLettersExchange() {
        return new FanoutExchange(DEAD_LETTERS_EXCHANGE_NAME);
    }

    @Bean
    public Binding deadLettersBinding() {
        return BindingBuilder.bind(deadLettersQueue()).to(deadLettersExchange());
    }

    /**
     * 声明普通队列，并指定相应的备份交换机、死信交换机
     */
    @Bean
    public Queue queue() {
        Map<String, Object> arguments = new HashMap<>(10);
        //指定死信发送的Exchange
        arguments.put("x-dead-letter-exchange", DEAD_LETTERS_EXCHANGE_NAME);
        return new Queue(QUEUE_NAME, true, false, false, arguments);
    }

    @Bean
    public Exchange exchange() {
        return new DirectExchange(EXCHANGE_NAME, true, false, null);
    }

    @Bean
    public Binding binding() {
        return BindingBuilder.bind(queue()).to(exchange()).with(ROUTING_KEY).noargs();
    }

}

【i】生产者：

import com.wsh.springboot.springboot_rabbitmq_deadqueue_demo.repository.OrderInfoMapper;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.util.UUID;

@Component
public class Producer {
    private static final String EXCHANGE_NAME = "test_dlx_exchange_name";
    private static final String ROUTING_KEY = "order.add";

    @Autowired
    private RabbitTemplate rabbitTemplate;
    @Autowired
    private OrderInfoMapper orderInfoMapper;

    /**
     * 发送消息
     */
    public void send() {
        MessagePostProcessor messagePostProcessor = message -> {
            MessageProperties messageProperties = message.getMessageProperties();
            // 设置编码
            messageProperties.setContentEncoding("utf-8");
            // 设置过期时间(60秒过期)
            int expiration = 1000 * 60;
            messageProperties.setExpiration(String.valueOf(expiration));
            return message;
        };

        //模拟创建五条订单消息
        for (int i = 0; i < 5; i++) {
            String orderId = String.valueOf(i);
            //订单初始化状态都为未支付
            orderInfoMapper.saveOrderInfo(UUID.randomUUID().toString(), String.valueOf(i), "0");
            rabbitTemplate.convertAndSend(EXCHANGE_NAME, ROUTING_KEY, orderId, messagePostProcessor, new CorrelationData(UUID.randomUUID().toString()));
        }
    }

}

【j】消费者：

import com.rabbitmq.client.Channel;
import com.wsh.springboot.springboot_rabbitmq_deadqueue_demo.repository.OrderInfoMapper;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import java.io.IOException;
import java.nio.charset.StandardCharsets;

/**
 * @Description: RabbitMQ消费者
 * @Author: weixiaohuai
 * @Date: 2019/7/24
 * @Time: 20:59
 * <p>
 */
@Component
public class Consumer {

    private static final Logger logger = LoggerFactory.getLogger(Consumer.class);
    @Autowired
    private OrderInfoMapper orderInfoMapper;

    @RabbitListener(queues = "dead_letters_queue_name")
    public void handler(Message message, Channel channel) throws IOException {
        /**
         * 发送消息之前，根据订单ID去查询订单的状态，如果已支付不处理，如果未支付，则更新订单状态为取消状态。
         */

        // 从队列中取出订单号
        byte[] body = message.getBody();
        String orderId = new String(body, StandardCharsets.UTF_8);
        logger.info("消费者接收到订单：" + orderId);
        String orderStatus = orderInfoMapper.findByOrderStatus(orderId);
        logger.info("订单状态： " + orderStatus);
        if (!"1".equals(orderStatus)) {
            //取消订单
            orderInfoMapper.updateOrderStatus(orderId);
        }
        channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
    }

}

【k】测试用例：

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringbootRabbitmqDeadqueueDemoApplicationTests {

    @Autowired
    private Producer producer;

    @Test
    public void contextLoads() {
        producer.send();
    }

}

【m】运行结果：

这里设置订单一分钟未支付就算过期，然后监听死信队列，只要有消息，去数据库查询订单状态，如果仍然未支付，那么更新订单状态为已取消，并且发送ack确认应答给mq。

假设创建完成五个订单之后，在一分钟之内，手动修改数据库中两个订单的订单状态为已支付(这里只是为了测试，实际肯定是调用支付接口进行支付的),观察另外三个订单的状态是否在一分钟之后都被更新为已取消了。

手动修改2号和4号订单的状态为已支付，假设他们在一分钟之内已经付过款了。

一分钟之后，观察控制台输出：

可见，消费者成功接收到五条消息，并且再次查询数据库之后，发现0号，1号，3号订单状态都被取消了，而2号、4号因为已经支付过，所以状态为已支付的。

 

三、总结

思路总结：

  • 声明队列的时候指定参数 “ x-dead-letter-exchange ” 对应 死信路由器（dlx_exchange）；

  • 发送消息的时候指定消息的过期时间为30分钟(或者其他时间)，这样消息超过30分钟未消费就变为死信消息；

  • 生产者发送消息到交换机 ，等待30分钟后，会去绑定的死信路由（dlx_exchange），然后被转发到死信队列；

  • 然后我们通过监听死信队列的消息，查询该订单是否支付，如果没有支付，则取消该订单；

本文通过一个简单的示例说明了死信队列在自动取消未支付订单场景下的使用方法，希望能对大家有所帮助。

 

 

 

每天都要进步一点点
关注
专栏目录
rabbitmq死信队列详解与使用
congge
08-28 14万+
什么是死信队列 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信，自然就有了死信队列； 以上是个人的通俗解释，专业术语解释的比...
Springboot+RabbitMQ实现订单超时未支付，取消订单(实战+源码下载)
雾林小妖的博客
11-08 845
Springboot整合RabbitMQ,通过使用RabbitMQ的延时队列，死信队列等实现当订单超时后取消订单，预约超时取消预约，审批超时取消审批或发送短信或邮件消息等。
消息队列之自动取消已放弃的订单
weixin_53410590的博客
06-17 357
今天我们来看另一个需要借助消息队列异步处理的业务场景 —— 自动取消已经放弃的订单。在网上购物商城，我们需要为已经下单的实体商品订单（尤其是限量的抢购订单，或者需要依赖商家及时响应的外卖订单）设置支付有效期，以免用户下单后长时间不支付，或者根本不打算支付，而又没有手动取消，白白占用了库存额度，让其他想买的用户无法购买。有了支付有效期后（通常是 15 分钟、半小时或者一小时），超过这个有效期，我们就认为用户放弃这个订单了，然后系统会自动取消这个订单，释放对应库存。显然，这可以通过 Laravel 消息队列提供
RabbitMQ 死信队列应用
花未央D8023的博客
01-31 1213
消息可能会因为多种原因变成“死信”，例如消息过期、消息被拒绝、消息队列长度超过限制等。若参数requeue为true，则表示还可以将此跳消息重新塞回普通队列，若为false则消息被拒绝后直接进入死信队列。当普通队列中消息堆积数量长度达到了maxLength，则会将新接收的消息转发到死信队列中去，从而避免消息丢失。在生产者设置生产时设置，若消费者未在过期时间内消费消息，则消息被转发到死信队列中。（"x-message-ttl"）延迟消息处理：实现延迟消息投递，例如实现消息的定时投递、消息重试机制等。
RabbitMQ 详解：概念、结构、使用场景与常用命令
最新发布
CloudJourney的博客
07-05 924
例如，图像处理系统可以将图像处理任务发送到RabbitMQ，多个图像处理节点从RabbitMQ中接收并处理任务，提高系统的并行处理能力。例如，物联网系统可以将传感器数据发送到RabbitMQ，实时数据处理系统从RabbitMQ中接收并处理传感器数据。例如，用户服务可以将用户注册消息发送到RabbitMQ，通知服务和邮件服务分别从RabbitMQ中接收并处理用户注册消息。例如，订单系统可以将订单消息发送到RabbitMQ，支付系统和物流系统分别从RabbitMQ中接收并处理订单消息。
史上最全 RabbitMQ入门教程，从零开始带你深入♂学习（十一）——死信队列
爱分享的板栗老哥
08-17 570
RabbitMQ（十一）——死信队列 死信队列简介 先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到 queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息
MQ死信队列的应用场景
AAA821的专栏
01-25 6130
 转自：https://blog.csdn.net/zhanghan18333611647/article/details/79519085  二、用代码进行相关测试：                1、生产者进行添加，20s后不进行消费，发现消息从正常的队列进入了死信队列；                2、生产者进行添加，消费者进行消费；                3、设置死信队列...
死信队列、延时队列的应用场景
tiankongzhouye的博客
01-06 216
交换机将从延时队列接收到的消息通过路由键 stock.release 发送到stock.release.stock.queue。延时队列TTL时间到了 发送消息到 stock-event-exchange 通过另一个路由键 stock.release。交换机通过路由键 stock.locked 发送消息到 延时队列 stock.delay.queue。发送消息给交换机 stock-event-exchange。我们监听stock.release.stock.queue。场景一: 库存解锁服务。
RabbitMQ死信队列应用1
08-03
RabbitMQ死信队列（Dead Letter Exchange, DLX）是一种高级特性，用于处理那些无法正常处理或过期的消息。当消息在业务队列中处理失败，如因异常导致重试次数达到上限，就会变为死信。DLX允许将这些死信重新发布到另...
RabbitMQ的死信队列和延时队列
DMaker1993的博客
12-26 3343
本文介绍并实战RabbitMQ的死信队列，以及通过RabbitMQ如何实现延时队列。
RabbitMQ的延时队列和死信队列
hkl_Forever的博客
11-18 1868
1、在 RabbitMQ 中，没有严格意义上的死信队列，所谓死信队列和正常队列没有太大区别，都是需要创建自己的Exchange、Routingkey、Queue，只不过死信队列的 Exchange 和 RoutingKey 要作为参数绑定到正常队列(也可能是延时队列)上，根据参数策略决定是否进入死信队列。2、死信队列和延时队列可以相互调换使用，例如先发送消息给延时队列(其中配置的有延时策略)，当消息达到延长的时间后，再丢入正常的业务队列中。【3】超时、超过队列最大容量(溢出)的消息，也会进入死信队列。
使用RabbitMQ死信队列关闭未支付的订单
lovoo的博客
06-26 2762
RabbitMQ死信队列（Dead-Letter Exchange，简称DLX）是一种特殊类型的交换机，用于处理在队列中无法被消费的消息。当消息无法被消费时，它会被转发到死信队列中，以便进一步处理。消息无法被消费者处理：例如，如果消费者崩溃或消息的格式不正确，则无法处理消息。此时，消息将被发送到死信队列进行进一步处理。消息的优先级较低：如果消息的优先级较低，则可能无法在队列中得到及时处理。在这种情况下，消息也会被发送到死信队列中，以确保它最终被处理。
RabbitMQ场景应用-死信队列模拟未支付订单自动取消
专业的计算机毕业设计指南
11-03 1113
1.简介 场景介绍： 我们都经常在淘宝上买东西，当我们提交订单后，如果某个时间段之内我们没有支付，淘宝肯定不会帮我们一直保留那个订单，如果超过半个小时我们未支付的话，淘宝会自动帮我们取消订单。在没有用RabbitMQ消息队列之前，我们可以通过设置一个定时任务，设定一个定时规则去轮询数据库查询超过半个小时而且未支付的订单，然后修改订单状态为已取消，这也是一个解决方案，但是需要轮询数据库，增加了对数据...
死信队列理解与使用
weixin_45326523的博客
08-28 1087
死信队列；rabbitMQ
[MQ] 死信队列介绍与场景描述
沫洺的博客
11-20 2320
死信队列介绍与场景描述
Spring Boot利用RabbitMQ的死信队列实现定时任务,如超时未支付,自动取消订单等等......
a870368162的博客
08-14 4000
本文不介绍如何整合消息队列,有需要请参考我之前发布:https://blog.csdn.net/a870368162/article/details/99566685 RabbitMQ死信队列 RabbitMQ要实现延时任务，需要使用RabbitMQ的死信交换机（Exchange）和消息的存活时间TTL（Time To Live）来实现 死信交换机 死信交换机跟普通交换机一样,只是这个交换机用来存...
RabbitMQ死信队列在实际业务场景中的运用
撸起袖子加油干
05-25 4317
一、先来了解一下啥是死信队列： 这篇博客，是基于大家有消息队列使用经验的同学，如果没有使用经验的，可以学习一下消息队列，主流的AMQ，RMQ，KAFKA等等 死信队列：没有被及时消费的消息存放的队列，消息没有被及时消费有以下几点原因： a.消息被拒绝（basic.reject/ basic.nack）并且不再重新投递 requeue=false b.TTL(time-to-live) 消息超时未消费 c.达到最大队列长度 ...
RabbitMQ死信队列应用
长沙老码农
02-05 6589
目录 1、什么是死信队列 2、死信队列应用场景 3、延迟消息概念 3.1 消息的TTL（Time To Live） 3.2 死信交换器 3.3 延时队列 4、死信队列使用流程图 5、死信队列应用（管理控制台） 6、死信队列应用（Java代码） 6.1 RabbitMQ原生API 6.2 SpringBoot集成RabbitMQ 1、什么是死信队列 DLX, Dead-Letter-Exchange。利用DLX, 当消息在一个队列中因为业务队列处理失败(比如抛异常并且达到了re.
【分布式】Rabbitmq死信队列模型、实战场景---订单延迟30min支付处理
a23452的博客
09-18 2157
延时、延迟处理指定的业务逻辑 ---- 在实际生产中非常常见， 比如商城订单完成之后，用户如果一直没有评价，5天后自动好评，会员到期前15天、某个业务到期前X天提示 【 ECS最近给我提示麻了】， 延迟处理的业务逻辑， 之前就是定时器扫表， 但是这样子性能太低了，数据库压力大，RabbitMQ的延迟队列就可以解决
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值