SpringBoot使用RabbitMq实现队列和延时队列

闲来无事看了看RabbitMq的队列，总结了一些队列的实现方法，当然，免不了各种看别人的博客哈哈哈
其中延时队列有两种方式，一种是使用TTl+死信队列实现，一种是直接用RabbitMq的官方插件
第一种写起来比较麻烦，这里就只说第二种了
接下来从头开始说吧
1.首先是插件下载
打开链接https://github.com/rabbitmq/rabbitmq-routing-node-stamp/releases

然后下载图中的文件，放到你的安装目录的plugins文件夹下
然后在安装目录sbin下执行 rabbitmq-plugins enable rabbitmq_delayed_message_exchange即可
运行完直接关掉黑窗口就行
2.导入依赖

1. <dependency>
2.     <groupId>org.springframework.amqp</groupId>
3.     <artifactId>spring-rabbit</artifactId>
4. </dependency>

复制代码

3.在yml中配置

1. spring:
2.   rabbitmq:
3.     host: localhost
4.     port: 5672
5.     username: guest
6.     password: guest
7.     virtual-host: /
8.     # 消息确认（ACK）
9.     publisher-confirm-type: correlated #确认消息已发送到交换机(Exchange)
10.     publisher-returns: true #确认消息已发送到队列(Queue)
11.     listener:
12.       simple:
13.         #自动签收auto  手动 manual
14.         acknowledge-mode: auto
15.         retry:
16.           enabled: true #开启重试
17.           max-attempts: 3 #最大重试次数，默认3次，达到次数后，会进行消息移除。若绑定了死信队列，则会放入死信队列中
18.           initial-interval: 2000ms  #重试间隔时间

复制代码

4.在项目下创建一个rabbitMq目录，后续将他的配置文件放入此目录
创建接口文件

1. public interface RabbitConsts {
3.     /**
4.      * 普通队列
5.      */
6.     String QUEUE_NAME = "gzl.queue"; //队列名称
7.     String EXCHANGE_NAME = "gzl.exchange"; //交换器名称
8.     String ROUTING_KEY = "gzl.outing"; //路由键
10.     /**
11.      * 延迟队列
12.      */
13.     String DELAY_QUEUE = "delay.queue";
14.     /**
15.      * 延迟队列交换器
16.      */
17.     String DELAY_MODE_QUEUE = "delay.mode";
18. }

复制代码

创建MessageStruct消息体（传数据用）

1. @Data
2. @Builder
3. @NoArgsConstructor
4. @AllArgsConstructor
5. public class MessageStruct implements Serializable {
6.     private static final long serialVersionUID = 392365881428311040L;
7.     private String message;
8. }

复制代码

创建RabbitMqConfig工具类

1. @Slf4j
2. @Configuration
3. public class RabbitMqConfig {
4.     @Bean
5.     public RabbitTemplate rabbitTemplate(CachingConnectionFactory connectionFactory) {
6.         connectionFactory.setPublisherConfirms(true);
7.         connectionFactory.setPublisherReturns(true);
8.         RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
9.         rabbitTemplate.setMandatory(true);
10.         rabbitTemplate.setConfirmCallback((correlationData, ack, cause) -> log.info("消息发送成功:correlationData({}),ack({}),cause({})", correlationData, ack, cause));
11.         rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}", exchange, routingKey, replyCode, replyText, message));
12.         return rabbitTemplate;
13.     }
15.     /**
16.      * 队列
17.      */
18.     @Bean
19.     public Queue queue()
20.     {
21.         /**
22.          * 创建队列，参数说明：
23.          * String name：队列名称。
24.          * boolean durable：设置是否持久化，默认是 false。durable 设置为 true 表示持久化，反之是非持久化。
25.          * 持久化的队列会存盘，在服务器重启的时候不会丢失相关信息。
26.          * boolean exclusive：设置是否排他，默认也是 false。为 true 则设置队列为排他。
27.          * boolean autoDelete：设置是否自动删除，为 true 则设置队列为自动删除，
28.          * 当没有生产者或者消费者使用此队列，该队列会自动删除。
29.          * Map<String, Object> arguments：设置队列的其他一些参数。
30.          */
31.         return new Queue(RabbitConsts.QUEUE_NAME, true, false, false, null);
32.     }
34.     /**
35.      * Direct交换器
36.      */
37.     @Bean
38.     public DirectExchange exchange()
39.     {
40.         /**
41.          * 创建交换器，参数说明：
42.          * String name：交换器名称
43.          * boolean durable：设置是否持久化，默认是 false。durable 设置为 true 表示持久化，反之是非持久化。
44.          * 持久化可以将交换器存盘，在服务器重启的时候不会丢失相关信息。
45.          * boolean autoDelete：设置是否自动删除，为 true 则设置队列为自动删除，
46.          */
47.         return new DirectExchange(RabbitConsts.EXCHANGE_NAME, true, false);
48.     }
50.     /**
51.      * 绑定
52.      */
53.     @Bean
54.     Binding binding(DirectExchange exchange, Queue queue)
55.     {
56.         //将队列和交换机绑定, 并设置用于匹配键：routingKey
57.         return BindingBuilder.bind(queue).to(exchange).with(RabbitConsts.ROUTING_KEY);
58.     }
61.     //===================延迟队列插件实现start====================//
62.     /**
63.      * 延迟队列
64.      */
65.     @Bean
66.     public Queue delayQueue() {
67.         return new Queue(RabbitConsts.DELAY_QUEUE, true);
68.     }
69.     /**
70.      * 延迟队列交换器, x-delayed-type 和 x-delayed-message 固定
71.      */
72.     @Bean
73.     public CustomExchange delayExchange() {
74.         Map<String, Object> args = new HashMap<>(16);
75.         args.put("x-delayed-type", "direct");
76.         return new CustomExchange(RabbitConsts.DELAY_MODE_QUEUE, "x-delayed-message", true, false, args);
77.     }
78.     /**
79.      * 延迟队列绑定自定义交换器
80.      *
81.      * @param delayQueue    队列
82.      * @param delayExchange 延迟交换器
83.      */
84.     @Bean
85.     public Binding delayBinding(Queue delayQueue, CustomExchange delayExchange) {
86.         return BindingBuilder.bind(delayQueue).to(delayExchange).with(RabbitConsts.DELAY_QUEUE).noargs();
87.     }
88. //===================延迟队列插件实现end====================/
89. }

复制代码

然后自己写个接口调用生产和消费就行了

1. @Autowired
2. private RabbitTemplate rabbitTemplate;

复制代码

生产者发送消息
1.普通队列发送（无延时）

1. rabbitTemplate.convertAndSend(RabbitConsts.EXCHANGE_NAME,
2.     RabbitConsts.ROUTING_KEY, new MessageStruct("非延时！"));

复制代码

2.延时队列发送

1. rabbitTemplate.convertAndSend(RabbitConsts.DELAY_MODE_QUEUE,
2.     RabbitConsts.DELAY_QUEUE, new MessageStruct("延时6s, " +
3.             new Date()), message -> {
4.             message.getMessageProperties().setHeader("x-delay", 6000);
5.             return message;
6.             }
7. );

复制代码

消费者接收消息（无延时）

1. //开启队列获取
2.     @RabbitListener(queues = RabbitConsts.QUEUE_NAME)
3.     @RabbitHandler
4.     public void getInfo(MessageStruct messageStruct,Message message, Channel channel) throws IOException {
5.         long deliveryTag = message.getMessageProperties().getDeliveryTag();
6.         String msg = JSONObject.toJSONString(messageStruct.getMessage());
7.         Date date = new Date();
8.         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
9.         System.out.println("时间："+df.format(date));
10.         System.out.println("接收到消息:" + msg);
11. //        消息确认 如果yml中的配置为  acknowledge-mode: manual则需要手动确认消息，否则会造成消息堆积
12. //        channel.basicNack(deliveryTag,false,false);
13.     }

复制代码

 消费者延时接收消息

1. //开启延时队列获取
2.     @RabbitListener(queues = RabbitConsts.DELAY_QUEUE)
3.     @RabbitHandler
4.     public void setListY(MessageStruct messageStruct,Message message, Channel channel) throws IOException {
5.         long deliveryTag = message.getMessageProperties().getDeliveryTag();
6.         String msg = JSONObject.toJSONString(messageStruct.getMessage());
7.         Date date = new Date();
8.         SimpleDateFormat df = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
9.         System.out.println("时间："+df.format(date));
10.         System.out.println("延时接收到消息:" + msg);
11. //        消息确认 如果yml中的配置为  acknowledge-mode: manual则需要手动确认消息，否则会造成消息堆积
12. //        channel.basicNack(deliveryTag,false,false);
13.     }

复制代码

最后控制台输出
 

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！