RabbitMQ 延迟队列

最新推荐文章于 2024-03-21 22:34:23 发布
最新推荐文章于 2024-03-21 22:34:23 发布
阅读量276 收藏
点赞数
分类专栏： 消息队列 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_24991197/article/details/117997671
版权

概述

延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

TTL 是 RabbitMQ 中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间，单位是毫秒。换句话说，如果一条消息设置了 TTL 属性或者进入了设置 TTL 属性的队列，那么这条消息如果在 TTL 设置的时间内没有被消费，则会成为"死信"。如果同时配置了队列的 TTL 和消息的TTL，那么较小的那个值将会被使用，有两种方式设置 TTL。

  • 第一种是在创建队列的时候设置队列的“x-message-ttl”属性
  • 另一种方式便是针对每条消息设置 TTL

死信队列 和 TTL，至此利用 RabbitMQ 实现延时队列的两大要素已经集齐，接下来只需要将它们进行融合，再加入一点点调味料，延时队列就可以新鲜出炉了。想想看，延时队列，不就是想要消息延迟多久被处理吗，TTL 则刚好能让消息在延迟多久之后成为死信，另一方面，成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就完事了，因为里面的消息都是希望被立即处理的消息。

测试

<?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 https://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>2.1.8.RELEASE</version>
        <relativePath/> <!-- lookup parent from repository -->
    </parent>
    <groupId>com.bang</groupId>
    <artifactId>rabbitmq-springboot</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>rabbitmq-springboot</name>
    <description>延迟队列</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>

    <dependencies>
        <!--RabbitMQ 依赖-->
        <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.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
            <scope>test</scope>
        </dependency>
        <dependency>
            <groupId>com.alibaba</groupId>
            <artifactId>fastjson</artifactId>
            <version>1.2.47</version>
        </dependency>
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>
        <!--swagger-->
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger2</artifactId>
            <version>2.9.2</version>
        </dependency>
        <dependency>
            <groupId>io.springfox</groupId>
            <artifactId>springfox-swagger-ui</artifactId>
            <version>2.9.2</version>
        </dependency>
        <!--RabbitMQ 测试依赖-->
        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit-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>

修改配置文件

spring.rabbitmq.host=192.168.56.10
spring.rabbitmq.port=5672

添加 Swagger 配置类

@Configuration
@EnableSwagger2
public class SwaggerConfig {

    @Bean
    public Docket webApiConfig(){
        return new Docket(DocumentationType.SWAGGER_2)
                .groupName("webApi")
                .apiInfo(webApiInfo())
                .select().build();
    }
    private ApiInfo webApiInfo(){
        return new ApiInfoBuilder()
                .title("rabbitmq 接口文档")
                .description("本文档描述了 rabbitmq 微服务接口定义")
                .version("1.0")
                .contact(new Contact("renjianbang", "http://123.com",
                        "1115189918@qq.com"))
                .build();
    }
    
}

创建两个队列 QA 和 QB，两者队列 TTL 分别设置为 10S 和 40S，然后在创建一个交换机 X 和死信交换机 Y，它们的类型都是 direct，创建一个死信队列 QD，它们的绑定关系如下：

在这里插入图片描述
配置文件类代码

@Configuration
public class TtlQueueConfig {
    public static final String X_EXCHANGE = "X";
    public static final String QUEUE_A = "QA";
    public static final String QUEUE_B = "QB";
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String DEAD_LETTER_QUEUE = "QD";
    // 声明 xExchange
    @Bean("xExchange")
    public DirectExchange xExchange(){
        return new DirectExchange(X_EXCHANGE);
    }
    // 声明 yExchange
    @Bean("yExchange")
    public DirectExchange yExchange(){
        return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
    }

    //声明队列 A ttl 为 10s 并绑定到对应的死信交换机
    @Bean("queueA")
    public Queue queueA(){
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 10000);
        return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
    }
    // 声明队列 A 绑定 X 交换机
    @Bean
    public Binding queueaBindingX(@Qualifier("queueA") Queue queueA,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueA).to(xExchange).with("XA");
    }
    //声明队列 B ttl 为 40s 并绑定到对应的死信交换机
    @Bean("queueB")
    public Queue queueB(){
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //声明队列的 TTL
        args.put("x-message-ttl", 40000);
        return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
    }
    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queue1B).to(xExchange).with("XB");
    }
    //声明死信队列 QD
    @Bean("queueD")
    public Queue queueD(){
        return new Queue(DEAD_LETTER_QUEUE);
    }
    //声明死信队列 QD 绑定关系
    @Bean
    public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
                                        @Qualifier("yExchange") DirectExchange yExchange){
        return BindingBuilder.bind(queueD).to(yExchange).with("YD");
    }

}

消息生产者代码

@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    @GetMapping("sendMsg/{message}")
    public void sendMsg(@PathVariable String message){
        log.info("当前时间：{},发送一条信息给两个 TTL 队列:{}", new Date(), message);
        rabbitTemplate.convertAndSend("X", "XA", "消息来自 ttl 为 10S 的队列: "+message);
        rabbitTemplate.convertAndSend("X", "XB", "消息来自 ttl 为 40S 的队列: "+message);
    }
}

消息消费者代码

@Slf4j
@Component
public class DeadLetterQueueConsumer {

    @RabbitListener(queues = "QD")
    public void receiveD(Message message, Channel channel) throws IOException {
        String msg = new String(message.getBody());
        log.info("当前时间：{},收到死信队列信息{}", new Date().toString(), msg);
    }

}

发起一个请求 http://localhost:8080/ttl/sendMsg/消息内容

在这里插入图片描述

第一条消息在 10S 后变成了死信消息，然后被消费者消费掉，第二条消息在 40S 之后变成了死信消息，然后被消费掉，这样一个延时队列就打造完成了。

不过，如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S两个时间选项，如果需要一个小时后处理，那么就需要增加 TTL 为一个小时的队列，如果是预定会议室然后提前通知这样的场景，岂不是要增加无数个队列才能满足需求？

延时队列优化

在这里新增了一个队列 QC,绑定关系如下,该队列不设置 TTL 时间，这样就不用每增加一个新的时间需求，就新增一个队列了
在这里插入图片描述
配置文件类代码

@Component
public class MsgTtlQueueConfig {
    public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
    public static final String QUEUE_C = "QC";

    // 声明队列 C 死信交换机
    @Bean("queueC")
    public Queue queueC() {
        Map<String, Object> args = new HashMap<>(3);
        //声明当前队列绑定的死信交换机
        args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
        //声明当前队列的死信路由 key
        args.put("x-dead-letter-routing-key", "YD");
        //没有声明 TTL 属性
        return QueueBuilder.durable(QUEUE_C).withArguments(args).build();
    }

    //声明队列 B 绑定 X 交换机
    @Bean
    public Binding queuecCindingX(@Qualifier("queueC") Queue queueC,
                                  @Qualifier("xExchange") DirectExchange xExchange){
        return BindingBuilder.bind(queueC).to(xExchange).with("XC");
    }
}

消息生产者代码

    @GetMapping("sendExpirationMsg/{message}/{ttlTime}")
    public void sendMsg2(@PathVariable String message,@PathVariable String ttlTime) {
        rabbitTemplate.convertAndSend("X", "XC", message, correlationData ->{
            correlationData.getMessageProperties().setExpiration(ttlTime);
            return correlationData;
        });
        log.info("当前时间：{},发送一条时长{}毫秒 TTL 信息给队列 C:{}", new Date(),ttlTime, message);
    }

发起请求
http://localhost:8080/ttl/sendExpirationMsg/你好 1/20000

在这里插入图片描述

按理说应该时间短的会先到，但是使用在消息属性上设置 TTL 的方式，消息可能并不会按时“死亡“，因为 RabbitMQ 只会检查第一个消息是否过期，如果过期则丢到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

Rabbitmq 插件实现延迟队列

如果不能实现在消息粒度上的 TTL，并使其在设置的 TTL 时间及时死亡，就无法设计成一个通用的延时队列。那如何解决呢，接下来我们就去解决该问题。

在官网上下载 https://www.rabbitmq.com/community-plugins.html，下载rabbitmq_delayed_message_exchange 插件，然后解压放置到 RabbitMQ 的插件目录。

进入 RabbitMQ 的安装目录下的 plgins 目录，执行下面命令让该插件生效，然后重启 RabbitMQ

/usr/lib/rabbitmq/lib/rabbitmq_server-3.8.8/plugins
rabbitmq-plugins enable rabbitmq_delayed_message_exchange

在这里插入图片描述

在这里新增了一个队列 delayed.queue,一个自定义交换机 delayed.exchange，绑定关系如下:

在这里插入图片描述

配置文件类代码

在我们自定义的交换机中，这是一种新的交换类型，该类型消息支持延迟投递机制 消息传递后并不会立即投递到目标队列中，而是存储在 mnesia(一个分布式数据系统)表中，当达到投递时间时，才投递到目标队列中。

@Configuration
public class DelayedQueueConfig {
	 public static final String DELAYED_QUEUE_NAME = "delayed.queue";
	 public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
	 public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
	 @Bean
	 public Queue delayedQueue() {
		 return new Queue(DELAYED_QUEUE_NAME);
	 }
	 //自定义交换机 我们在这里定义的是一个延迟交换机
	 @Bean
	 public CustomExchange delayedExchange() {
		 Map<String, Object> args = new HashMap<>();
		 //自定义交换机的类型
		 args.put("x-delayed-type", "direct");
		 return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false, args);
	 }
	 @Bean
	 public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue, @Qualifier("delayedExchange") CustomExchange delayedExchange) {
	 	return BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
	 }
}

消息生产者代码

public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
@GetMapping("sendDelayMsg/{message}/{delayTime}")
public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime) {
	 rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message, 
	correlationData ->{
		 correlationData.getMessageProperties().setDelay(delayTime);
		 return correlationData;
	 });
	 log.info(" 当 前 时 间 ： {}, 发送一条延迟 {} 毫秒的信息给队列 delayed.queue:{}", new 
	Date(),delayTime, message);
}

消息消费者代码

public static final String DELAYED_QUEUE_NAME = "delayed.queue";
@RabbitListener(queues = DELAYED_QUEUE_NAME)
public void receiveDelayedQueue(Message message){
	 String msg = new String(message.getBody());
	 log.info("当前时间：{},收到延时队列的消息：{}", new Date().toString(), msg);
}

延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过 RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或者消息丢失。当然，延时队列还有很多其它选择，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz或者利用 kafka 的时间轮，这些方式各有特点,看需要适用的场景

发起请求：

http://localhost:8080/ttl/sendDelayMsg/come on baby1/20000
http://localhost:8080/ttl/sendDelayMsg/come on baby2/2000

在这里插入图片描述
第二个消息被先消费掉了，符合预期

﹏天微亮ミ夜微凉╮
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
RabbitMQ中延迟队列的全方位解析
lt_xiaodou的博客
08-30 1298
工作中有些场景需要用到延迟队列，大概对RabbitMQ延迟队列场景有一些了解，网上大部分的场景应用于：订单超时、定时执行等。而我需要延迟队列的场景是：有一批机器需要监控这个延迟队列长度，一旦满足就提前预备机器，准备执行任务。通过监控延迟队列，我可以准确、可靠的清楚，接下来的某个时间我一定会执行哪些任务。相较于传统通过API来唤醒设备，提升了稳定性。我只需要关注一点：发布消息。同时也了解到，大部分使用RabbitMQ实现延迟队列从两个方向入手：接下来，我将会从这两个方向逐一进行，分析利弊。阅读本文，你将获得：
RabbitMQ 的延时队列和镜像队列原理与实战
weixin_34210740的博客
05-05 367
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ的延迟队列机制
qq_39794062的博客
06-25 1902
一、延迟队列 延时队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望 在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。 二、队列TTL 创建一个配置类，声明并配置交换机和队列 @Configuration public class TtlQueueConfig { //普通交换机名称 public static final String NORMAL_EXCHANGE = "X"; //死信交换机名称
RabbitMQ延时队列原理讲解
Leon_Jinhai_Sun的博客
05-10 7626
RabbitMQ延时消息队列 延时队列介绍 延时队列即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。 那么，为什么需要延迟消费呢？我们来看以下的场景 网上商城下订单后30分钟后没有完成支付，取消订单(如：淘宝、去哪儿网)系统创建了预约之后，需要在预约时间到达前一小时提醒被预约的双方参会系统中的业务失败之后，需要重试这些场景都非常常见，我们可以思考，比如第二个需求，系统创建了预约之后，需要在预约时间到达前一小时提醒被预约的双方参会。那么一天之中肯定是会有很多个预约的，时间也是
【RabbitMq04】延迟队列
weixin_40964170的博客
07-29 2117
一、延迟队列理解 1、延迟队列概念 延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列 延迟队列，就是死信队列中，TTL消息过期的一种 举例 如死信队列文章中所讲，消费者1启动后，在rabbitmq控制台生成正常队列和死信队列后就又关闭了，然后开启生产者给消费者1发送消息，因为消费者1中设置了TTL消息过期机制，所以等了10秒种消息就自动进入到死信队列了，消息被消费者2接
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
RabbitMQ 延迟队列及消息延迟推送实现详解 RabbitMQ 延迟队列及消息延迟推送实现详解是指在 RabbitMQ 中实现消息延迟推送的功能，即在指定的时间后推送消息到目标队列中。这种机制在实际应用中非常有价值，如在淘宝...
rabbitMQ延迟队列
03-15
RabbitMQ延迟队列是一种特殊类型的队列，它允许消息在特定时间后才被消费者处理，而不是立即处理。这种功能在某些业务场景下非常有用，例如订单超时处理、定时发送邮件或短信通知等。在RabbitMQ中，实现延迟队列通常...
rabbitmq 延迟队列插件 rabbitmq_delayed_message_exchange_3.8.17
04-11
rabbitmq 延迟队列插件 rabbitmq_delayed_message_exchange_3.8.17 解压即用 输入命令进行安装 .\rabbitmq-plugins enable rabbitmq_delayed_message_exchange
如何通过Python实现RabbitMQ延迟队列
01-19
因为系统本身一直在用RabbitMQ做异步处理任务的中间件，所以想到是否可以利用RabbitMQ实现延迟队列。功夫不负有心人，RabbitMQ虽然没有现成可用的延迟队列，但是可以利用其两个重要特性来实现之：1、Time To Live...
Rabbitmq延迟队列实现定时任务的方法
08-27
RabbitMQ 延迟队列实现定时任务的方法 RabbitMQ 延迟队列是一种实现定时任务的方法，它可以帮助我们在指定的时间点执行某个任务。这种方法可以应用在很多场景中，例如：在电子商城中，需要在指定的时间点关闭订单、...
RabbitMQ--延迟队列--使用/原理
IT利刃出鞘的博客
12-02 2693
本文介绍RabbitMQ的延迟队列的用法。 本内容也是Java后端面试中常见的问题。
【学习笔记】RabbitMQ04：延迟队列的原理以及实现代码
Xcong_Zhu的博客
10-17 1260
正常的MQ应用场景中，我们希望消息可以快速稳定的传递。但是有一些场景中，希望在指定的延迟后再消费信息，比如订单支付场景（订单15部分内未支付则关闭订单）。这类实现延迟任务的场景，就可以采用延迟队列来实现。以下介绍一下其他的一些方法。
RabbitMq 实现延迟队列
chenpeng4623的博客
05-09 298
欢迎转载分享，转载请注明出处。 如有问题欢迎指正 更多实时文章请关注公众号：WTF名字好难取 推荐书籍：《RabbitMQ实战指南 》朱忠华 。欢迎购买正版书籍。 想要 电子版参考的小伙伴，可以关注公众号 【WTF名字好难取】回复，【推荐书籍】，获取下载地址。 本文参考：《RabbitM...
RabbitMQ之“延时队列”
最新发布
2302_77971734的博客
03-21 2139
延迟队列存储的对象是对应的延迟消息，所谓“延迟消息”是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费
rabbitmq延迟队列实现
weixin_45967375的博客
04-15 191
延迟队列 Rabbitmq并没有延迟队列 但是：死信队列+消息时间设置过期时间可以 达成我们想要的延迟队列效果 例如下单5分钟之内未支付就会取消订单，那么设置下单支付时间为5分钟后过期然后进入私信队列，一旦进入私信队列那么就自动取消订单 代码 消费者： @Component public class ttlproducer { @Autowired private RabbitTemplate rabbitTemplate; // 模拟订单 public void mak
RabbitMQ延迟消息的延迟极限是多少？
weixin_30527323的博客
07-22 613
之前在写Spring Cloud Stream专题内容的时候，特地介绍了一下如何使用RabbitMQ的延迟消息来实现定时任务。最近正好因为开发碰到了使用过程中发现，延迟消息没有效果，消息直接就被消费了的情况。因此就继续深入研究了一下问题原因，在此记录下来，给碰到类似问题的童鞋们参考。 问题定位 因为不是所有的消息都出现了没有延迟消息效果的因素，通过有问题的消息特征，大致猜测可能是延迟时间过长导致了...
RabbitMQ延迟队列插件原理及改进方式
loseyourself94的博客
03-02 553
RabbitMQ延迟队列插件原理及改进方式
RabbitMQ延时队列
chenwucsdn的博客
08-02 390
MQConfig @Configuration @ConditionalOnProperty(name = "spring.rabbitmq.addresses", havingValue = "") public class MQConfig implements RabbitListenerConfigurer { public static final String Q...
RabbitMQ死信队列、延迟队列原理实战
2302_76363587的博客
02-20 786
什么是TTL什么是RabbitMQ的死信队列什么是RabbitMQ的死信交换机消息有哪几种情况成为死信消费者拒收消息（），并且没有重新入队消息在队列中未被消费，且超过队列或者消息本身的过期时间队列的消息长度达到极限结果：消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队列。
rabbitmq延迟队列插件
07-27
RabbitMQ延迟队列插件是一种用于实现延迟消息传递的插件。您可以通过下载并安装rabbitmq-delayed-message-exchange插件来使用它。首先，您需要从https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases下载插件。然后，将rabbitmq_delayed_message_exchange-3.9.0.ez插件上传到您的RabbitMQ安装目录下的plugins目录中。接下来，您需要进入RabbitMQ的安装目录下的plugins目录，并执行命令使插件生效。最后，重启RabbitMQ使插件生效。如果您是在Docker容器中安装的RabbitMQ，您可以将插件拷贝到容器内的plugins目录中，并进入容器执行相应的命令来启用插件。请确保在启用插件之前，您已经检查了插件是否存在，并在启用插件后重启了RabbitMQ容器。 #### 引用[.reference_title] - *1* *3* [RabbitMQ延迟队列实现 ( 插件版 )](https://blog.csdn.net/weixin_42950079/article/details/125753894)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] - *2* [Rabbitmq插件实现延迟队列](https://blog.csdn.net/m0_62436868/article/details/126074832)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v91^insertT0,239^v3^insert_chatgpt"}} ] [.reference_item] [ .reference_list ]
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值