RabbitMQ自学之路（九）——RabbitMQ实现延时队列的两种方式

最新推荐文章于 2024-05-01 10:42:04 发布
最新推荐文章于 2024-05-01 10:42:04 发布
阅读量970 收藏
点赞数
分类专栏： java 文章标签： rabbitmq java spring boot
原文链接：https://blog.csdn.net/qq_29914837/article/details/94070677
版权

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

二、延时队列应用于什么场景
场景一：在订单系统中，一个用户下单之后通常有30分钟的时间进行支付，如果30分钟之内没有支付成功，那么这个订单将进行一场处理。这是就可以使用延时队列将订单信息发送到延时队列。

场景二：用户希望通过手机远程遥控家里的智能设备在指定的时间进行工作。这时候就可以将用户指令发送到延时队列，当指令设定的时间到了再将指令推送到智能设备。

Rabbitmq实现延时队列一般而言有两种形式：
第一种方式：利用两个特性： Time To Live(TTL)、Dead Letter Exchanges（DLX）
第二种方式：利用rabbitmq中的插件x-delay-message

三、第一种：利用TTL DLX实现延时队列的方式
AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是可以通过以下特性模拟出延迟队列的功能。


1、Time To Live(TTL)

RabbitMQ可以针对Queue设置x-expires 或者 针对Message设置 x-message-ttl，来控制消息的生存时间，如果超时(两者同时设置以最先到期的时间为准)，则消息变为dead letter(死信)

A: 通过队列属性设置，队列中所有消息都有相同的过期时间。
B: 对消息进行单独设置，每条消息TTL可以不同。

2、Dead Letter Exchanges（DLX）

RabbitMQ的Queue可以配置x-dead-letter-exchange和x-dead-letter-routing-key（可选）两个参数，如果队列内出现了dead letter，则按照这两个参数重新路由转发到指定的队列。
x-dead-letter-exchange：出现dead letter之后将dead letter重新发送到指定exchange
x-dead-letter-routing-key：出现dead letter之后将dead letter重新按照指定的routing-key发送

用一个具体案例来实现第一种方式：用户下订单后，如何在一分钟没有支付就取消订单


package com.springboot.rabbitmq.example.demo5.config;

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

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import lombok.extern.slf4j.Slf4j;

/**
 * @method
 * @author Mr yi
 * @time 2019年6月23日
 */
@Configuration
@Slf4j
public class RabbitConfigDemo5    {

 
    //队列名称
    final static String queue = "queue_demo5";

    //交换机名称
    final static String exchangeName = "deom5Exchange";
    
    // routingKey
    final static String routingKey  = "keyDemo5";
    
    //死信消息队列名称
    final static String deal_queue = "deal_queue_demo5";

    //死信交换机名称
    final static String deal_exchangeName = "deal_deom5Exchange";
    
    //死信 routingKey
    final static String dead_RoutingKey  = "dead_routing_key";
    
    //死信队列 交换机标识符
    public static final String DEAD_LETTER_QUEUE_KEY = "x-dead-letter-exchange";
    
    //死信队列交换机绑定键标识符
    public static final String DEAD_LETTER_ROUTING_KEY = "x-dead-letter-routing-key";

    @Autowired
    private CachingConnectionFactory connectionFactory;
    
    /**
     * 
     * @method 定义队列(队列 绑定一个死信交换机,并指定routing_key)
     * @author Mr yi
     * @time 2019年6月29日
     * @return
     */
    @Bean
    public Queue queueDemo5() {
        // 将普通队列绑定到死信队列交换机上
        Map<String, Object> args = new HashMap<>(2);
        //args.put("x-message-ttl", 5 * 1000);//直接设置 Queue 延迟时间 但如果直接给队列设置过期时间,这种做法不是很灵活
        //这里采用发送消息动态设置延迟时间,这样我们可以灵活控制
        args.put(DEAD_LETTER_QUEUE_KEY, deal_exchangeName);
        args.put(DEAD_LETTER_ROUTING_KEY, dead_RoutingKey);
        return new Queue(RabbitConfigDemo5.queue, true, false, false, args);
    }

    //声明一个direct类型的交换机
    @Bean
    DirectExchange exchangeDemo5() {
        return new DirectExchange(RabbitConfigDemo5.exchangeName);
    }

    //绑定Queue队列到交换机,并且指定routingKey 
    @Bean
    Binding bindingDirectExchangeDemo5(   ) {
        return BindingBuilder.bind(queueDemo5()).to(exchangeDemo5()).with(routingKey);
    }
    
    //创建配置死信队列
    @Bean
    public Queue deadQueue5() {
        Queue queue = new Queue(deal_queue, true);
        return queue;
    }
    
    //创建死信交换机
     @Bean
     public DirectExchange deadExchange5() {
         return new DirectExchange(deal_exchangeName);
     }
    
     //死信队列与死信交换机绑定
      @Bean
      public Binding bindingDeadExchange5() {
          return BindingBuilder.bind(deadQueue5()).to(deadExchange5()).with(dead_RoutingKey);
      }

/**      @Bean
      public RabbitTemplate rabbitTemplate(){
          //若使用confirm-callback ，必须要配置publisherConfirms 为true
          connectionFactory.setPublisherConfirms(true);
          //若使用return-callback，必须要配置publisherReturns为true
          connectionFactory.setPublisherReturns(true);
          RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
          //使用return-callback时必须设置mandatory为true，或者在配置中设置mandatory-expression的值为true
         // rabbitTemplate.setMandatory(true);
   
          // 如果消息没有到exchange,则confirm回调,ack=false; 如果消息到达exchange,则confirm回调,ack=true
          rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
              @Override
              public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                  if(ack){
                      log.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
                  }else{
                      log.info("消息发送失败:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
                  }
              }
          });
          
          //如果exchange到queue成功,则不回调return;如果exchange到queue失败,则回调return(需设置mandatory=true,否则不回回调,消息就丢了)
          rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
              @Override
              public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                  log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
              }
          });
          return rabbitTemplate;
      }

**/
     

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
生产者产生订单后，将订单信息发送到rabbitmq 服务段，设置TTL 时间，如果超过了这个时间，还没有消费这个消息，那么就变为死信，发送到死信队列中。

这里利用死信的机制来巧妙的实现延时，我这里没有设置正常消费者，即生产者发送消息后，消息不会被消费，那么在指定时间后，变为死信，有与死信队列绑定的消费者来消费消息（判断订单是否已经成功支付）

package com.springboot.rabbitmq.example.demo5.producers;

import java.util.Date;
import java.util.UUID;

import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;

import lombok.extern.slf4j.Slf4j;
/**
 * 
 * @method 生产者
 * @author Mr yi
 * @time 2019年6月19日
 */
@Component
@Slf4j
public class ProducersDemo5  {

 
    @Autowired
    private AmqpTemplate rabbitTemplate;
    
    /**
     * @method 生产者发送消息,direct模式下需要传递一个routingKey
     * @author Mr yi
     * @time 2019年6月19日
     * @throws Exception
     */
    public void send( ) throws Exception {
        
        log.info("【订单生成时间】" + new Date().toString() +"【1分钟后检查订单是否已经支付】"  );
        
        this.rabbitTemplate.convertAndSend("deom5Exchange", "keyDemo5", "订单实体类对象信息", message -> {
            // 如果配置了 params.put("x-message-ttl", 5 * 1000); 那么这一句也可以省略,具体根据业务需要是声明 Queue 的时候就指定好延迟时间还是在发送自己控制时间
            message.getMessageProperties().setExpiration(1 * 1000 * 60 + "");
            return message;
        });
         
    }
     
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
死信消息消费者

package com.springboot.rabbitmq.example.demo5.consumers;

import java.io.IOException;
import java.util.Date;
import java.util.Map;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;

import lombok.extern.slf4j.Slf4j;

/**
 * 
 * @method  死信消费者，消费从死信队列传来的消息
 * @author Mr yi
 * @time 2019年6月19日
 */
@Component
@Slf4j
public class ConsumersDemo5Deal {
    
    @RabbitListener(queues = "deal_queue_demo5")
    public void process(String order,  Message message, @Headers Map<String, Object> headers, Channel channel) throws IOException {
    
        log.info("【 监听到延时队列消息】 - 【消费时间】 - [{}]- 【订单内容】 - [{}]",  new Date(), order); 
        // 判断订单是否已经支付，如果支付则；否则，取消订单（逻辑代码省略)
        
        // 手动ack
        Long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
        // 手动签收
        channel.basicAck(deliveryTag, false);
        System.out.println("执行结束....");
        
    }
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
测试

@Autowired
    private ProducersDemo5 producers;
    
    @RequestMapping("/send")
    public String send() throws Exception {
        producers.send();
        return "success";
    }
1
2
3
4
5
6
7
8
启动程序，测试

发现queue_demo5正常队列有一条消息处于待续状态

等待一分钟后，控制台输出

发现queue_demo5 消息已经被消费（发送到deal_queue_demo5死信队列了）

使用死信队列实现延时消息的缺点：

1） 如果统一用队列来设置消息的TTL，当延时时间梯度比较多的话，比如1分钟，2分钟，5分钟，10分钟，20分钟，30分钟……需要创建很多交换机和队列来路由消息。
2） 如果单独设置消息的TTL，则可能会造成队列中的消息阻塞——前一条消息没有出队（没有被消费），后面的消息无法投递。
3） 可能存在一定的时间误差。

四、第二种：利用rabbitmq-delayed-message-exchange插件来实现延迟队列功能
插件下载地址：注意下载插件要和安装的rabbitmq版本一致，我这里下载的是3.7的
https://www.rabbitmq.com/community-plugins.html

下载解压后，得到一个.ez的压缩文件，找到rabbitmq安装目录的plugins文件夹，将解压的文件复制进去

重新启动rabbitmq ，输入命令
rabbitmq-plugins enable rabbitmq_delayed_message_exchange

停止：net stop RabbitMQ
启动：net start RabbitMQ
1
2


配置类

package com.springboot.rabbitmq.example.demo6.config;

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

import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.CustomExchange;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.rabbit.connection.CachingConnectionFactory;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import lombok.extern.slf4j.Slf4j;

/**
 * @method
 * @author Mr yi
 * @time 2019年6月23日
 */
@Configuration
@Slf4j
public class RabbitConfigDemo6    {

 
    //队列名称
    final static String queue = "queue_demo6";

    //交换机名称
    final static String exchangeName = "deom6Exchange";
    
    // routingKey
    final static String routingKey  = "keyDemo6";
    
     

    @Autowired
    private CachingConnectionFactory connectionFactory;
    
    @Bean
    public Queue queueDemo6() {
        // 第一个参数是创建的queue的名字，第二个参数是是否支持持久化
        return new Queue(RabbitConfigDemo6.queue, true);
    }

    @Bean
    public CustomExchange delayExchange6() {
        Map<String, Object> args = new HashMap<String, Object>();
        args.put("x-delayed-type", "direct");
        return new CustomExchange(RabbitConfigDemo6.exchangeName, "x-delayed-message", true, false, args);
    }
 
    @Bean
    public Binding bindingNotify6() {
        return BindingBuilder.bind(queueDemo6()).to(delayExchange6()).with(RabbitConfigDemo6.routingKey).noargs();
    }
 
     

/**      @Bean
      public RabbitTemplate rabbitTemplate(){
          //若使用confirm-callback ，必须要配置publisherConfirms 为true
          connectionFactory.setPublisherConfirms(true);
          //若使用return-callback，必须要配置publisherReturns为true
          connectionFactory.setPublisherReturns(true);
          RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
          //使用return-callback时必须设置mandatory为true，或者在配置中设置mandatory-expression的值为true
         // rabbitTemplate.setMandatory(true);
   
          // 如果消息没有到exchange,则confirm回调,ack=false; 如果消息到达exchange,则confirm回调,ack=true
          rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
              @Override
              public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                  if(ack){
                      log.info("消息发送成功:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
                  }else{
                      log.info("消息发送失败:correlationData({}),ack({}),cause({})",correlationData,ack,cause);
                  }
              }
          });
          
          //如果exchange到queue成功,则不回调return;如果exchange到queue失败,则回调return(需设置mandatory=true,否则不回回调,消息就丢了)
          rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
              @Override
              public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                  log.info("消息丢失:exchange({}),route({}),replyCode({}),replyText({}),message:{}",exchange,routingKey,replyCode,replyText,message);
              }
          });
          return rabbitTemplate;
      }

**/
     

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
生产者，设置setDelay(1 * 1000 * 60 ); 延时 1分钟

package com.springboot.rabbitmq.example.demo6.producers;

import java.text.SimpleDateFormat;
import java.util.Date;
import java.util.UUID;

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.AmqpTemplate;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessageBuilder;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.core.MessageProperties;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;

import com.alibaba.fastjson.JSONObject;

import lombok.extern.slf4j.Slf4j;
/**
 * 
 * @method 生产者
 * @author Mr yi
 * @time 2019年6月19日
 */
@Component
@Slf4j
public class ProducersDemo6 {

 
    @Autowired
    private AmqpTemplate rabbitTemplate;
    
    /**
     * @method 生产者发送消息,direct模式下需要传递一个routingKey
     * @author Mr yi
     * @time 2019年6月19日
     * @throws Exception
     */
    public void send( ) throws Exception {
        
        log.info("【订单生成时间】" + new Date().toString() +"【1分钟后检查订单是否已经支付】"  );
        
        this.rabbitTemplate.convertAndSend("deom6Exchange", "keyDemo6", "订单实体类对象信息", new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                message.getMessageProperties().setDelay(1 * 1000 * 60 );
                return message;
            }
        });
 
         
    }
     
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
消费者，消费者一分钟后得到生产者发送的消息

package com.springboot.rabbitmq.example.demo6.consumers;

import java.io.IOException;
import java.util.Date;
import java.util.Map;

import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitHandler;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.amqp.support.AmqpHeaders;
import org.springframework.messaging.handler.annotation.Header;
import org.springframework.messaging.handler.annotation.Headers;
import org.springframework.stereotype.Component;
import com.alibaba.fastjson.JSONObject;
import com.rabbitmq.client.Channel;

import lombok.extern.slf4j.Slf4j;

/**
 * 
 * @method  消费者
 * @author Mr yi
 * @time 2019年6月19日
 */
@Component
@Slf4j
public class ConsumersDemo6 {
    
    @RabbitListener(queues = "queue_demo6")
    public void process(String order,  Message message, @Headers Map<String, Object> headers, Channel channel) throws IOException {
    
        log.info("【 监听到延时队列消息】 - 【消费时间】 - [{}]- 【订单内容】 - [{}]",  new Date(), order); 
        // 判断订单是否已经支付，如果支付则；否则，取消订单（逻辑代码省略)
        
        // 手动ack
        Long deliveryTag = (Long) headers.get(AmqpHeaders.DELIVERY_TAG);
        // 手动签收
        channel.basicAck(deliveryTag, false);
        System.out.println("执行结束....");
        
    }
    
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
测试

@Autowired
    private ProducersDemo6 producers;
    
    @RequestMapping("/send")
    public String send() throws Exception {
        producers.send();
        return "success";
    }
1
2
3
4
5
6
7
8
启动程序，执行方法

控制台输出

rabbitmq服务端，queue_demo6 其中并没有消息进入就绪状态，这一点也是和第一种方式（使用死信）的区别优势所在。


等待一分钟后，消费者接受到消息控制台

源码下载：https://download.csdn.net/download/qq_29914837/11264460

如果你觉得本篇文章对你有所帮助的话，麻烦请点击头像右边的关注按钮，谢谢！

技术在交流中进步，知识在分享中传播
————————————————
版权声明：本文为CSDN博主「互联网叫兽」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/qq_29914837/article/details/94070677

gb4215287
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码
06-29
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码。参考博客：https://blog.csdn.net/qq_29914837/article/details/94070677
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
在本项目中，我们将探讨如何实现RabbitMQ的延时队列以及在四种不同的交换机模式下的队列配置。 首先，让我们理解RabbitMQ的延时队列。在实际业务场景中，有时我们需要在特定时间后才处理某些消息，例如订单超时取消...
RabbitMQ实现延时消息的两种方法
lan_kang的博客
12-17 5469
文章目录RabbitMQ实现延时消息的两种方法1、死信队列1.1消息什么时候变为死信(dead-letter)1.2死信队列的原理1.3 代码实现1.4死信队列的一个小坑2 、延时插件2.1如何实现 RabbitMQ实现延时消息的两种方法 1、死信队列 1.1消息什么时候变为死信(dead-letter) 消息被否定接收，消费者使用basic.reject 或者 basic.nack并且requeue 重回队列属性设为false。 消息在队列里得时间超过了该消息设置的过期时间（TTL）。 消息队列到达了它
rabbitmq实现延时队列
LATER
09-15 367
目的： rabbitmq实现延时队列 步骤： 1.docker 下为rabbitmq安装rabbitmq-delayed-message-exchange插件 2.使用bean注入支持延时队列类型的交换机 3.使用注解注入延时队列 4.延迟发送mq
RabbitMQ之延迟队列
最新发布
CSDN_LiMingfly的博客
05-01 969
RabbitMQ 提供了过期时间 TTL 机制，可以设置消息在队列中的存活时长。在消息到达过期时间时，会从当前队列中删除，并被 RabbitMQ 自动转发到对应的死信队列中。延迟消息就是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。2:利用 RabbitMQ 中的插件 x-delay-message。然后再来消费该死信队列，这样就可以实现一个延迟队列的效果。失败重试：业务操作失败后，间隔一定的时间进行失败重试。此种方式需要安装mq的延迟第一列插件。
RabbitMq——延迟队列（基于延迟交换机实现）
weixin_50616848的博客
03-19 3235
延迟队列可以通过设置生产者发送设置有ttl时间的信息给队列来实现，但这种方式中的消息可能不会按时成为死信，而且rabbitmq每次只能检测第一个消息是否过期，如果过期就丢入死信队列，第一个消息延迟时间很长，第二个消息延迟时间很短，第二个消息并不会先执行。 如：若先发一个ttl为40s的消息，然后发一个ttl为10s的消息，ttl为10s的消息并不会先被执行，而是要等ttl为40s的消息消费完后，再消费ttl为10s的消息。 延迟交换机：类型为：x-delayed-message，消息发送给延迟交换机，交
RabbitMQ 笔记
Azure_xw的博客
05-18 528
延迟队列实现原理 a. 死信的来源 ⅰ. 消息 TTL 过期 ⅱ. 队列已经达到了最大长度(队列满了，无法添加消息到 MQ 中) ⅲ. 消息被拒绝 b. 延迟队列：不就想要消息延迟多久被处理，TTL 则刚好能让消息在延迟多久之后成为死信，成为死信的消息都会被投递到死信队列里，这样只需要消费者一直消费死信队列里的消息就完事了，因为里面的消息都是希望被立即处理的消息 c. 存在的问题： ⅰ. RabbitMQ 只会检查第一个消息是否过期，过期则投递到死信队列中， ⅱ. 如果第一消息的延时时长很长，而第二个消息.
学会RabbitMQ的延迟队列，提高消息处理效率
热门推荐
战斧的博客
08-08 1万+
延迟队列指的是当我们将消息发送到RabbitMQ时，可以指定消息的有效期或者消息需要在未来某个时间点才能被消费。这种消息被称为“延迟消息”。
springboot+rabbitmq实现延时队列
08-29
要使用SpringBoot和RabbitMQ实现延时队列，我们需要以下步骤： 1. **依赖配置**：在`pom.xml`文件中添加RabbitMQ的Spring Boot Starter依赖，确保版本与SpringBoot版本兼容。 2. **配置RabbitMQ**：在`application...
RabbitMQ延迟队列及消息延迟推送实现详解
08-25
延迟队列的实现方式有多种，例如，使用死信队列+TTL 过期时间来实现延迟队列，使用 RabbitMQ 官方提供的延迟队列插件等。每种方式都有其优缺点，需要根据实际情况选择合适的方式。 在使用 RabbitMQ 实现延迟队列时...
rabbitmq 7种队列实现java版
01-20
文章目录rabbitmq7种实现方式搭建maven项目引入依赖创建连接简单队列消息生产者消息消费者work queues 工作队列生产者消费者能者多劳（公平分发）：消费能力强则消费更多消息Publish/Subscribe 发布订阅模式生产者...
RabbitMQ延迟队列实现 ( 插件版 )
想好了就去做吧 即便失败了 至少这条路上留下了你的脚印
07-12 3812
安装完rabbitmq-delayed-message-exchange插件后，会生成一个新的Exchange类型 x-delayed-message ，该类型消息支持延迟投递机制。接收到消息后并不会立即将消息投递至目标队列，而是存储在mnesia table(一个分布式数据库)中，然后检测消息延迟时间，如果达到可投递时间( 过期时间 )后，将其通过 x-delayed-type 类型标记的交换机投递到目标队列中。...
springcloud：springboot整合RabbitMQ｜RabbitMQ保证消息可靠性（三）
55555的博客
05-14 863
2. RabbitMQ使用 2.1 RabbitMQ的安装 2.2 springboot整合RabbitMQ 2.3 RabbitMQ保证消息可靠性 2.4 RabbitMQ死信队列&延迟交换机
rabbitMq可靠性投递之配置（消息至交换机，至队列不通的回调） -- 转载
有一颗前端心的后端开发小哥
04-02 438
rabbitMq可靠性投递之配置（消息至交换机，至队列不通的回调） 记录mq学习的一个bug，配置了mandatory为true,可是callback却不生效。网上搜了一圈，发现该篇文章，❤ 在此记录下： 转载连接：https://www.cnblogs.com/wangbiaohistory/p/14630493.html @Bean public RabbitTemplate rabbitTemplate(CachingConnectionFactory factory) { //若使用
RabbitTemplate的两段回调确认机制
偶尔写写开发遇到的小知识
07-13 1641
RabbitTemplate 确认机制
Spring Boot整合RabbitMQ实现延时队列，满足订单延时支付需求
weixin_40648256的博客
05-06 614
springboot 整合 rabbitmq 实现延时队列，满足订单延时支付需求。在编写完上述代码后，我们可以编写测试代码来验证延时队列的功能是否正常。在 RabbitMQ 中，可以通过设置消息的过期时间来实现延时队列。从输出中可以看出，我们成功地接收到了延时消息，延时队列的功能正常。方法发送了一条延时消息。在发送消息之前，我们可以通过。注解的方法来监听队列中的消息。在需要接收延时消息的地方，需要定义一个。在需要发送延时消息的地方，可以注入。
消息中间件RabbitMQ（四）——消息收发方式
scorpio的博客
02-05 1623
消息中间件RabbitMQ（四）——消息收发方式
RabbitMQ延时队列应用
学习记录和总结
05-07 591
RabbitMQ 延时队列的介绍和应用
使用RabbitMQ解决服务间耦合——消息队列解析
JMS专注于Java环境，提供了统一的接口，但其消息模型相对简单，仅包含队列和主题两种。 3. **RabbitMQ特性** RabbitMQ支持AMQP协议，这使得它能够在多种编程语言中使用，包括Java、Python、Ruby、C#等。RabbitMQ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值