RabbitMQ之延时队列

已于 2022-03-19 20:15:58 修改
阅读量1.4k 收藏 2
点赞数
分类专栏： rabbitmq 文章标签： rabbitmq
于 2021-11-26 11:28:14 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_43654581/article/details/121555502
版权
本文通过Spring RabbitMQ配置展示了如何实现延时队列功能，利用死信队列在指定时间后处理消息。首先创建普通队列并设置消息过期时间，当消息未在规定时间内被消费则转发至死信队列。此外，还演示了如何针对单条消息设置过期时间，进一步细化延时控制。
摘要由CSDN通过智能技术生成

延时队列

延时队列：一般来说，发布消息之后，会被交换机接收并转发给对应的队列，队列分配给消费者处理，这个过程很快秒级处理；但有时候我们希望发布完消息后，在指定的时间之后再去处理消息，这个时候就需要使用到延时队列；
虽说是延时队列，但其实也只是对死信队列的一种扩展应用罢了。

在这里插入图片描述

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

首先还是得创建普通队列，添加参数绑定死信队列同时设置消息过期时间，生产者发布消息到普通队列，而普通队列没有任何消费者来消费，那么消息在普通队列中存活到设定过期时间就被转发到死信队列，由死信队列的消费者消费消息，以此实现延时功能。

package com.yzm.rabbitmq_06.config;

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
public class RabbitConfig {

	// 死信队列
    public static final String DL_QUEUE = "dl_queue2";
    public static final String DL_EXCHANGE = "dl.exchange";
    public static final String DL_KEY = "dl.key2";

    @Bean
    public Queue dlQueue() {
        return QueueBuilder.durable(DL_QUEUE).build();
    }

    @Bean
    public DirectExchange dlExchange() {
        return ExchangeBuilder.directExchange(DL_EXCHANGE).build();
    }

    @Bean
    public Binding dlBinding() {
        return BindingBuilder.bind(dlQueue()).to(dlExchange()).with(DL_KEY);
    }

    // ----------------------------------------------------------------------------------------------------------

    public static final String NORMAL_EXCHANGE = "normal.exchange";
    public static final String NORMAL_QUEUE2 = "normal_queue2";
    public static final String NORMAL_KEY2 = "normal.key2";

    @Bean
    public DirectExchange exchange() {
        return ExchangeBuilder.directExchange(NORMAL_EXCHANGE).build();
    }

    // 正常队列2，添加配置
    @Bean
    public Queue queue2() {
        Map<String, Object> params = new HashMap<>();
        params.put("x-dead-letter-exchange", DL_EXCHANGE);//声明当前队列绑定的死信交换机
        params.put("x-dead-letter-routing-key", DL_KEY);//声明当前队列的死信路由键
        // 添加消息过期时间，10秒内还没处理完，就转发给死信队列
        params.put("x-message-ttl", 10000);
        return QueueBuilder.durable(NORMAL_QUEUE2).withArguments(params).build();
    }

    @Bean
    public Binding binding2() {
        return BindingBuilder.bind(queue2()).to(exchange()).with(NORMAL_KEY2);
    }
}

package com.yzm.rabbitmq_06.sender;

import com.yzm.rabbitmq_06.config.RabbitConfig;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@Slf4j
@RestController
public class Sender {

    private final RabbitTemplate rabbitTemplate;

    public Sender(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    @GetMapping("/dl")
    public void dl() {
        String message = "Hello World!";
        log.info(" [ 生产者 ] Sent ==> '" + message + "'");
        rabbitTemplate.convertAndSend(RabbitConfig.NORMAL_EXCHANGE, RabbitConfig.NORMAL_KEY2, message);
    }

}

消费者，不需要对普通队列进行监听

package com.yzm.rabbitmq_06.receiver;

import com.yzm.rabbitmq_06.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class Receiver {

    // 监听死信队列
    @RabbitListener(queues = RabbitConfig.DL_QUEUE)
    public void dl(Message message) {
        log.info(" [ 消费者@死信号 ] 接收到消息 ==> '" + new String(message.getBody()));
    }

}

启动，运行结果：
在这里插入图片描述
设置过期时间10秒，没有任何消费者对normal-queue2队列处理，10秒过后，消息转发到死信队列处理

现在这种过期时间设定就针对整个normal_queue2队列的所有消息的，还可以更细粒度的针对每一条消息设置过期时间。

package com.yzm.rabbitmq_06.config;

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
public class RabbitConfig {

    // 死信队列在这里作为延时队列
    public static final String DL_QUEUE = "dl_queue2";
    public static final String DL_EXCHANGE = "dl.exchange";
    public static final String DL_KEY = "dl.key2";

    @Bean
    public Queue dlQueue() {
        return QueueBuilder.durable(DL_QUEUE).build();
    }

    @Bean
    public DirectExchange dlExchange() {
        return ExchangeBuilder.directExchange(DL_EXCHANGE).build();
    }

    @Bean
    public Binding dlBinding() {
        return BindingBuilder.bind(dlQueue()).to(dlExchange()).with(DL_KEY);
    }

    // ----------------------------------------------------------------------------------------------------------

    public static final String NORMAL_EXCHANGE = "normal.exchange";
    public static final String NORMAL_QUEUE2 = "normal_queue2";
    public static final String NORMAL_KEY2 = "normal.key2";
    public static final String NORMAL_QUEUE3 = "normal_queue3";
    public static final String NORMAL_KEY3 = "normal.key3";

    @Bean
    public DirectExchange exchange() {
        return ExchangeBuilder.directExchange(NORMAL_EXCHANGE).build();
    }

    // 正常队列2，添加配置
    @Bean
    public Queue queue2() {
        Map<String, Object> params = new HashMap<>();
        params.put("x-dead-letter-exchange", DL_EXCHANGE);//声明当前队列绑定的死信交换机
        params.put("x-dead-letter-routing-key", DL_KEY);//声明当前队列的死信路由键
        // 添加消息过期时间，10秒内还没处理完，就转发给死信队列
        params.put("x-message-ttl", 10000);
        return QueueBuilder.durable(NORMAL_QUEUE2).withArguments(params).build();
    }

    @Bean
    public Binding binding2() {
        return BindingBuilder.bind(queue2()).to(exchange()).with(NORMAL_KEY2);
    }
    
    // 正常队列3，添加配置
    @Bean
    public Queue queue3() {
        Map<String, Object> params = new HashMap<>();
        params.put("x-dead-letter-exchange", DL_EXCHANGE);//声明当前队列绑定的死信交换机
        params.put("x-dead-letter-routing-key", DL_KEY);//声明当前队列的死信路由键
        // 添加消息过期时间，10秒内还没处理完，就转发给死信队列
        // params.put("x-message-ttl", 10000);
        return QueueBuilder.durable(NORMAL_QUEUE3).withArguments(params).build();
    }
    
    @Bean
    public Binding binding3() {
        return BindingBuilder.bind(queue3()).to(exchange()).with(NORMAL_KEY3);
    }
}

package com.yzm.rabbitmq_06.sender;

import com.yzm.rabbitmq_06.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

import java.nio.charset.StandardCharsets;

@Slf4j
@RestController
public class Sender {

    private final RabbitTemplate rabbitTemplate;

    public Sender(RabbitTemplate rabbitTemplate) {
        this.rabbitTemplate = rabbitTemplate;
    }

    @GetMapping("/dl")
    public void dl() {
        String message = "Hello World!";
        log.info(" [ 生产者 ] Sent ==> '" + message + "'");
        rabbitTemplate.convertAndSend(RabbitConfig.NORMAL_EXCHANGE, RabbitConfig.NORMAL_KEY2, message);
    }

    @GetMapping("/dl3")
    public void dl3() {
        String s = "Hello World!";
        log.info(" [ 生产者 ] Sent ==> '" + s + "'");
        //设置过期时间
        MessageProperties messageProperties = new MessageProperties();
        messageProperties.setExpiration("12000");
        Message message = new Message(s.getBytes(StandardCharsets.UTF_8), messageProperties);
        rabbitTemplate.convertAndSend(RabbitConfig.NORMAL_EXCHANGE, RabbitConfig.NORMAL_KEY3, message);
    }
}

package com.yzm.rabbitmq_06.receiver;

import com.yzm.rabbitmq_06.config.RabbitConfig;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;

@Slf4j
@Component
public class Receiver {

    // 监听死信队列
    @RabbitListener(queues = RabbitConfig.DL_QUEUE)
    public void dl(Message message) {
        log.info(" [ 消费者@死信号 ] 接收到消息 ==> '" + new String(message.getBody()));
    }
}

重启。运行结果：
在这里插入图片描述

相关链接

首页
上一篇：死信队列
下一篇：备用交换机

yzm4399
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
thinkphp6实战Rabbitmq之延时队列（完整篇）
qq_21273321的博客
08-16 1275
thinkphp6之rabbitmq延时队列
RabbitMQ 之延时队列
const_
07-09 974
文章目录什么是延时队列延时队列使用场景RabbitMQ中的TTLRabbitMQ实现延时队列RabbitMQ延时队列优化利用RabbitMQ插件实现延时队列总结 什么是延时队列 延时队列，首先，它是一种队列，队列意味着内部的元素是有序的，元素出队和入队是有方向性的，元素从一端进入，从另一端取出。 其次，延时队列，最重要的特性就体现在它的延时属性上，跟普通的队列不一样的是，普通队列中的元素总是等着希望被早点取出处理，而延时队列中的元素则是希望被在指定时间得到取出和处理，所以延时队列中的元素是都是带时间属性的，
RabbitMq之延时队列
爱琴孩的博客
09-15 537
前言 前面在RabbitMq之消息限流与延时队列(上)中，我们介绍了rabbitmq如何设置限流，这里再和大家一起看下rabbitmq如何实现延迟队列。 TTL 消息/队列 TTL 是 Time To Live 的缩写，也就是生存时间的意思，RabbitMQ 支持消息的过期时间，在消息发送时可以进行指定，也支持队列的过期时间，从消息入队列开始计算，只要超过了队列的超时时间配置，那么消息会自动的清除。设置队列的话就是整个队列的消息到时都会过期，设置消息的话就是单条消息到时自动过期。 // TTL队列
RabbitMQ之“延时队列”
2302_77971734的博客
03-21 2868
延迟队列存储的对象是对应的延迟消息，所谓“延迟消息”是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费
RabbitMq安装延时队列 插件
mj15755774197的博客
09-04 257
ls。
rabbitmq php延迟队列,PHP实战RabbitMQ之延时队列篇
weixin_28944067的博客
03-16 431
前言延时队列的作用不再累述本文使用rabbitmq的queue可以设置ttl时间，将到期的message设为死信，message会被push到delay_queue，消费delay_queue即可实现延时队列功能场景先假设这样一个场景：小明在外卖平台下个一个订单，如果超过10分钟未支付，则系统自动取消订单，并推送给用户“订单已取消”信息。开发思路：下订单时就将订单orderId push到订单队列...
7. RabbitMQ之延时队列
u010502101的博客
07-21 1094
延迟队列是通过TTL实现的，TTL指Time To Live，消息存活时间，TTL是RabbitMQ中消息或者队列的属性，表明可以设置一条消息或者队列中所有消息的存活时间。可以对一条消息设置TTL，表示这条消息的存活时间；也可以对队列设置TTL，表示队列中所有消息的存活时间都是一致的。如果某条消息被设置了TTL，或者队列被设置了TTL属性，那么在TTL时间内这些消息没有被消费的话就会变成死信消息，被投递到死信队列中。在上一篇文章中已经介绍了2种设置TTL的方式：一种就是为队列设置参数，使队列中所有消息有相同
RabbitMQ 之延时队列使用场景
const_
11-13 2084
import com.rabbitmq.client.Channel; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.Exchange; import org.springframework.amqp.core.Message; import org.springframework.amqp.core.Queue; import org.springframework.amqp.core.
Springboot 集成Rabbitmq之延时队列
qq_33449977的博客
04-07 622
以上代码示例中，正常的消息会被发送到normalQueue，如果在指定的TTL时间内未被消费，则该消息会作为死信转发到delayExchange，然后根据路由键路由到delayQueue，最终由监听delayQueue的消费者进行处理，从而实现了消息的延时处理。
SpringBoot整合Rabbitmq之延时队列
桐花思雨
09-27 1335
目录延时队列概念使用场景延时队列实现 延时队列 概念 延时队列是存储延时消息的队列，延时消息就是生产者发送了一条消息，但是不希望该消息不要被立即消费，而是设置一个延时时间，等过了这个时间再消费消息 使用场景 订单在十分钟之内未支付则自动取消 新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒 账单在一周内未支付，则自动结算 用户注册成功后，如果三天内没有登陆则进行短信提醒 用户发起退款，如果三天内没有得到处理则通知相关运营人员 这时候，延时队列就可以闪亮登场了，以上场景，正是延时队列的用武之
使用RabbitMq实现延时队列
xushuai2333333的博客
10-19 1386
使用RabbitMq实现延时队列
php延时队列处理订单过程,PHP实战RabbitMQ之延时队列篇
weixin_39674978的博客
03-19 566
前言延时队列的作用不再累述本文使用rabbitmq的queue可以设置ttl时间，将到期的message设为死信，message会被push到delay_queue，消费delay_queue即可实现延时队列功能场景先假设这样一个场景：小明在外卖平台下个一个订单，如果超过10分钟未支付，则系统自动取消订单，并推送给用户“订单已取消”信息。开发思路：下订单时就将订单orderId push到订单队列...
【RabbitMQ】01-RabbitMQ
Infinity的博客
11-03 456
MQ可以有更好的并发性。
什么是RabbitMQ
QQ1817117243的博客
10-31 669
RabbitMQ 是一个开源的消息代理软件，旨在支持多种消息协议。RabbitMQ 允许应用程序和服务之间进行异步通信，能够在不同的应用和系统之间传递消息，从而实现解耦。同时，RabbitMQ 也支持消息持久化，将消息保存在磁盘上，以便在重启时恢复。：RabbitMQ 提供多种语言的客户端库，支持 Java、Python、Ruby、Go 等多种编程语言，方便开发者与 RabbitMQ 进行交互。：RabbitMQ 可以根据需求进行水平扩展，使之适应更大规模的消息处理需求。
【RabbitMQ】04-发送者可靠性
Infinity的博客
11-07 158
每个RabbitTemplate只能配置一个ReturnCallback，因此我们可以在配置类中统一设置。@Slf4j@Overridelog.error("触发return callback,");});由于每个消息发送时的处理逻辑不一定相同，因此ConfirmCallback需要在每次发消息时定义。@Test// 1.创建CorrelationData// 2.给Future添加ConfirmCallback@Override。
centos docker 安装 rabbitmq
liyongbing1122的博客
11-07 486
如果您之前安装过Docker，可能需要先卸载旧版本。安装一些必要的工具，如yum-utils阿里云清华大学源。
win11安装最新rabbitmq
qq_20376949的博客
11-03 313
因为RabbitMQ默认启动的，当键入启动命令时，会出现如下情况，直接关闭RabbitMQ服务，再启动就行。RabbitMQ后台访问地址 http://localhost:15672。身份运行cmd，，执行下面命令启动RabbitMQ。关闭后再重新执行启动命令即可。默认的用户名：guest。默认的密码为：guest。关闭RabbitMQ。
RabbitMQ 高级特性——消息分发
最新发布
不能再留遗憾了的博客
11-07 354
RabbitMQ消息分发
RabbitMQ的延时队列
04-08
RabbitMQ提供了延时队列的实现方式，可以通过设置消息的TTL（Time To Live）属性，以及通过DLX（Dead Letter Exchange）机制来实现延时队列。这种机制可以用于各种场景，例如订单超时未支付、用户未确认等等。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值