微服务-springboot-rabbitmq:实现延时队列

延时队列应用于什么场景

延时队列顾名思义，即放置在该队列里面的消息是不须要当即消费的，而是等待一段时间以后取出消费。
那么，为何须要延迟消费呢？咱们来看如下的场景

    网上商城下订单后30分钟后没有完成支付，取消订单(如：淘宝、去哪儿网)
    系统建立了预定以后，须要在预定时间到达前一小时提醒被预定的双方参会
    系统中的业务失败以后，须要重试

这些场景都很是常见，咱们能够思考，好比第二个需求，系统建立了预定以后，须要在预定时间到达前一小时提醒被预定的双方参会。那么一天之中确定是会有不少个预定的，时间也是不必定的，假设如今有1点 2点 3点 三个预定，如何让系统知道在当前时间等于0点 1点 2点给用户发送信息呢，是否是须要一个轮询，一直去查看全部的预定，比对当前的系统时间和预定提早一小时的时间是否相等呢？这样作很是浪费资源并且轮询的时间间隔很差控制。若是咱们使用延时消息队列呢，咱们在建立时把须要通知的预定放入消息中间件中，而且设置该消息的过时时间，等过时时间到达时再取出消费便可。
Rabbitmq实现延时队列通常而言有两种形式：
第一种方式：利用两个特性： Time To Live(TTL)、Dead Letter Exchanges（DLX）
第二种方式：利用rabbitmq中的插件x-delay-message

 

利用TTL DLX实现延时队列的方式

TTL DLX是什么

    TTL
    RabbitMQ能够针对队列设置x-expires(则队列中全部的消息都有相同的过时时间)或者针对Message设置x-message-ttl(对消息进行单独设置，每条消息TTL能够不一样)，来控制消息的生存时间，若是超时(二者同时设置以最早到期的时间为准)，则消息变为dead letter(死信)

    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发送

Springboot集成rabbitmq实现第一种方式

在pom.xml文件中增长rabbitmq的依赖

<dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

初始化queue exchange和queue及exchange之间的binding关系

import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.DirectExchange; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import org.springframework.amqp.core.Queue; import java.util.HashMap; import java.util.Map; @Configuration public class Config { public static final String IMMEDIATE_QUEUE = "queue.demo.immediate";//当即消费的队列名称
    public static final String IMMEDIATE_EXCHANGE = "exchange.demo.immediate";//当即消费的exchange
    public static final String IMMEDIATE_ROUTING_KEY = "routingkey.demo.immediate";//当即消费的routing-key 名称
    public static final String DELAY_QUEUE= "queue.demo.delay";//延时消费的队列名称
    public static final String DEAD_LETTER_EXCHANGE = "exchange.demo.delay";//延时消费的exchange
    public static final String DELAY_ROUTING_KEY = "routingkey.demo.delay";//延时消费的routing-key名称 // 建立一个当即消费队列
 @Bean public Queue immediateQueue() { // 第一个参数是建立的queue的名字，第二个参数是是否支持持久化
        return new Queue(IMMEDIATE_QUEUE, true); } // 建立一个延时队列
 @Bean public Queue delayQueue() { Map<String, Object> params = new HashMap<>(); // x-dead-letter-exchange 声明了队列里的死信转发到的DLX名称，
        params.put("x-dead-letter-exchange", IMMEDIATE_EXCHANGE); // x-dead-letter-routing-key 声明了这些死信在转发时携带的 routing-key 名称。
        params.put("x-dead-letter-routing-key", IMMEDIATE_ROUTING_KEY); return new Queue(DELAY_QUEUE, true, false, false, params); } public DirectExchange immediateExchange() { // 一共有三种构造方法，能够只传exchange的名字， 第二种，能够传exchange名字，是否支持持久化，是否能够自动删除， //第三种在第二种参数上能够增长Map，Map中能够存放自定义exchange中的参数
        return new DirectExchange(IMMEDIATE_EXCHANGE, true, false); } @Bean public DirectExchange deadLetterExchange() { // 一共有三种构造方法，能够只传exchange的名字， 第二种，能够传exchange名字，是否支持持久化，是否能够自动删除， // 第三种在第二种参数上能够增长Map，Map中能够存放自定义exchange中的参数
        return new DirectExchange(DEAD_LETTER_EXCHANGE, true, false); } //把当即消费的队列和当即消费的exchange绑定在一块儿
 @Bean public Binding immediateBinding() { return BindingBuilder.bind(immediateQueue()).to(immediateExchange()).with(IMMEDIATE_ROUTING_KEY); } //把延时消费的队列和延时消费的exchange绑定在一块儿
 @Bean public Binding delayBinding() { return BindingBuilder.bind(delayQueue()).to(deadLetterExchange()).with(DELAY_ROUTING_KEY); } }

 

 

生产者生产消息

import com.microservice.amqqp.amqp.config.Config; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.text.SimpleDateFormat; import java.util.Date; /** * 生产者生产消息 */ @Component public class ImmediateSender { @Autowired private RabbitTemplate rabbitTemplate; public void send(String msg, int delayTime) { System.out.println("msg="+",delayTime" + delayTime); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); this.rabbitTemplate.convertAndSend(Config.DEAD_LETTER_EXCHANGE, Config.DELAY_ROUTING_KEY, msg, message -> { message.getMessageProperties().setExpiration(delayTime + ""); System.out.println(sdf.format(new Date()) + " Delay sent."); return message; }); } }

 

消费者消费消息：

import com.microservice.amqqp.amqp.config.Config; import org.springframework.amqp.rabbit.annotation.EnableRabbit; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.context.annotation.Configuration; import org.springframework.stereotype.Component; import java.text.SimpleDateFormat; import java.util.Date; /** * 消费者消费消息 */ @Component @EnableRabbit @Configuration public class ImmediateReceiver { @RabbitListener(queues = Config.IMMEDIATE_QUEUE) @RabbitHandler public void get(String msg) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println("收到延时消息时间："+sdf.format(new Date()) + " Delay sent."); System.out.println("收到延时消息了:" + msg); } }

 

测试类：

import com.microservice.amqqp.amqp.send.ImmediateSender; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import java.util.concurrent.TimeUnit; @RunWith(SpringRunner.class) @SpringBootTest public class AmqpApplicationTests { @Autowired ImmediateSender immediateSender; @Test public void test() { immediateSender.send("我是一个延时消息",3000);//3秒 //让服务一直挂起，否则，接收消息时，服务已经停了
        while(true){ try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } }

 

 

第一次运行，须要进入rabbitmq管理界面，加上exchange，否则会报错（no exchange 'exchange.demo.immediate' in vhost '/'）

添加方式：1.浏览器打开：http://127.0.0.1:15672  2.选择Exchanges 3.Add a new exchange  ,填写name:exchange.demo.immediate,type选择：direct,点击Add exchange ，完成。

 

运行测试类，结果：

 

 再来一种测试：

import com.microservice.amqqp.amqp.send.ImmediateSender; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import java.util.concurrent.TimeUnit; @RunWith(SpringRunner.class) @SpringBootTest public class AmqpApplicationTests1 { @Autowired ImmediateSender immediateSender; /** * 发送三条消息，设置延时时间，发现全部的都在等待； * 这是由于符合先进先出原则，三条消息是依次被消费，并不会由于时间到了，就消费 */ @Test public void test() { immediateSender.send("我是一个延时消息，睡10秒",10000);//10秒
        immediateSender.send("我是一个延时消息，睡2秒",2000);//2秒
        immediateSender.send("我是一个延时消息，睡1秒",1000);//1秒 //让服务一直挂起，否则，接收消息时，服务已经停了
        while(true){ try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } }

结果：

 

 

通过测试，咱们能够发现，当咱们先增长一条过时时间大(10000)的A消息进入，以后再增长一个过时时间小的(1000)消息B,并无出现想象中的B消息先被消费，A消息后被消费，而是出现了当10000过去的时候，AB消息同时被消费，也就是B消息的消费被阻塞了。

为何会出现这样的现象呢？
咱们知道利用TTL DLX特性实现的方式，实际上在第一个延时队列C里面设置了dlx，生产者生产了一条带ttl的消息放入了延时队列C中，等到延时时间到了，延时队列C中的消息变成了死信，根据延时队列C中设置的dlx的exchange的转发规则，转发到了实际消费队列D中，当该队列中的监听器监听到消息时就会正式开始消费。那么实际上延时队列中的消息也是放入队列中的，队列知足先进先出，而延时大的消息A还没出队，因此B消息也不能顺利出队。

 

上面实现方式的源码地址：https://github.com/qjm201000/micro_service_amqp_ttldlx.git

 

 

 

 利用Rabbitmq的插件x-delay-message实现延时队列的方式

 为了解决上面的问题，Rabbitmq实现了一个插件x-delay-message来实现延时队列。

安装插件：

1.rabbit官网下载插件
插件地址

2.找到这个插件

3.下载下来复制到D:\RabbitMQ Server\rabbitmq_server-3.7.8\plugins中

 

 4.doc运行：rabbitmq-plugins enable rabbitmq_delayed_message_exchange

 

 开始写代码：

 配置：

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.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.HashMap; import java.util.Map; @Configuration public class XdelayConfig { public static final String IMMEDIATE_QUEUE_XDELAY = "queue.xdelay.immediate";//当即消费的队列名称
    public static final String DELAYED_EXCHANGE_XDELAY = "exchange.xdelay.delayed";//延时的exchange
    public static final String DELAY_ROUTING_KEY_XDELAY = "routingkey.xdelay.delay";//

    // 建立一个当即消费队列
 @Bean public Queue immediateQueue() { // 第一个参数是建立的queue的名字，第二个参数是是否支持持久化
        return new Queue(IMMEDIATE_QUEUE_XDELAY, true); } @Bean public CustomExchange delayExchange() { Map<String, Object> args = new HashMap<String, Object>(); args.put("x-delayed-type", "direct"); return new CustomExchange(DELAYED_EXCHANGE_XDELAY, "x-delayed-message", true, false, args); } //把当即消费的队列和延时消费的exchange绑定在一块儿
 @Bean public Binding bindingNotify() { return BindingBuilder.bind(immediateQueue()).to(delayExchange()).with(DELAY_ROUTING_KEY_XDELAY).noargs(); } }

发送：

import com.microservice.amqp.config.XdelayConfig; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import java.text.SimpleDateFormat; import java.util.Date; @Component public class XdelaySender { @Autowired private RabbitTemplate rabbitTemplate; public void send(String msg, int delayTime) { System.out.println("msg= "+msg+ ".delayTime" + delayTime); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); this.rabbitTemplate.convertAndSend(XdelayConfig.DELAYED_EXCHANGE_XDELAY, XdelayConfig.DELAY_ROUTING_KEY_XDELAY, msg, message -> { message.getMessageProperties().setDelay(delayTime); System.out.println(sdf.format(new Date()) + " Delay sent."); return message; }); } }

接收：

import com.microservice.amqp.config.XdelayConfig; import org.springframework.amqp.rabbit.annotation.EnableRabbit; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.context.annotation.Configuration; import org.springframework.stereotype.Component; import java.text.SimpleDateFormat; import java.util.Date; @Component @EnableRabbit @Configuration public class XdelayReceiver { @RabbitListener(queues = XdelayConfig.IMMEDIATE_QUEUE_XDELAY) public void get(String msg) { SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); System.out.println("收到延时消息时间："+sdf.format(new Date()) + " Delay sent."); System.out.println("收到延时消息:" + msg); } }

 

test:

import com.microservice.amqp.send.XdelaySender; import org.junit.Test; import org.junit.runner.RunWith; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.boot.test.context.SpringBootTest; import org.springframework.test.context.junit4.SpringRunner; import java.util.concurrent.TimeUnit; @RunWith(SpringRunner.class) @SpringBootTest public class AmqpApplicationTests { @Autowired XdelaySender xdelaySender; /** * 发送三条消息，设置延时时间，谁时间到了，谁就消费 */ @Test public void test() { xdelaySender.send("我来发一个测试消息,10秒", 10000);//10秒
        xdelaySender.send("我来发一个测试消息，2秒", 2000);//2秒
        xdelaySender.send("我来发一个测试消息，1秒", 2000);//1秒 //让服务一直挂起，否则，接收消息时，服务已经停了
        while(true){ try { TimeUnit.SECONDS.sleep(1); } catch (InterruptedException e) { e.printStackTrace(); } } } }

 

 

结果：

 

源码地址：https://github.com/qjm201000/micro_service_amqp_xdelaymessage.git