RabbitMQ延时队列

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

RabbitMQ延时队列

1.延时队列

1）延时队列顾名思义，即放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费。

也就是可以控制的一个定时器，多数用在订单，付款等等

2）TTL和DLX

  • ​ TTL是Time To Live的缩写, 也就是生存时间。RabbitMq支持对消息和队列设置TTL，对消息这设置是在 发送的时候指定，对队列设置是从消息入队列开始计算, 只要超过了队列的超时时间配置, 那么消息会自动 清除。

    ​ 如果两种方式一起使用消息对TTL和队列的TTL之间较小的为准，也就是消息5s过期，队列是10s，那么5s

    ​ 的生效。

    ​ 默认是没有过期时间的，表示消息没有过期时间；如果设置为0，表示消息在投递到消费者的时候直接被

    ​ 消息，否则丢弃。

    ​ 设置消息的过期时间用 x-message-ttl 参数实现，单位毫秒。

    ​ 设置队列的过期时间用 x-expires 参数，单位毫秒，注意，不能设置为0。

  • DLX是Dead-Letter-Exchange的缩写，全称死信交换器。成为死信队列后，可以被重新发送到另外一个交换器中，这个交换器就是DLX，绑定DLX到队列称为死信队列。注意，死信队列和死信交换器不一样哦。

    成为死信一般由以下几种情况：

    • 消息被拒绝 (basic.reject or basic.nack) 且带 requeue=false 参数

    • 消息的TTL-存活时间已经过期

    • 队列长度限制被超越（队列满）

    DLX和一般的交换器没有区别，可以声明在任何的队列上，理解为队列的一个属性吧。当这个队列有死信时会根据设置自动的将死信重新发布到设置的DLX上进行消费。这个消费了死信的队列称之为死信队列，并不是绑定了DLX的队列是死信队列，大家要区分清楚。

    通过在队列里设置 x-dead-letter-exchange 参数来声明DLX，如果当前DLX是 direct 类型还要 声明 x-dead-letter-routing-key 参数来指定路由键，如果没有指定，则使用原队列的路由键

2.代码

1）jar

<dependency>

  <groupId>org.springframework.boot</groupId>

  <artifactId>spring-boot-starter-amqp</artifactId>

</dependency>

2）application.yml配置文件

spring:
    rabbitmq:
      host: 你的RabbitMq配置地址
      port: 8080
      username: 用户名默认（guest）
      password: 密码默认（guest）

3）配置队列

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

/**
 * 作者：**
 * 日期：2019/12/19 11:01
 */
//配置队列
@Configuration
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);
    }
}

4）接收者

import org.springframework.stereotype.Component;

import java.util.Date;

/**
 * 作者：**
 * 日期：2019/12/19 11:02
 */
@Component
public class DelayReceiver {

    //接收者
    @RabbitListener(queues = {DelayRabbitConfig.ORDER_QUEUE_NAME})
    public void orderDelayQueue(Order order, Message message, Channel channel) {
        System.out.println("###########################################");
        System.out.println("【orderDelayQueue 监听的消息】 - 【消费时间】 - [{"+new Date()+"}]- 【订单内容】 - [{"+order.toString()+"}]");
        if(order.getOrderStatus() == 0) {
            order.setOrderStatus(2);
            System.out.println("【该订单未支付，取消订单】" + order.toString());
        } else if(order.getOrderStatus() == 1) {
            System.out.println("【该订单已完成支付】");
        } else if(order.getOrderStatus() == 2) {
            System.out.println("【该订单已取消】");
        }
        System.out.println("###########################################");
    }
}

5）发送者

package com.example.rabbitmq.config;

import com.example.rabbitmq.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;
/**
 * 作者：**
 * 日期：2019/12/19 11:07
 */
@Component
public class DelaySender {
    @Autowired
    private AmqpTemplate amqpTemplate;
    //发送者
    public void sendDelay(Order order) {
        System.out.println("【订单生成时间】" + 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;
        });
    }
}

6）controller

package com.example.rabbitmq.controller;

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

/**
 * 作者：**
 * 日期：2019/12/19 11:17
 */
@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("小米7");

        Order order2 = new Order();
        order2.setOrderStatus(1);
        order2.setOrderId("456789");
        order2.setOrderName("小米9");

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

7）实体类

package com.example.rabbitmq.pojo;

import lombok.Data;

import java.io.Serializable;

/**
 * 作者：**
 * 日期：2019/12/19 11:38
 */
@Data
public class Order implements Serializable {
    private static final long serialVersionUID = -2221214252163879885L;

    private String orderId; // 订单id

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

    private String orderName; // 订单名字
}
IT_liangchaowei
关注
专栏目录
【SpringBoot】43、SpringBoot中整合RabbitMQ实现延时队列（延时插件篇）
Asurplus
02-21 21万+
一、介绍 1、什么是延时队列？ 延时队列即就是放置在该队列里面的消息是不需要立即消费的，而是等待一段时间之后取出消费 2、适用场景 （1）商城订单超时未支付，取消订单 （2）使用权限到期前十分钟提醒用户 （3）收益项目，投入后一段时间后产生收益 二、实现方式 从以上场景中，我们可以看出，延时队列的主要功能就是在指定的时间之后做指定的事情，那么，我们思考有哪些工具我们可以使用？ 1、Redis 监听过期 Key 可以参考我的博客【SpringBoot】三十五、SpringBoot整合Redis监听Ke
RabbitMq延时队列
m0_61349626的博客
04-03 630
1. 场景：“订单下单成功后，15分钟未支付自动取消” 1.传统处理超时订单 采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性能会有很大的要求， 并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下， 即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单， 然后再做其他的业务操作 2.rabbitMQ延时队列方案 一台普通的...
延迟队列
lei_lin的博客
12-27 430
1. 场景：“订单下单成功后，15分钟未支付自动取消” 1.传统处理超时订单 采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求， 并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下， 即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单， 然后再做其他的业务操作 ...
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
rabbitmq延时队列和四种交换机模式下队列的简单实现，需要自己配置一下属性文件。
【RabbitMq04】延迟队列
weixin_40964170的博客
07-29 2194
一、延迟队列理解 1、延迟队列概念 延时队列,队列内部是有序的，最重要的特性就体现在它的延时属性上，延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列 延迟队列，就是死信队列中，TTL消息过期的一种 举例 如死信队列文章中所讲，消费者1启动后，在rabbitmq控制台生成正常队列和死信队列后就又关闭了，然后开启生产者给消费者1发送消息，因为消费者1中设置了TTL消息过期机制，所以等了10秒种消息就自动进入到死信队列了，消息被消费者2接
RabbitMQ学习之延时队列
热门推荐
任何技能都是从模仿开始，逐步升华。
12-11 1万+
在实际的业务中我们会遇见生产者产生的消息，不立即消费，而是延时一段时间在消费。RabbitMQ本身没有直接支持延迟队列功能，但是我们可以根据其特性Per-Queue Message TTL和 Dead Letter Exchanges实现延时队列。也可以通过改特性设置消息的优先级。
RabbitMQ：延时队列
caox_nazi的博客
08-02 1135
RabbitMQ：延时队列 （一）：在队列上设置TTL  参考文献：RabbitMQ学习之延时队列  其中，【延时队列delay.1m.queue】配置参数如下需配置： 【生产者配置】： package com.caox.rabbitmq.demo._15_rabbitmq_delay_query_ttl; import com.rabbitmq.client.Chann...
RabbitMQ之“延时队列”
最新发布
2302_77971734的博客
03-21 2642
延迟队列存储的对象是对应的延迟消息，所谓“延迟消息”是指当消息被发送以后，并不想让消费者立刻拿到消息，而是等待特定时间后，消费者才能拿到这个消息进行消费
SpringBoot集成RabbitMQ延时队列，自定义延时时间Demo
09-16
该示例通过 rabbitmq_delayed_message_exchange 插件实现自定义延时时间的延时队列。 示例是纯净的，只引入了需要的架包 启动示例时，请确保MQ已经安装了延时插件(附件里带有插件及安装说明)以及示例的MQ相关的配置...
RabbitMQ延时队列及消息可靠性
MostSnails的博客
10-01 820
RabbitMQ延时队列及消息可靠性
RabbitMQ —— 延迟队列
荔枝当大佬的博客
09-19 2634
在这篇文章中，荔枝会梳理延迟队列的相关知识，主要涉及两种实现延时队列的方式和应用场景，希望能帮助到有需要的小伙伴~~~
RabbitMQ 实现延时队列
09-22 628
1.消息的TTL（TimeToLive）•消息的TTL就是消息的存活时间。•RabbitMQ可以对队列和消息分别设置TTL。•对队列设置就是队列没有消费者连着的保留时间，也可以对每一个单独的消息做单独的 设置。超过了这个时间，我们认为这个消息就死了，称之为死信。•如果队列设置了，消息也设置了，那么会取小的。所以一个消息如果被路由到不同的队 列中，这个消息死亡的时间有可能不一样（不同的队列设置）。这里单讲单个消息的TTL。
RabbitMQ——延迟队列
weixin_67465673的博客
12-24 2200
采取定时任务轮训数据库订单，并且批量处理。其弊端也是显而易见的；对服务器、数据库性会有很大的要求，并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下，即存入订单的时候就算出订单的过期时间插入数据库，设置定时任务查询数据库的时候就只需要查询过期了的订单，然后再做其他的业务操作。
rabbitmq 延迟队列_RabbitMQ 实现延迟队列
weixin_39929259的博客
11-26 1313
参考文章https://www.cnblogs.com/mfrank/p/11260355.htmlhttps://blog.csdn.net/u014308482/article/details/53036770https://blog.csdn.net/u012988901/article/details/88958654本文大纲什么是延迟队列延迟队列也是队列，队列就意味着元素是有序...
RabbitMQ 延迟队列实现定时任务的正确姿势
HelloWorld搬运工
06-23 241
场景 开发中经常需要用到定时任务，对于商城来说，定时任务尤其多，比如优惠券定时过期、订单定时关闭、微信支付2小时未支付关闭订单等等，都需要用到定时任务，但是定时任务本身有一个问题，一般来说我们都是通过定时轮询查询数据库来判断是否有任务需要执行。 也就是说不管怎么样，我们需要先查询数据库，而且有些任务对时间准确要求比较高的，需要每秒查询一次，对于系统小倒是无所谓，如果系统本身就大而且数据也多的情况下，这就不大现实了。所以需要其他方式的，当然实现的方式有多种多样的，比如Redis实现定时队列、基于优先级队列
RabbitMQ学习笔记（下）：延迟队列，发布确认高级，备份交换机
RuanFun的博客
10-06 267
点击启动类重新启动，在网页端输入：localhost:8080/ttl/sendExpirationMsg/你好1/20000和localhost:8080/ttl/sendExpirationMsg/你好2/2000。rabbitmq的插件在：/usr/lib/rabbitmq/lib/rabbitmq_server-3.8.8/plugins目录下，上传插件到目录下，如果上传失败用sudo rz先获得权限。问题：延迟队列是排队的，当队列中有多条消息时，延迟队列的消息会根据前面最长时间发送。
rabbitmq延时队列
08-31
RabbitMQ延时队列是一种实现消息延迟推送的机制。在RabbitMQ中，可以使用插件来启用延迟队列功能。通过使用该插件，可以实现消息在一定时间后才被消费者接收。在过去的版本中，一般采用死信队列和过期时间来实现延迟...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值