Springboot+rabbitmq实现延时队列的两种方式

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的依赖

org.springframework.boot

spring-boot-starter-amqp

初始化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() {

// 第一个参数是创建的queuhttp://e的名字，第二个参数是是否支持持久化

return new Queue(Constants.IMMEDIATE_QUEUE, true);

}

// 创建一个延时队列

@Bean

public Queue delayQueue() {

Map 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.Chttp://onstants;

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 args = new HashMap();

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);

}

}

版权声明：本文内容由网络用户投稿，版权归原作者所有，本站不拥有其著作权，亦不承担相应法律责任。如果您发现本站中有涉嫌抄袭或描述失实的内容，请联系我们jiasou666@gmail.com 处理，核实后本网站将在24小时内删除侵权内容。