目录
8. 运用场景:
8.1.传统处理超时订单
8. 2.rabbitMQ延时队列方案
9. TTL和DLX
9.1.TTL
9.2.DLX和死信队列
10. 延迟队列
10.1. 开发步骤
11. json转换
11.1.生产者
11.2.消费者
采取定时任务轮训数据库订单,并且批量处理。其弊端也是显而易见的;对服务器、数据库性会有很大的要求,
并且当处理大量订单起来会很力不从心,而且实时性也不是特别好。当然传统的手法还可以再优化一下,
即存入订单的时候就算出订单的过期时间插入数据库,设置定时任务查询数据库的时候就只需要查询过期了的订单,
然后再做其他的业务操作
一台普通的rabbitmq服务器单队列容纳千万级别的消息还是没什么压力的,而且rabbitmq集群扩展支持的也是非常好的,
并且队列中的消息是可以进行持久化,即使我们重启或者宕机也能保证数据不丢失
rabbitMQ中是没有延时队列的,也没有属性可以设置,只能通过死信交换机(DLX)和设置过期时间(TTL)结合起来实现延迟队列
TTL是Time To Live的缩写, 也就是生存时间。
RabbitMq支持对消息和队列设置TTL,对消息这设置是在发送的时候指定,对队列设置是从消息入队列开始计算, 只要超过了队列的超时时间配置, 那么消息会自动清除。
如果两种方式一起使用消息的TTL和队列的TTL之间较小的为准,也就是消息5s过期,队列是10s,那么5s的生效。
默认是没有过期时间的,表示消息没有过期时间;如果设置为0,表示消息在投递到消费者的时候直接被消费,否则丢弃。
设置消息的过期时间用 x-message-ttl 参数实现,单位毫秒。
设置队列的过期时间用 x-expires 参数,单位毫秒,注意,不能设置为0。
消息:生产者 -> 交换机 消息在生产者制造消息的时候就开始计算了TTL TTL=5
队列:生产者 -> 交换机 -> 路由键 -> 队列 当消息送达到队列的时候才开始计算TTL TTL=10
DLX即Dead-Letter-Exchange(死信交换机),它其实就是一个正常的交换机,能够与任何队列绑定。
死信队列是指队列(正常)上的消息(过期)变成死信后,能够发送到另外一个交换机(DLX),然后被路由到一个队列上,
这个队列,就是死信队列
成为死信一般有以下几种情况:
消息被拒绝(basic.reject or basic.nack)且带requeue=false参数
消息的TTL存活时间已经过期
队列长度限制被超越(队列满)
注1:如果队列上存在死信, RabbitMq会将死信消息投递到设置的DLX上去 ,
注2:通过在队列里设置x-dead-letter-exchange参数来声明DLX,如果当前DLX是direct类型还要声明
x-dead-letter-routing-key参数来指定路由键,如果没有指定,则使用原队列的路由键
通过DLX和TTL模拟出延迟队列的功能,即,消息发送以后,不让消费者拿到,而是等待过期时间,变成死信后,发送给死信交换机再路由到死信队列进行消费
10.1.1.生产者创建一个正常消息,并添加消息过期时间/死信交换机/死信路由键这3个参数
关键代码
new Queue(name, durable, exclusive, autoDelete, arguments);
new Queue(NORMAL_QUEUE, true, false, false, map)
参数说明:
name:队列名字
durable:true则持久队列
exclusive:如果我们声明一个排他队列(该队列将仅由声明者的连接使用),则为true
autoDelete:服务器不再使用时应删除队列,则为true
arguments:用于声明队列的参数
map.put("x-message-ttl", 10000);//message在该队列queue的存活时间最大为10秒
map.put("x-dead-letter-exchange", DELAY_EXCHANGE); //x-dead-letter-exchange参数是设置该队列的死信交换器(DLX)
map.put("x-dead-letter-routing-key", DELAY_ROUTING_KEY);//x-dead-letter-routing-key参数是给这个DLX指定路由键
关键代码2
new DirectExchange(NORMAL_EXCHANGE, true, false);
10.1.2.消费者A
正常情况下,由消费者A去消费队列“normal-queue”中的消息,但实际上没有,而是等消息过期
10.1.3.消费者B
消息过期后,变成死信,根据配置会被投递到DLX,然后根据死信路由键投到死信队列(即延时队列)中
RabbitmqDeadConfig
@Configuration
public class RabbitmqDeadConfig {
//定义正常的队列,交换机,路由键
public static final String NORMAL_QUEUE="normal-queue";
public static final String NORMAL_EXCHANGE="normal-exchange";
public static final String NORMAL_ROUTING_KEY="normal-routing-key";
//定义死信的队列,交换机,路由键
public static final String DEAD_QUEUE="dead-queue";
public static final String DEAD_EXCHANGE="dead-exchange";
public static final String DEAD_ROUTING_KEY="dead-routing-key";
/**
* 定义正常队列,并设置TTL(过期时间),DLX,(死信交换机),DLK(死信路由键)
* @return
*/
@Bean
public Queue normalQueue(){
Map map=new HashMap<>();
//message在该队列queue的存活时间最大为10秒
map.put("x-message-ttl", 10000);
//x-dead-letter-exchange参数是设置该队列的死信交换器(DLX)
map.put("x-dead-letter-exchange", DEAD_EXCHANGE);
//x-dead-letter-routing-key参数是给这个DLX指定路由键
map.put("x-dead-letter-routing-key", DEAD_ROUTING_KEY);
return new Queue(NORMAL_QUEUE, true, false, false, map);
}
/**
* 定义正常交换机(直连)
* @return
*/
@Bean
public DirectExchange normalExchange(){
return new DirectExchange(NORMAL_EXCHANGE,true,false);
}
/**
* 配置正常队列与交换机的绑定关系
* @return
*/
@Bean
public Binding normalBinding(){
return BindingBuilder.bind(normalQueue())
.to(normalExchange())
.with(NORMAL_ROUTING_KEY);
}
/*****************************死信************************************/
@Bean
public Queue deadQueue(){
return new Queue(DEAD_QUEUE);
}
@Bean
public DirectExchange deadExchange(){
return new DirectExchange(DEAD_EXCHANGE,true,false);
}
@Bean
public Binding deadBinding(){
return BindingBuilder.bind(deadQueue())
.to(deadExchange())
.with(DEAD_ROUTING_KEY);
}
}
SendController:
@RestController
@RequestMapping("/send")
public class SendController {
@Autowired
private RabbitTemplate rabbitTemplate;
@RequestMapping("/deadSend")
public Map deadSend(){
Map json=new HashMap();
json.put("msg","OK");
json.put("code",200);
//获取发送消息
Map data=this.json("hello,rabbitmq!! this is a directExchange");
//将消息通过绑定建发送到直连交换机,再由之间交换机群发的执行推送到队列,与路由器无关
// 流程:生产者--》交换机--》队列《--》消费者
rabbitTemplate.convertAndSend(RabbitmqDeadConfig.NORMAL_EXCHANGE,
RabbitmqDeadConfig.NORMAL_ROUTING_KEY,data);
return json;
}
/**
* 消息发送的方法
* @param msg
* @return
*/
private Map json(String msg){
Map param=new HashMap<>();
param.put("msg",msg);
param.put("code",200);
param.put("date", LocalDateTime.now()
.format(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
return param;
}
}
结果:消息会在正常队列中保存15秒,后存入死信队列
@Bean
public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory, Jackson2JsonMessageConverter jackson2JsonMessageConverter) {
RabbitTemplate rabbitTemplate = new RabbitTemplate(connectionFactory);
rabbitTemplate.setMessageConverter(jackson2JsonMessageConverter());//指定json转换器
return rabbitTemplate;
}@Bean
public Jackson2JsonMessageConverter jackson2JsonMessageConverter(){
return new Jackson2JsonMessageConverter();
}
@Bean
public SimpleRabbitListenerContainerFactory rabbitListenerContainerFactory(ConnectionFactory connectionFactory, Jackson2JsonMessageConverter jackson2JsonMessageConverter) {
SimpleRabbitListenerContainerFactory factory = new SimpleRabbitListenerContainerFactory();
factory.setConnectionFactory(connectionFactory);
factory.setMessageConverter(jackson2JsonMessageConverter());
return factory;
}@Bean
public Jackson2JsonMessageConverter jackson2JsonMessageConverter(){
return new Jackson2JsonMessageConverter();
}