rabbitmq java 动态创建队列

转载

云端梦想家 2024-09-17 22:15:10

文章标签 java-rabbitmq rabbitmq java spring 使用场景 文章分类 Java 后端开发

RabbitMQ 之延时队列

1.延迟队列概念
2.延迟队列使用场景
3.RabbitMQ 中的 TTL

3.1 队列设置 TTL
3.2 消息设置 TTL
3.3 两者的区别

4.整合 springboot

4.1 创建 springboot 项目
4.2 依赖
4.3 修改配置文件

5. 设置队列 TTL 实现延时队列

5.1 代码架构图
5.2 配置类代码
5.3 消息生产者代码
5.4 消息消费者代码

6.设置消息 TTL 实现延时队列

6.1 代码架构图
6.2 配置类代码
6.3 消息生产者代码

7. RabbitMQ 插件实现延迟队列

7.1 安装延时队列插件
7.2 代码架构图
7.3 配置类代码
7.4 消息生产者代码
7.5 消息消费者代码

8. 总结

好记性不如烂笔头，继续整理 RabbitMQ 的相关知识，做一个系统学习的好同学 ღ( ´･ᴗ･` )

1.延迟队列概念

延时队列中的元素是希望在指定时间到了以后或之前取出和处理，简单来说，延时队列就是用来存放需要在指定时间被处理的元素的队列。

2.延迟队列使用场景

订单在十分钟之内未支付则自动取消。
新创建的店铺，如果在十天内都没有上传过商品，则自动发送消息提醒。
用户注册成功后，如果三天内没有登录，则进行短信提醒。
用户发起退款，如果三天内没有得到处理，则通知相关运营人员。
预定会议后，需要在预定的时间点前十分钟通知各个相关人员参加会议。
这些场景都有一个特点：在某个事情发生之后或者之前的指定时间点完成某一项任务。
如：发生订单生成事件，十分钟之后检查该订单支付状态，然后将未支付的订单进行关闭。看起来使用定时任务一直轮询，每秒查一次，取出被处理的数据，然后不就完事了吗？如果数据量比较小确实还行，比如：对于“如果账单一周内未支付则进行自动结算”这样的需求，对于时间不是严格限制，而是宽松意义的一周，那么每天晚上跑一个定时任务检查一下所有未支付账单，确实是一个可行方案。但是对于数据量比较大，并且时效性较强的场景，如：“订单十分钟内未支付则关闭”，短期内未支付的订单数据可能很多，活动期间甚至会达到百万甚至千万级别，对那么庞大的数据量仍然采用轮回的方式显然是不可取的，很可能在一秒钟内无法完成所有订单的检查，同时会给数据库带来很大压力，无法满足要求而且性能底下。

3.RabbitMQ 中的 TTL

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

3.1 队列设置 TTL

在创建队列的时候设置队列的“x-message-ttl”属性

3.2 消息设置 TTL

针对每条消息设置 TTL

rabbitmq java 动态创建队列_java

3.3 两者的区别

如果设置了队列的 TTL 属性，那么一旦消息过期，就会被队列丢弃（如果配置了死信队列被丢到死信队列中），而消息设置 TTL的方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需要注意的一点是，如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以直接投递该消息，否则该消息将会被丢弃。

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

4.整合 springboot

4.1 创建 springboot 项目

这里就不废话了

4.2 依赖

<dependencies>
        <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>

        <!-- rabbitMq -->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
            <version>2.5.6</version>
        </dependency>

        <!-- lombok -->
        <dependency>
            <groupId>org.projectlombok</groupId>
            <artifactId>lombok</artifactId>
        </dependency>

    </dependencies>

4.3 修改配置文件

spring:
  rabbitmq:
    host: 39.105.35.163
    port: 5672
    username: root
    password: 123456

5. 设置队列 TTL 实现延时队列

5.1 代码架构图

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

rabbitmq java 动态创建队列_java_02

5.2 配置类代码

package com.wpp.rabbitmq_csdn.ttl;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @Author wpp
 * @Date 2021/09/28/15:01
 * @Description
 */
@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);
        // 声明当前队列的死信 routingKey
        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);
        //声明当前队列的死信 routingKey
        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 queueB, @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueB).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");
    }


}

5.3 消息生产者代码

package com.wpp.rabbitmq_csdn.ttl;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * @Author wpp
 * @Date 2022/08/30/14:11
 * @Description
 */
@Slf4j
@RestController
public class SendMsgController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

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

}

5.4 消息消费者代码

package com.wpp.rabbitmq_csdn.ttl;

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;


/**
 * @Author wpp
 * @Date 2022/08/30/14:10
 * @Description
 */
@Slf4j
@Component
public class DeadLetterQueueConsumer {

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

    }


}

发送一个请求：localhost:8080/sendMessage/消息

rabbitmq java 动态创建队列_java_03

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

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

6.设置消息 TTL 实现延时队列

6.1 代码架构图

在这里新增了一个队列 QC，绑定关系如下，该队列不设置 TTL 时间

rabbitmq java 动态创建队列_java-rabbitmq_04

6.2 配置类代码

package com.wpp.rabbitmq_csdn.ttl;

import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @Author wpp
 * @Date 2021/09/28/15:01
 * @Description
 */
@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 QUEUE_C = "QC";

    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);
        // 声明当前队列的死信 routingKey
        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);
        //声明当前队列的死信 routingKey
        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 queueB, @Qualifier("xExchange") DirectExchange xExchange) {
        return BindingBuilder.bind(queueB).to(xExchange).with("XB");
    }

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

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

    // 声明死信队列 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");
    }


}

6.3 消息生产者代码

package com.wpp.rabbitmq_csdn.ttl;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;

/**
 * @Author wpp
 * @Date 2022/08/30/14:11
 * @Description
 */
@Slf4j
@RestController
public class SendMsgController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

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

    @GetMapping(value = "sendExpirationMessage/{message}/{ttlTime}")
    public void sendMessage(@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);
    }

}

发起请求：

localhost:8080/sendExpirationMessage/哎呦/20000

localhost:8080/sendExpirationMessage/哎呦2/2000

rabbitmq java 动态创建队列_rabbitmq_05

看起来似乎没什么问题，但是在最开始的时候，就介绍过如果使用在消息上设置 TTL 的方式，消息可能并不会按时“死亡”，因为 RabbitMQ 只会检查第一个消息是否过期，如果过期则丢弃到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

7. RabbitMQ 插件实现延迟队列

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

7.1 安装延时队列插件

下载地址：https://www.rabbitmq.com/community-plugins.html
下载 rabbitmq_delayed_message_exchange 插件，然后解压放置到 RabbitMQ 的插件目录。
进入 RabbitMQ 的安装目录下的 plugins 目录，执行下面命令让该插件生效，然后重启 RabbitMQ

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

我们也可以使用 docker 安装 RabbitMQ，并且安装 rabbitmq_delayed_message_exchange

安装延时插件后，新增交换机类型：x-delayed-message

rabbitmq java 动态创建队列_java_06

7.2 代码架构图

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

rabbitmq java 动态创建队列_rabbitmq_07

7.3 配置类代码

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

package com.wpp.rabbitmq_csdn.delayed;

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

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

/**
 * @Author wpp
 * @Date 2022/09/17/8:14
 * @Description
 */
@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();
    }

}

7.4 消息生产者代码

package com.wpp.rabbitmq_csdn.delayed;

import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RestController;

import java.util.Date;


/**
 * @Author wpp
 * @Date 2022/08/30/14:11
 * @Description
 */
@Slf4j
@RestController
public class SendDelayMsgController {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
    public static final String DELAYED_ROUTING_KEY = "delayed.routingKey";

    @GetMapping(value = "sendDelayMsg/{message}/{delayTime}")
    public void sendMessage(@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);
    }

}

7.5 消息消费者代码

package com.wpp.rabbitmq_csdn.delayed;

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;


/**
 * @Author wpp
 * @Date 2022/08/30/14:10
 * @Description
 */
@Slf4j
@Component
public class DelayedQueueConsumer {

    public static final String DELAYED_QUEUE_NAME = "delayed.queue";

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

    }


}

发送请求：

localhost:8080/sendDelayMsg/同志们好1/20000

localhost:8080/sendDelayMsg/同志们好2/2000

rabbitmq java 动态创建队列_java_08

第二个消息被先消费了，符合预期。

8. 总结

延时队列在需要延时处理的场景下非常有用，使用 RabbitMQ 来实现延时队列可以很好的利用RabbitMQ 的特性，如：消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过RabbitMQ 集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致队列不可用或者消息丢失。

当然，延时队列还有很多其他选择，比如利用 Java的 DelayQueue，利用 Redis 的 zset，利用 Quartz 或者利用 kafka 的时间轮，这些防方式各有特点，看需要适用的场景。

本文章为转载内容，我们尊重原作者对文章享有的著作权。如有内容错误或侵权问题，欢迎原作者联系我们进行内容更正或删除文章。