RabbitMQ高级特性:死信队列
什么是死信队列?
死信队列,英文缩写DLX,Dead Letter Exchange(死信交换机),当消息成为Dead message(消息过期)后,可以被重新发送到另一个交换机,这个交换机就算是DLX,其实死信交换机(队列)和正常交换机(队列)没有什么区别
为什么叫死信队列但是翻译过来叫死信交换机呢,因为RabbitMQ比较特殊,其他MQ只有队列没有交换机这个概念的
正常来说,队列设置了过期时间,当消息到了队列之后,在过期时间内没有被消费,那么这个消息就被丢弃了,但是如果这个队列绑定了一个DLX死信队列(交换机),那么就算消息过期了也不会被直接丢弃掉,而是会发送给死信交换机,那么死信交换机又可以绑定其他队列,将这些消息存储到其他队列,从而又可以进行消息消费,就算这个意思,过程如图所示
什么情况下消息成为死信队列
消息成为死信队列的三种情况
1 队列消息长度达到限制
比如说给队列最大存储长度为10,当11条消息进来的时候,第11条消息进不去了，那么第11条消息就是死信
2 消费者拒绝消费消息,basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false,
消费者使用basicNack/basicReject,并且requeue=false,表示消费者拒绝重新消费该消息
3 原队列存在消息过期设置,消息到达超时时间未被消费
原来的队列存在过期时间,但是到了过期时间还没有消费该消息
队列绑定交换机的方式
给队列设置两个参数 x-dead-letter-exchange(设置交换机的名称)和x-dead-letter-routing-key(发送消息时指定的routingkey)
死信队列代码实现
声明两套交换机队列,一套是正常的交换机队列,一套是死信的交换机队列
1 声明正常队列和交换机test_queue_dlx test_exchange_dlx
2 声明死信队列和死信交换机 queue_dlx exchange_dlx
3 正常队列绑定死信交换机
设置两个参数
1死信交换机名称 x-dead-letter-exchange
2发送给死信交换机的路由键 x-dead-letter-routing-key
1 消息过期时间的测试
测试过期时间的死信 给正常的交换机发送消息,过了存活时间消息自动从正常队列跑到死信队列
2 队列长度限制的测试
如果发送成功 那么因为设置了最大长度是10,只会有10条进行正常队列剩下的会跑到死信队列,过了10s后正常队列中的消息也会自动跑到死信队列中
3 消费者消息拒收的限制
消费者Consumer监听正常的队列,然后让消息拒绝接收并且不重回队列
由于消费者拒收消息,消息会直接跑到私信队列中
最终相关测试代码
生产者配置
复制代码消费者配置
复制代码生产者发送消息
package com.producer.test;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.test.context.ContextConfiguration;
import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
/**
* @prog ram: SpringBoot_RabbitMQ_Advanced
* @description: 测试确认模式消息是否发送成功
* @author: 魏一鹤
* @createDate: 2022-04-04 23:10
**/
//spring配置文件
@RunWith(SpringJUnit4ClassRunner.class)
//加载文件的路径
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml" )
public class ProducerTest {
//注入 RabbitTemplate
@Autowired
private RabbitTemplate rabbitTemplate;
/**
* 确认模式:
* 步骤
* 1确认模式的开启:在connectionFactory中开启,默认是false不开启的 publisher-confirms="true"
* 2回调函数的编写:在RabbitTemplate模板工具类定义ConfirmCallBack(回调函数).当消息发送出去的时候回调函数会自动执行,返回true(成功)或者false(失败)
**/
@Test
public void testConfirm() {
//定义确认模式的回调函数
rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
@Override
//匿名内部类
/**
* confirm有三个参数 下面一一说明
* CorrelationData correlationData 相关的配置信息
* boolean ack exchange交换机是否成功收到了消息 true成功false失败
* String cause 失败原因 ack=false
**/
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
System.out.println( "确认模式的回调函数被执行了!" ); //确认模式的回调函数被执行了!
System.out.println( "消息是否发送成功?" +ack);
if(ack){
//交换机接收成功生产者发送的消息
System.out.println( "接收成功消息！原因是:" +cause);
}else{
//交换机接收没有成功生产者发送的消息
System.out.println( "接收失败消息！原因是:" +cause);
//将来会做处理,就算消息发送失败也会重新去发送消息,保证消息第二次发送成功
}
}
});
//发送消息
rabbitTemplate.convertAndSend( "test_exchange_confirm" , "confirm" , "message confirm..." );
}
/**
* 回退模式:当消息发送给Exchange交换机后,交换机路由到queue失败时才会执行ReturnCallBack
* 步骤
* 1回退模式的开启:在connectionFactory中开启,默认是false不开启的 publisher-returns="true"
* 2回调函数的编写:在RabbitTemplate模板工具类定义ConfirmCallBack(回调函数).当消息发送出去的时候回调函数会自动执行,返回true(成功)或者false(失败)
* 3设置Exchange处理消息的模式 它有两种模式
* 3.1 第一种模式:如果消息没有路由到queue队列,则会丢弃消息(默认的方式)
* 3.2 第二种模式:如果消息没有路由到queue队列,则返回给消息的发送方ReturnCallBack
**/
@Test
public void testReturn() {
//由于处理消息的模式默认是如果消息没有路由到queue队列,则会丢弃消息
//所以需要设置交换机处理消息的模式,交换机会把消息返回给对应的生产者,生产者通过监听就能拿到消息
rabbitTemplate.setMandatory(true);
//编写returnCallBack回调函数
rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback(){
@Override
//匿名内部类
/**
* returnedMessage有五个参数 下面一一说明
* Message message 消息对象
* int replyCode 返回编码 错误码
* String replyText 错误信息
* String exchange 交换机
* String routingKey 路由键
**/
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println( "返回模式的回调函数被执行了!" );
System.out.println( "消息对象:" +message);
System.out.println( "返回编码(错误码):" +replyCode);
System.out.println( "错误信息:" +replyText);
System.out.println( "交换机:" +exchange);
System.out.println( "路由键:" +routingKey);
//将来会做处理 把信息重新路由
//-----------------------------------------打印信息
//返回模式的回调函数被执行了!
//消息对象:(Body:'message confirm...' MessageProperties [headers={}, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, receivedDeliveryMode=PERSISTENT, priority=0, deliveryTag=0])
//返回编码(错误码):312
//错误信息:NO_ROUTE
//交换机:test_exchange_confirm
//路由键:confirm111
}
});
//发送消息
rabbitTemplate.convertAndSend( "test_exchange_confirm" , "confirm" , "message confirm..." );
}
//专门测试限流循环发送消息
@Test
public void testSend() {
for (int i = 0; i < 10; i++) {
//发送消息
rabbitTemplate.convertAndSend( "test_exchange_confirm" , "confirm" , "message confirm..." );
}
}
//测试ttl
/**
* ttl 过期时间分为两种
* 1队列统一过期
* 2消息单独过期
* 如果设置了消息的过期时间,也设置了队列的过期时间,它以时间短的为准！
* 如果队列过期后,会将队列所有消息全部移除,因为是统一的
* 消息过期后,只有消息在队列顶端(快要被消费),才会判断其是否过期,如果过期就会被移除掉
**/
@Test
public void testTTL() {
//消息单独过期 在convertAndSend方法中心新增一个参数 MessagePostProcessor 加载匿名内部类和它的重写方法
//MessagePostProcessor 消息处理对象 设置一些消息参数信息
//发送消息
for (int i = 0; i < 10; i++) {
if(i==5){
//过期的消息
rabbitTemplate.convertAndSend( "test_exchange_ttl" , "ttl.weiyihe" , "message ttl..." ,new MessagePostProcessor(){
@Override
public Message postProcessMessage(Message message) throws AmqpException {
//设置message的信息 setExpiration 设置消息过期时间
message.getMessageProperties().setExpiration( "10000" );
//返回该消息
return message;
}
});
}else{
//不过期的消息
rabbitTemplate.convertAndSend( "test_exchange_ttl" , "ttl.weiyihe" , "message ttl..." );
}
}
}
/**
* 发送测试私信消息
* 1、消息过期时间的测试
* 2、队列长度限制的测试
* 3、消费者消息拒收的限制
**/
@Test
public void testDlx(){
//1、测试过期时间的死信 给正常的交换机发送消息
//如果消息正常发送到正常的交换机,过了10s会自动去死信队列
//发送消息
//rabbitTemplate.convertAndSend("test_exchange_dlx", "test.dlx.haha", "我是一条消息,我会死吗?");
//2、队列长度限制的测试
//发送20条信息 现在x-max-length是10
//如果发送成功 那么因为设置了最大长度是10,只会有10条进行正常队列
// 剩下的会跑到死信队列,过了10s后正常队列中的消息也会自动跑到死信队列中
//for (int i = 0; i < 20; i++) {
// //发送消息
// rabbitTemplate.convertAndSend("test_exchange_dlx", "test.dlx.haha", "我是一条消息,我会死吗?");
//}
//3 消费者消息拒收的限制
//消费者Consumer监听正常的队列,然后让消息拒绝接收并且不重回队列
rabbitTemplate.convertAndSend( "test_exchange_dlx" , "test.dlx.haha" , "我是一条消息,我会死吗?" );
}
}
复制代码消费者拒收消息
package com.wyh.listener;
import com.rabbitmq.client.Channel;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener;
import org.springframework.stereotype.Component;
import java.util.concurrent.TimeUnit;
/**
* @program: SpringBoot_RabbitMQ_Advanced
* @description: RabbitMQ 死信通信
* @author: 魏一鹤
* @createDate: 2022-04-06 20:30
**/
//包扫描注解 把bean加载到spring容器中
@Component
//实现MessageListener接口并重写onMessage方法
public class DLXCKListener implements ChannelAwareMessageListener {
@Override
public void onMessage(Message message, Channel channel) throws Exception {
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
//1 接收并打印消费者收到(消费)的消息
System.out.println(new String(message.getBody()));
//2 处理业务逻辑
System.out.println( "处理业务逻辑......" );
//故意使得业务报错
int num=3/0;
channel.basicAck(deliveryTag,true);
} catch (Exception e) {
System.out.println( "出现异常,消费者拒绝签收！" );
//死信队列 拒绝签收requeue=false 将消息路由到死信队列中
channel.basicNack(deliveryTag,true,false);
}
}
}
复制代码DLX小结
1 死信交换机(队列)和普通交换机(队列)没什么区别
2 当消息成为死信后,如果该队列绑定了死信队列,那么该消息就会被死信交换机路由到死信队列,如果没有绑定死信队列,那么消息就会根据消息过期时间丢失,就不会被消费
成为死信队列的三种情况
1 队列消息长度达到最大限制
2 消息者拒收消息,并且不允许重回路由
3 原队列设置过期时间,消息到达超时时间未被消费