本文详细讲解了如何在RabbitMQ中实现死信队列，包括死信概念、常见来源（如消息TTL过期、队列长度限制和消息被拒），并通过代码实例展示了如何配置交换机、队列和消费者来处理死信消息，确保业务数据完整性。
死信队列
1、死信的概念
先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。
应用场景：为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，当消息消费发生异常时，将消息投入死信队列中。还有比如说：用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。
2、死信的来源
-
消息 TTL（存活时间） 过期
-
队列达到最大长度(队列满了，无法再添加数据到队列中)
-
消息被拒绝（消费方拒绝应答：basic.reject 或 basic.nack）并且（不放回队列中： requeue=false）
3、死信实战
3.1. 代码架构图
描述：一个生产者，两个消费者，有一个正常的交换机，类型为direct，路由模式。一个消息正常发给消费者C1，结果出现了上面描述的三种情况：消息 TTL 过期、队列达到最大长度、消息被拒绝，消息成为死信，之后消息被转发到（死信交换机）ded_exchange，类型也为direct，之后进入死信队列，最终由消费者C2消费。
代码核心部分在C1。
3.2. 消息TTL 过期
先启动C1，让其创建正常交换机、死信交换机、正常队列、死信队列，以及之间的绑定关系，之后关闭C1，生产者发送消息，这是模拟“消息TTL 过期”。之后启动C2去消息死信队列中的消息。
消费者 C1 代码 (启动之后关闭该消费者 模拟其接收不到消息)
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
import java.util.HashMap;
import java.util.Map;
/**
* 死信队列 消费者C1
*/
public class Consumer01 {
//正常交换机名称
private static final String NORMAL_EXCHANGE = "normal_exchange";
//死信交换机名称
private static final String DEAD_EXCHANGE = "dead_exchange";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
//声明正常交换机和死信交换机 类型为 direct
channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明死信队列,并绑定死信交换机
String deadQueue = "dead-queue";
channel.queueDeclare(deadQueue, false, false, false, null);
channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");
//正常队列 将消息转发给死信队列 所需参数
Map<String, Object> params = new HashMap<>();
//正常队列 设置 死信交换机，参数 key 是固定值
params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
//正常队列设置死信 routing-key，参数 key 是固定值
params.put("x-dead-letter-routing-key", "lisi");
//声明正常队列,并绑定正常交换机
String normalQueue = "normal-queue";
channel.queueDeclare(normalQueue, false, false, false, params);
channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");
System.out.println("Consumer01等待接收消息........... ");
//成功接收消息的回调
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println("Consumer01 接收到消息"+message);
};
//接收消息
channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {});
}
}
生产者代码：
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
/**
* 死信队列 生产者
*/
public class Producer {
//正常交换机名称
private static final String NORMAL_EXCHANGE = "normal_exchange";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
//声明正常交换机和死信交换机 类型为 direct
channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
//死信消息，设置消息的 TTL（存活时间） 时间：10s
AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
for (int i = 1; i <11 ; i++) {
String message="info"+i;
//正常交换机名称、正常交换机于正常队列之间的routingKey、配置参数、消息
channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", properties, message.getBytes());
System.out.println("生产者发送消息:"+message);
}
}
}
消费者 C2 代码(以上步骤完成后 启动 C2 消费者 它消费死信队列里面的消息)
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
/**
* 死信队列 消费者C2 - 消费死信消息
*/
public class Consumer02 {
//死信队列的名称 - 和C1中保持一致
private static final String DEAD_QUEUE = "dead-queue";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
System.out.println("Consumer02等待接收死信队列消息........... ");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println("Consumer02 接收死信队列的消息" + message);
};
channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
}
}
3.3. 队列达到最大长度
在测试时，还是需要关闭C1，这样消息才会积压，正常队列才会满。
1.消息生产者代码去掉 TTL 属性:
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
/**
* 死信队列 生产者
*/
public class Producer {
//正常交换机名称
private static final String NORMAL_EXCHANGE = "normal_exchange";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
//声明正常交换机和死信交换机 类型为 direct
channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
//该信息是用作演示队列个数限制
for (int i = 1; i <11 ; i++) {
String message="info"+i;
//正常交换机名称、正常交换机于正常队列之间的routingKey、配置参数、消息
channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", null, message.getBytes());
System.out.println("生产者发送消息:"+message);
}
}
}
2.C1 消费者修改以下代码
注意此时需要把原先队列删除 因为参数改变了
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
import java.util.HashMap;
import java.util.Map;
/**
* 死信队列 消费者C1
*
* @auther wlw
* @date 2022/3/13
*/
public class Consumer01 {
//正常交换机名称
private static final String NORMAL_EXCHANGE = "normal_exchange";
//死信交换机名称
private static final String DEAD_EXCHANGE = "dead_exchange";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
//声明正常交换机和死信交换机 类型为 direct
channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明死信队列,并绑定死信交换机
String deadQueue = "dead-queue";
channel.queueDeclare(deadQueue, false, false, false, null);
channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");
//正常队列 将消息转发给死信队列 所需参数
Map<String, Object> params = new HashMap<>();
//正常队列 设置 死信交换机，参数 key 是固定值
params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
//正常队列设置死信 routing-key，参数 key 是固定值
params.put("x-dead-letter-routing-key", "lisi");
//设置正常队列的限制
params.put("x-max-length", 6);
//声明正常队列,并绑定正常交换机
String normalQueue = "normal-queue";
channel.queueDeclare(normalQueue, false, false, false, params);
channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");
System.out.println("Consumer01等待接收消息........... ");
//成功接收消息的回调
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println("Consumer01 接收到消息"+message);
};
//接收消息
channel.basicConsume(normalQueue, true, deliverCallback, consumerTag -> {});
}
}
3.C2 消费者代码不变(启动 C2 消费者)
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
/**
* 死信队列 消费者C2 - 消费死信消息
*/
public class Consumer02 {
//死信队列的名称 - 和C1中保持一致
private static final String DEAD_QUEUE = "dead-queue";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
System.out.println("Consumer02等待接收死信队列消息........... ");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println("Consumer02 接收死信队列的消息" + message);
};
channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
}
}
3.4. 消息被拒
1.消息生产者代码同上生产者一致
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
/**
* 死信队列 生产者
*/
public class Producer {
//正常交换机名称
private static final String NORMAL_EXCHANGE = "normal_exchange";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
//声明正常交换机和死信交换机 类型为 direct
channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
for (int i = 1; i <11 ; i++) {
String message="info"+i;
//正常交换机名称、正常交换机于正常队列之间的routingKey、配置参数、消息
channel.basicPublish(NORMAL_EXCHANGE, "zhangsan", null, message.getBytes());
System.out.println("生产者发送消息:"+message);
}
}
}
2.C1 消费者代码
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
import java.util.HashMap;
import java.util.Map;
/**
* 死信队列 消费者C1
*/
public class Consumer01 {
//正常交换机名称
private static final String NORMAL_EXCHANGE = "normal_exchange";
//死信交换机名称
private static final String DEAD_EXCHANGE = "dead_exchange";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
//声明正常交换机和死信交换机 类型为 direct
channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
//声明死信队列,并绑定死信交换机
String deadQueue = "dead-queue";
channel.queueDeclare(deadQueue, false, false, false, null);
channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");
//正常队列 将消息转发给死信队列 所需参数
Map<String, Object> params = new HashMap<>();
//正常队列 设置 死信交换机，参数 key 是固定值
params.put("x-dead-letter-exchange", DEAD_EXCHANGE);
//正常队列设置死信 routing-key，参数 key 是固定值
params.put("x-dead-letter-routing-key", "lisi");
//设置正常队列的限制
//params.put("x-max-length", 6);
//声明正常队列,并绑定正常交换机
String normalQueue = "normal-queue";
channel.queueDeclare(normalQueue, false, false, false, params);
channel.queueBind(normalQueue, NORMAL_EXCHANGE, "zhangsan");
System.out.println("Consumer01等待接收消息........... ");
//成功接收消息的回调
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
if(message.equals("info5")){
// "info5"为消息内容
System.out.println("Consumer01 接收到消息" + message + "并拒绝签收该消息");
//拒绝应答，requeue 设置为 false 代表拒绝重新入队 该队列如果配置了死信交换机将发送到死信队列中
//并且下面接收消息也要设置为手动应答
channel.basicReject(delivery.getEnvelope().getDeliveryTag(), false);
}else {
System.out.println("Consumer01 接收到消息"+message);
//确认应答
channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
}
};
//接收消息
boolean autoAck = false; //表示手动应答
channel.basicConsume(normalQueue, autoAck, deliverCallback, consumerTag -> {});
}
}
3.C2 消费者代码不变
package com.wlw.rabbitmq.eight;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.DeliverCallback;
import com.wlw.rabbitmq.utils.RabbitMqUtils;
/**
* 死信队列 消费者C2 - 消费死信消息
*/
public class Consumer02 {
//死信队列的名称 - 和C1中保持一致
private static final String DEAD_QUEUE = "dead-queue";
public static void main(String[] argv) throws Exception {
Channel channel = RabbitMqUtils.getChannel();
System.out.println("Consumer02等待接收死信队列消息........... ");
DeliverCallback deliverCallback = (consumerTag, delivery) -> {
String message = new String(delivery.getBody(), "UTF-8");
System.out.println("Consumer02 接收死信队列的消息" + message);
};
channel.basicConsume(DEAD_QUEUE, true, deliverCallback, consumerTag -> {});
}
}
启动消费者 1 然后再启动消费者 2
扫一扫
819
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
