rabbitmq死信队列

死信队列

候由于特定的原因导致 queue 中的某些消息无法被消费
来源

• 消息 TTL 过期
• 队列达到最大长度(队列满了，无法再添加数据到 mq 中)
• 消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

延时队列

TTL

TTL 是 RabbitMQ 中一个消息或者队列的属性，表明一条消息或者该队列中的所有消息的最大存活时间,单位是毫秒。

• 队列设置 TTL
  第一种是在创建队列的时候设置队列的“x-message-ttl”属性
  

• 消息设置 TTL
  另一种方式便是针对每条消息设置 TTL
  
  区别

如果设置了队列的 TTL 属性，那么一旦消息过期，就会被队列丢弃(如果配置了死信队列被丢到死信队列中)，而第二种方式，消息即使过期，也不一定会被马上丢弃，因为消息是否过期是在即将投递到消费者之前判定的，如果当前队列有严重的消息积压情况，则已过期的消息也许还能存活较长时间；另外，还需要注意的一点是，如果不设置 TTL，表示消息永远不会过期，如果将 TTL 设置为 0，则表示除非此时可以直接投递该消息到消费者，否则该消息将会被丢弃。

整合springboot

<dependencies>
	 <!--RabbitMQ 依赖-->
	 <dependency>
		 <groupId>org.springframework.boot</groupId>
		 <artifactId>spring-boot-starter-amqp</artifactId>
	 </dependency>
	 <dependency>
		 <groupId>org.springframework.boot</groupId>
		 <artifactId>spring-boot-starter-web</artifactId>
	 </dependency>
	 <dependency>
		 <groupId>org.springframework.boot</groupId>
		 <artifactId>spring-boot-starter-test</artifactId>
		 <scope>test</scope>
	 </dependency>
	 <dependency>
		 <groupId>com.alibaba</groupId>
		 <artifactId>fastjson</artifactId>
		 <version>1.2.47</version>
	 </dependency>
	 <dependency>
		 <groupId>org.projectlombok</groupId>
		 <artifactId>lombok</artifactId>
	 </dependency>
	 <!--swagger-->
	 <dependency>
		 <groupId>io.springfox</groupId>
		 <artifactId>springfox-swagger2</artifactId>
		 <version>2.9.2</version>
	 </dependency>
	 <dependency>
		 <groupId>io.springfox</groupId>
		 <artifactId>springfox-swagger-ui</artifactId>
		 <version>2.9.2</version>
	 </dependency>
	 <!--RabbitMQ 测试依赖-->
	 <dependency>
		 <groupId>org.springframework.amqp</groupId>
		 <artifactId>spring-rabbit-test</artifactId>
		 <scope>test</scope>
	 </dependency>
</dependencies>

配置文件

spring.rabbitmq.host=182.92.234.71
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=123

代码结构图

队列TTL

配置文件类代码

@Configuration
public class TtlQueueConfig {
	 public static final String X_EXCHANGE = "X";
	 public static final String QUEUE_A = "QA";
	 public static final String QUEUE_B = "QB";
	 public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
	 public static final String DEAD_LETTER_QUEUE = "QD";
	 // 声明 xExchange
	 @Bean("xExchange")
	 public DirectExchange xExchange(){
		 return new DirectExchange(X_EXCHANGE);
	 }
	 // 声明 xExchange
	 @Bean("yExchange")
	 public DirectExchange yExchange(){
		 return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
	 }
	 //声明队列 A ttl 为 10s 并绑定到对应的死信交换机
	 @Bean("queueA")
	 public Queue queueA(){
		 Map<String, Object> args = new HashMap<>(3);
		 //声明当前队列绑定的死信交换机
		 args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
		 //声明当前队列的死信路由 key
		 args.put("x-dead-letter-routing-key", "YD");
		 //声明队列的 TTL
		 args.put("x-message-ttl", 10000);
		 return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
	 }
	 // 声明队列 A 绑定 X 交换机
	 @Bean
	 public Binding queueaBindingX(@Qualifier("queueA") Queue queueA,
	 @Qualifier("xExchange") DirectExchange xExchange){
		 return BindingBuilder.bind(queueA).to(xExchange).with("XA");
	 }
	 //声明队列 B ttl 为 40s 并绑定到对应的死信交换机
	 @Bean("queueB")
	 public Queue queueB(){
		 Map<String, Object> args = new HashMap<>(3);
		 //声明当前队列绑定的死信交换机
		 args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
		 //声明当前队列的死信路由 key
		 args.put("x-dead-letter-routing-key", "YD");
		 //声明队列的 TTL
		 args.put("x-message-ttl", 40000);
		 return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
	 }
	 //声明队列 B 绑定 X 交换机
	 @Bean
	 public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B,
	 @Qualifier("xExchange") DirectExchange xExchange){
		 return BindingBuilder.bind(queue1B).to(xExchange).with("XB");
	 }
	 //声明死信队列 QD
	 @Bean("queueD")
	 public Queue queueD(){
		 return new Queue(DEAD_LETTER_QUEUE);
	 }
	 //声明死信队列 QD 绑定关系
	 @Bean
	 public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
	 @Qualifier("yExchange") DirectExchange yExchange){
		 return BindingBuilder.bind(queueD).to(yExchange).with("YD");
	 }
}

队列设置TTL和消息设置TTL的对比

• 队列:如果这样使用的话，岂不是每增加一个新的时间需求，就要新增一个队列，这里只有 10S 和 40S两个时间选项，如果需要一个小时后处理，那么就需要增加 TTL 为一个小时的队列
• 消息:RabbitMQ 只会检查第一个消息是否过期，如果过期则丢到死信队列，如果第一个消息的延时时长很长，而第二个消息的延时时长很短，第二个消息并不会优先得到执行。

延时队列插件

如果不能实现在消息粒度上的 TTL，并使其在设置的 TTL 时间
及时死亡，就无法设计成一个通用的延时队列。那如何解决呢，接下来我们就去解决该问题。

安装

1. 在官网上下载 https://www.rabbitmq.com/community-plugins.htm，下载rabbitmq_delayed_message_exchange 插件，然后解压放置到 RabbitMQ 的插件目录。
2. 进入 RabbitMQ 的安装目录下的 plgins 目录，执行下面命令让该插件生效，然后重启 RabbitMQ
   /usr/lib/rabbitmq/lib/rabbitmq_server-3.8.8/plugins
   rabbitmq-plugins enable rabbitmq_delayed_message_exchange
   

实现

代码架构图:

@Configuration
public class DelayedQueueConfig {
	 public static final String DELAYED_QUEUE_NAME = "delayed.queue";
	 public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
	 public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
	 @Bean
	 public Queue delayedQueue() {
		 return new Queue(DELAYED_QUEUE_NAME);
	 }
	 //自定义交换机 我们在这里定义的是一个延迟交换机
	 @Bean
	 public CustomExchange delayedExchange() {
		 Map<String, Object> args = new HashMap<>();
		 //自定义交换机的类型
		 args.put("x-delayed-type", "direct");
		 return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false,
		args);
	 }
	 @Bean
	 public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue,
	 @Qualifier("delayedExchange") CustomExchange
	delayedExchange) {
	     return	BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
	 }
}

消息生产者:

public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
@GetMapping("sendDelayMsg/{message}/{delayTime}")
public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime) {
	 rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message,
	correlationData ->{
	     correlationData.getMessageProperties().setDelay(delayTime);
		 return correlationData;
 	});
	 log.info(" 当 前 时 间 ： {}, 发送一条延迟 {} 毫秒的信息给队列 delayed.queue:{}", new Date(),delayTime, message);
}