RabbitMQ4/7--RabbitMQTTL，死信队列

(一)RabbitMQ TTL

过期时间 TTl表示可以对消息设置预期的时间，在这个时间内都可以被消费者接收获取；过了之后消息将自动被删除。RabbitMQ可以对消息和队列设置 TTL，目前有两种方法可以设置

• 第一种方法是通过队列属性设置，队列中所有消息都有相同的过期时间
• 第二种方法是对消息进行单独设置，每条消息 TTL可以不同

如果上述两种方法同时使用，则消息的过期时间以两者 TTL较小的那个数值为准。消息在队列的生存时间一旦超过设置的 TTL值，就称为 dead message被投递到死信队列，消费者将无法再收到该消息

设置队列TTL

生产者

service

//---------------------------TTL队列过期时间-----------------------------------
//模拟用户下单
public void makeOrderDirectTtl(String userid,String productid,int num){
    //1.根据商品id查询库存是否足够
    //2.保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生产成功："+orderId);
    //3.通过MQ来完成消息的分发
    //参数1：交换机 参数2：路由key/queue队列名称 参数3：消息内容
    String exchangeName = "ttl_direct_exchange";
    String routingKey = "ttl";
    rabbitTemplate.convertAndSend(exchangeName,routingKey,orderId);
}

config配置类

package com.yhd.rabbitmq.config;

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 java.util.HashMap;
import java.util.Map;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/21 8:40
 */
@Configuration
public class TTLRabbitMQConfiguration {
    //1.声明注册direct模式的交换机
    @Bean
    public DirectExchange ttlDirectExchange(){
        return new DirectExchange("ttl_direct_exchange",true,false);
    }
    //2.声明队列
    @Bean
    public Queue ttlDirectSmsQueue(){
        //设置过期时间
        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("x-message-ttl",5000);
        //参数1：队列名称 参数2：持久化 参数3：排他性 参数4：自动删除 参数5：队列过期信息
        return new Queue("ttl.direct.queue",true,false,false,hashMap);
    }

    //3.完成绑定关系
    @Bean
    public Binding ttlSmsBingding(){
        return BindingBuilder.bind(ttlDirectSmsQueue()).to(ttlDirectExchange()).with("ttl");
    }

}

设置队列过期时间的参数来源

运行结果

时间到期后，队列中的信息将全部删除

总结

1.队列的过期时间，是在配置类中进行设置
2.使用queue的方法重载进行参数追加

对每一条单独消息设置过期时间

生产者

service

//--------------------------TTL单条消息过期时间-------------------------------------------------
//模拟用户下单
public void makeOrderDirectTtlMessage(String userid,String productid,int num){
    //1.根据商品id查询库存是否足够
    //2.保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生产成功："+orderId);
    //3.通过MQ来完成消息的分发
    //参数1：交换机 参数2：路由key/queue队列名称 参数3：消息内容
    String exchangeName = "ttl_order_exchange";
    String routingKey = "ttlmessage";

    //设置消息过期时间
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
        @Override
        public Message postProcessMessage(Message message) throws AmqpException {
            //设置时间
           message.getMessageProperties().setExpiration("5000");
           //设置编码
           message.getMessageProperties().setContentEncoding("UTF-8");
           return message;
        }
    };
    rabbitTemplate.convertAndSend(exchangeName,routingKey,orderId,messagePostProcessor);
}

config配置类

package com.yhd.rabbitmq.config;

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 java.util.HashMap;
import java.util.Map;

/**
 * @author 袁浩东
 * @description
 * @date 2021/7/21 9:27
 */
@Configuration
public class TTLMessageRabbitMQConfiguration {
    //1.声明注册direct模式的交换机
    @Bean
    public DirectExchange ttMessageDirectExchange(){
        return new DirectExchange("ttl_order_exchange",true,false);
    }

    //2.声明消息过期时间
    @Bean
    public Queue ttlDirectMessageSmsQueue(){
        //参数1：队列名称 参数2：持久化
        return new Queue("ttl.message.order.queue",true);
    }

    //3、完成绑定关系
    @Bean
    public Binding ttlMessageSmsBingding(){
        return BindingBuilder.bind(ttlDirectMessageSmsQueue()).to(ttMessageDirectExchange()).with("ttlmessage");
    }
}

测试类

@Test
void testorderTopicTtlMessage() {
    orderService.makeOrderDirectTtlMessage("1","1",12);
}

运行结果

过期后自动删除

总结

1.单条 消息过期时间的设置，主要在生产者的service发消息的时候进行设置
2.方法重载，参数追加

• 单条消息的过期时间，当过期后就自动删除了
• 队列的过期时间，可以把过期队列放到死信队列中

---

（二）RabbitMQ死信队列

死信队列概念

DLX，全称 Dead-Letter-Exchange，可以称之为死信交换机，也有人称之为死信邮箱。当消息再一个队列中变成死信之后，它能被重新发送到另一个交换机中，这个交换机就是
DLX，绑定 DLX的队列就称之为死信队列。

消息变成死信，可能是由于以下原因

• 消息被拒绝
• 消息过期
• 队列达到最大长度

DLX也是一个正常的交换机，和一般的交换机没有区别，它能在任何的队列上被指定，实际上就是设置某一个队列的属性，当这个队列中存在死信时，Rabbitmq就会自动地将这个消息重新发布到设置的
DLX上去，进而被路由到另一个队列，即死信队列。

要想使用死信队列，只需要在定义队列的时候设置队列参数x-dead-letter-exchange指定交换机即可

死信队列代码架构

代码演示

死信队列，就是一个接盘侠，当TTL队列过期后，会将消息转移到死信队列中，死信队列，就是一个普通的队列

死信队列配置类

package com.yhd.rabbitmq.config;

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 java.util.HashMap;
import java.util.Map;

/**
 * @author 袁浩东
 * @description   死信队列（接盘）
 * @date 2021/7/21 10:12
 */
@Configuration
public class DealRabbitMQConfiguration {
    //1.声明注册direct模式的交换机
    @Bean
    public DirectExchange deadDirect1(){
        return new DirectExchange("dead_direct_exchange",true,false);}
    //2.声明队列
    @Bean
    public Queue deadQueue1(){
        return new Queue("dead.direct.queue",true);}
    @Bean
    public Binding deadbinds(){
        return BindingBuilder.bind(deadQueue1()).to(deadDirect1()).with("dead");
    }
}

生产者

service消息生成

//----------------------------------死信队列----------------------------------------------------
//模拟用户下单
public void makeOrDead(String userid,String productid,int num){
    //1.根据商品id查询库存是否足够
    //2.保存订单
    String orderId = UUID.randomUUID().toString();
    System.out.println("订单生产成功："+orderId);
    //3.通过MQ来完成消息的分发
    //参数1：交换机 参数2：路由key/queue队列名称 参数3：消息内容
    String exchangeName = "ttl_dead_exchange";
    String routingKey = "ttldead";
    rabbitTemplate.convertAndSend(exchangeName,routingKey,orderId);
}

config配置类

package com.yhd.rabbitmq.config;

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 java.util.HashMap;
import java.util.Map;

/**
 * @author 袁浩东
 * @description  过期队列与死信队列的绑定
 * @date 2021/7/21 10:24
 */
@Configuration
public class TTLDeadRabbitMQConfiguration {
    //1.声明注册direct模式的交换机
    @Bean
    public DirectExchange ttlDeadExchange(){
        return new DirectExchange("ttl_dead_exchange",true,false);
    }
    //2.声明队列
    @Bean
    public Queue ttlDeadQueue2(){
        //设置过期时间
        Map<String, Object> hashMap = new HashMap<>();
        hashMap.put("x-max-length",5);//队列长度
        hashMap.put("x-message-ttl",5000);//队列过期时间
        hashMap.put("x-dead-letter-exchange","dead_direct_exchange");//死信队列交换机绑定
        hashMap.put("x-dead-letter-routing-key","dead");//死信队列的luyoukey信息，fanout不需要配置
        //参数1：队列名称 参数2：持久化 参数3：排他性 参数4：自动删除 参数5：队列过期信息
        return new Queue("ttl.direct.queue1",true,false,false,hashMap);
    }

    //3.完成绑定关系
    @Bean
    public Binding ttlSmsBingding11(){
        return BindingBuilder.bind(ttlDeadQueue2()).to(ttlDeadExchange()).with("ttldead");
    }
}

测试类

@Test
void testTtlDead() {
    for (int i = 0; i < 10; i++) {
        orderService.makeOrDead("1","1",12);
    }
}

运行结果

队列中的消息过期后会转移到私信队列中

流程分析

1.创建一个死信队列，用于接盘过期的消息队列

2.普通队列中设置过期时间

3.普通队列与需要绑定的死信队列的交换机名称

4.绑定路由key（如果是direct模式）

总结

队列中设置死信队列的参数来源

x-dead-letter-exchange

x-dead-letter-routing-key