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

最新推荐文章于 2024-07-24 11:12:17 发布
最新推荐文章于 2024-07-24 11:12:17 发布
阅读量972 收藏
点赞数
分类专栏： 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
    评论
专栏目录
RabbitMQ自学之路（十）——RabbitMQ知识点整理
互联网叫兽
09-06 612
一、RabbitMQ 中 vhost 的作用是什么？ vhost：每个 RabbitMQ 都能创建很多 vhost，我们称之为虚拟主机，每个虚拟主机其实都是 mini 版的RabbitMQ，它拥有自己的队列，交换器和绑定，拥有自己的权限机制。 二、RabbitMQ 有哪些重要的组件？ ConnectionFactory（连接管理器）：应用程序与Rabbit之间建立连接的管理器，程序代码中使用。 Channel（信道）：消息推送使用的通道。 Exchange（交换器）：用于接受、分配消息。 Queue（队列）
RabbitMQ之延迟队列
CSDN_LiMingfly的博客
05-01 975
RabbitMQ 提供了过期时间 TTL 机制，可以设置消息在队列中的存活时长。在消息到达过期时间时，会从当前队列中删除，并被 RabbitMQ 自动转发到对应的死信队列中。延迟消息就是指当消息被发送以后，并不想让消费者立即拿到消息，而是等待指定时间后，消费者才拿到这个消息进行消费。2:利用 RabbitMQ 中的插件 x-delay-message。然后再来消费该死信队列，这样就可以实现一个延迟队列的效果。失败重试：业务操作失败后，间隔一定的时间进行失败重试。此种方式需要安装mq的延迟第一列插件。
项目实战-基于SpringBoot整合RabbitMQ实现延时队列_springboot rabbit 延迟消息
2401_84159966的博客
04-18 574
【代码】项目实战-基于SpringBoot整合RabbitMQ实现延时队列_springboot rabbit 延迟消息。
RabbitMQ 实现延迟队列的两种方式
2401_84831638的博客
05-13 289
自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。深知大多数Java工程师，想要提升技能，往往是自己摸索成长，自己不成体系的自学效果低效漫长且无助。因此收集整理了一份《2024年Java开发全套学习资料》，初衷也很简单，就是希望能够帮助到想自学提升又不知道该从何学起的朋友，同时减轻大家的负担。
rabbitMq实现延迟队列
2401_84091544的博客
04-20 612
消息可靠发送、消息可靠投递、死信队列来保障消息至少被消费一次以及未被正确处理的消息不会被丢弃。另外，通过RabbitMQ集群的特性，可以很好的解决单点故障问题，不会因为单个节点挂掉导致延时队列不可用或者消息丢失。当然，延时队列还有很多其它选择，比如利用Java的DelayQueu，利用Redis的zset，利用Quartz或者利用kafka的时间轮，这些方式各有特点。自我介绍一下，小编13年上海交大毕业，曾经在小公司待过，也去过华为、OPPO等大厂，18年进入阿里一直到现在。
RabbitMQ实现延迟队列
web15085599741的博客
08-02 2273
AMQP协议和RabbitMQ队列本身没有直接支持延迟队列功能，但是可以通过以下特性模拟出延迟队列的功能。
RabbitMQ之“延时队列”_rabbitmq实现延时队列
2301_82241942的博客
04-12 599
作者在这里只创建了一个交换机，这个交换机可以同时绑定两个队列(有两个队列，一个队列设置了它的ttl(消息过期时间)，同时设置了消息过期后的路由交换机和路由的routeKey，如果不设置过期策略那么消息过期之后就会进入死信队列,另外一个队列是普通队列，监听的时候只用去监听普通队列，达到延迟队列的效果。2、下载rabbitmq_delayer_message_exchange插件（注：RabbitMQ是什么版本的，下载的插件就得是什么版本的，得对应上，以下截图为官方文档的对插件版本的要求说明。
RabbitMQ自学笔记——延迟消息
m0_62565675的博客
03-13 750
RabbitMQ自学笔记——延迟消息
spring boot 自学笔记(五) Rabbitmq集成,延时消息队列实现
热门推荐
Shiro °
05-25 1万+
本篇主要记录Spring boot 集成Rabbitmq，分为两部分， 第一部分为创建普通消息队列， 第二部分为延时消息队列实现： spring boot提供对mq消息队列支持amqp相关包，引入即可： <!-- rabbit mq --> <dependency> <groupId>org.springframework...
《RabbitMQ系列教程-第十章-RabbitMQ之延时队列》
2401_84302507的博客
04-28 210
2）当用户3天未登录，进行登录提醒、礼包赠送等3）开启一个会议后，会议达到开始时间时自动更改状态在RabbitMQ中，我们可以借助来完成延时队列的效果。
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码
06-29
springboot整合RabbitMQ实现延时队列的两种方式 教程及源码。参考博客：https://blog.csdn.net/qq_29914837/article/details/94070677
rabbitmq延时队列和四种交换机模式下队列的简单实现
08-06
在本项目中，我们将探讨如何实现RabbitMQ的延时队列以及在四种不同的交换机模式下的队列配置。 首先，让我们理解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 发布订阅模式生产者...
Prometheus 监控 RabbitMQ
最新发布
TechEnthusiast的博客
07-24 404
RabbitMQ Exporter 是连接 RabbitMQ 和 Prometheus 的桥梁，它从 RabbitMQ 收集指标并以 Prometheus 可以理解的格式暴露这些指标。通过以上步骤，您可以建立一个全面的 RabbitMQ 监控系统，及时发现并解决潜在问题，确保消息中间件的稳定运行。记住，监控是一个持续的过程，需要根据系统的变化和需求不断调整和优化。注意：请根据您的 RabbitMQ 配置调整用户名、密码和 URL。修改 Prometheus 配置文件（通常是 ​。
RabbitMQ是什么？
A_m_of_m的博客
07-21 720
RabbitMQ是一个开源的消息代理软件（Message Broker），它实现了高级消息队列协议（AMQP，Advanced Message Queuing Protocol），并支持多种消息传递协议。它最初由英国的Rabbit Technologies开发，后来被VMware收购，并在2010年开源。目前，RabbitMQ由Pivotal Software（旧名VMware）维护和支持。
Rabbitmq从入门到精通
程序员进阶之路
07-23 1002
交换机和队列的名称是不能相同的。相互隔离，不同用户之间创建的交换机是不可见的。生产者通过tcp连接到broker，broker是接收和分发消息的实体，vhost是一个虚拟主机，不同用户之间的隔离。每次连接占用一个管道，每一次连接可以多次发送消息。exchange：交换机，queue：存放消息的队列rabbitMQ四大核心：生产者，交换机，队列，消费者AMQP协议四大核心：消息，没交换，队列，绑定。
使用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、付费专栏及课程。

余额充值