Springboot rabbitmq延时队列 Springboot+rabbitmq实现延时队列的两种方式
酸酸的酸酸酱 人气:0什么是延时队列,延时队列应用于什么场景
延时队列顾名思义,即放置在该队列里面的消息是不需要立即消费的,而是等待一段时间之后取出消费。
那么,为什么需要延迟消费呢?我们来看以下的场景
- 网上商城下订单后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关系
Config.java
package com.example.demo.deadLetter; 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.Queue; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.example.demo.Constants.Constants; @Configuration public class Config { // 创建一个立即消费队列 @Bean public Queue immediateQueue() { // 第一个参数是创建的queue的名字,第二个参数是是否支持持久化 return new Queue(Constants.IMMEDIATE_QUEUE, true); } // 创建一个延时队列 @Bean public Queue delayQueue() { Map<String, Object> params = new HashMap<>(); // x-dead-letter-exchange 声明了队列里的死信转发到的DLX名称, params.put("x-dead-letter-exchange", Constants.IMMEDIATE_EXCHANGE); // x-dead-letter-routing-key 声明了这些死信在转发时携带的 routing-key 名称。 params.put("x-dead-letter-routing-key", Constants.IMMEDIATE_ROUTING_KEY); return new Queue(Constants.DELAY_QUEUE, true, false, false, params); } @Bean public DirectExchange immediateExchange() { // 一共有三种构造方法,可以只传exchange的名字, 第二种,可以传exchange名字,是否支持持久化,是否可以自动删除, //第三种在第二种参数上可以增加Map,Map中可以存放自定义exchange中的参数 return new DirectExchange(Constants.IMMEDIATE_EXCHANGE, true, false); } @Bean public DirectExchange deadLetterExchange() { // 一共有三种构造方法,可以只传exchange的名字, 第二种,可以传exchange名字,是否支持持久化,是否可以自动删除, //第三种在第二种参数上可以增加Map,Map中可以存放自定义exchange中的参数 return new DirectExchange(Constants.DEAD_LETTER_EXCHANGE, true, false); } @Bean //把立即消费的队列和立即消费的exchange绑定在一起 public Binding immediateBinding() { return BindingBuilder.bind(immediateQueue()).to(immediateExchange()).with(Constants.IMMEDIATE_ROUTING_KEY); } @Bean //把立即消费的队列和立即消费的exchange绑定在一起 public Binding delayBinding() { return BindingBuilder.bind(delayQueue()).to(deadLetterExchange()).with(Constants.DELAY_ROUTING_KEY); } }
生产者生产消息
ImmediateSender.java
package com.example.demo.deadLetter; import java.text.SimpleDateFormat; import java.util.Date; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Component; import com.example.demo.Constants.Constants; import com.example.demo.model.Booking; @Component public class ImmediateSender { @Autowired private RabbitTemplate rabbitTemplate; public void send(Booking booking, int delayTime) { System.out.println("delayTime" + delayTime); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); this.rabbitTemplate.convertAndSend(Constants.DEAD_LETTER_EXCHANGE, Constants.DELAY_ROUTING_KEY, booking, message -> { message.getMessageProperties().setExpiration(delayTime + ""); System.out.println(sdf.format(new Date()) + " Delay sent."); return message; }); } }
消费者消费消息
ImmediateReceiver.java
package com.example.demo.deadLetter; 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 com.example.demo.Constants.Constants; import com.example.demo.model.Booking; @Component @EnableRabbit @Configuration public class ImmediateReceiver { @RabbitListener(queues = Constants.IMMEDIATE_QUEUE) @RabbitHandler public void get(Booking booking) { System.out.println("收到延时消息了" + booking); } }
model类book
Book.java
package com.example.demo.model; import java.io.Serializable; import java.util.Date; public class Booking implements Serializable { private static final long serialVersionUID = 1L; private String bookingName; private Date bookingTime; private String bookingContent; private String operatorName; public Booking() { } public String getBookingName() { return bookingName; } public void setBookingName(String bookingName) { this.bookingName = bookingName; } public Date getBookingTime() { return bookingTime; } public void setBookingTime(Date bookingTime) { this.bookingTime = bookingTime; } public String getBookingContent() { return bookingContent; } public void setBookingContent(String bookingContent) { this.bookingContent = bookingContent; } public String getOperatorName() { return operatorName; } public void setOperatorName(String operatorName) { this.operatorName = operatorName; } @Override public String toString() { return super.toString(); } }
测试类
Test.java
package com.example.demo; import java.util.Date; 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 com.example.demo.Immediate.Sender; import com.example.demo.deadLetter.ImmediateSender; import com.example.demo.model.Booking; @RunWith(SpringRunner.class) @SpringBootTest public class RabbitMqTestApplicationTests { @Autowired ImmediateSender immediateSender; @Test public void test() { Booking booking = new Booking(); booking.setBookingContent("hhaha"); booking.setBookingName("预定房子"); booking.setBookingTime(new Date()); booking.setOperatorName("hellen"); immediateSender.send(booking, 1000); } }
总结第一种方式:经过测试,我们可以发现,当我们先增加一条过期时间大(10000)的A消息进入,之后再增加一个过期时间小的(1000)消息B,并没有出现想象中的B消息先被消费,A消息后被消费,而是出现了当10000过去的时候,AB消息同时被消费,也就是B消息的消费被阻塞了。
为什么会出现这样的现象呢?
我们知道利用TTL DLX特性实现的方式,实际上在第一个延时队列C里面设置了dlx,生产者生产了一条带ttl的消息放入了延时队列C中,等到延时时间到了,延时队列C中的消息变成了死信,根据延时队列C中设置的dlx的exchange的转发规则,转发到了实际消费队列D中,当该队列中的监听器监听到消息时就会正式开始消费。那么实际上延时队列中的消息也是放入队列中的,队列满足先进先出,而延时大的消息A还没出队,所以B消息也不能顺利出队。
利用Rabbitmq的插件x-delay-message实现
为了解决上面的问题,Rabbitmq实现了一个插件x-delay-message来实现延时队列。
x-delay-message安装
介绍Ubuntu系统下插件安装方式:
选择rabbitmq_delayed_message_exchange插件,选择3.6版本,进行下载
将安装包进行解压
uzip rabbitmq_delayed_message_exchange-20171215-3.6.x.zip
将插件移到rabbitmq安装的路径
sudo cp -r rabbitmq_delayed_message_exchange-20171215-3.6.x.ez /usr/lib/rabbitmq/lib/rabbitmq_server-3.6.15/plugins
Enable插件
rabbitmq-plugins enable rabbitmq_delayed_message_exchange
windows同理
Springboot集成rabbitmq实现第二种方式
XdelayConfig.java
package com.example.demo.Xdelay; 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.Queue; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import com.example.demo.Constants.Constants; @Configuration public class XdelayConfig { // 创建一个立即消费队列 @Bean public Queue immediateQueue() { // 第一个参数是创建的queue的名字,第二个参数是是否支持持久化 return new Queue(Constants.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(Constants.DELAYED_EXCHANGE_XDELAY, "x-delayed-message", true, false, args); } @Bean public Binding bindingNotify() { return BindingBuilder.bind(immediateQueue()).to(delayExchange()).with(Constants.DELAY_ROUTING_KEY_XDELAY).noargs(); } }
XdelaySender.java
package com.example.demo.Xdelay; import java.text.SimpleDateFormat; import java.util.Date; import org.springframework.amqp.AmqpException; import org.springframework.amqp.core.Message; import org.springframework.amqp.core.MessagePostProcessor; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.stereotype.Service; import com.example.demo.Constants.Constants; import com.example.demo.model.Booking; @Service public class XdelaySender { @Autowired private RabbitTemplate rabbitTemplate; public void send(Booking booking, int delayTime) { System.out.println("delayTime" + delayTime); SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss"); this.rabbitTemplate.convertAndSend(Constants.DELAYED_EXCHANGE_XDELAY, Constants.DELAY_ROUTING_KEY_XDELAY, booking, new MessagePostProcessor() { @Override public Message postProcessMessage(Message message) throws AmqpException { message.getMessageProperties().setDelay(delayTime); System.out.println(sdf.format(new Date()) + " Delay sent."); return message; } }); } }
XdelayReceiver.java
package com.example.demo.Xdelay; 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 com.example.demo.Constants.Constants; import com.example.demo.model.Booking; @Component @EnableRabbit @Configuration public class XdelayReceiver { @RabbitListener(queues = Constants.IMMEDIATE_QUEUE_XDELAY) public void get(Booking booking) { System.out.println("Receive" + booking); } }
Test.java
package com.example.demo; import java.util.Date; 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 com.example.demo.Xdelay.XdelaySender; import com.example.demo.model.Booking; @RunWith(SpringRunner.class) @SpringBootTest public class RabbitMqTestApplicationTests { @Autowired XdelaySender xdelaySender; @Test public void test11() { Booking booking = new Booking(); booking.setBookingContent("hhaha"); booking.setBookingName("预定房子"); booking.setBookingTime(new Date()); booking.setOperatorName("hellen"); xdelaySender.send(booking, 2000); } }
加载全部内容