RabbitMQ设置TTL（Time To Live)过期消息

消息的过期时间有两种设置方式：

1通过队列属性设置消息过期时间；

 //TTL队列 (queue的扩展参数)
            Map<String, Object> arguments = new HashMap<String, Object>();
            arguments.put("x-message-ttl", 6000); //6秒消息过期
//队列的过期时间决定了在没有任何消费者以后，队列可以存活多久；

从这里可以看到队列属性

1.添加依赖

 <dependency>
            <groupId>com.rabbitmq</groupId>
            <artifactId>amqp-client</artifactId>
            <version>5.7.3</version>
        </dependency>

        <dependency>
            <groupId>org.springframework.amqp</groupId>
            <artifactId>spring-rabbit</artifactId>
            <version>2.2.0.RELEASE</version>
        </dependency>

代码:

public class TTLSender {

    //交换机名字
    private final static String EXCHANGE_NAME = "ttlExchange";
    //路由key名字
    private final static String ROUTINGKEY_NAME = "ttlRoutingKey";
    //队列名字
    private final static String QUEUE_NAME = "ttlQueue";

    public static void main(String[] args) throws TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接ip
        factory.setHost("192.168.6.128");
        //设置连接端口
        factory.setPort(5672);
        //设置用户名
        factory.setUsername("admin");
        //设置密码
        factory.setPassword("admin");
        //设置虚拟主机Virtual Host
        factory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //创建一个连接
            connection = factory.newConnection();

            //创建一个消息通道
            channel = connection.createChannel();

            //声明一个交换机（exchange：DirectExchange 直连交换机，精确匹配）
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

            //TTL队列 (queue的扩展参数)
            Map<String, Object> arguments = new HashMap<String, Object>();
            arguments.put("x-message-ttl", 6000); //6秒消息过期

            //声明一个队列（队列是用来存放exchange路由过来的消息）
            //String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
            channel.queueDeclare(QUEUE_NAME, true, false, false, arguments);

            //将队列和交换机绑定（建立起关系，交换机 + 队列 通过路由键绑定起来）
            //String queue, String exchange, String routingKey
            channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTINGKEY_NAME);

            //要发送的消息
            String message = "Hello RabbitMQ! The Direct Exchange Message.";

            //发送消息（也就是发送数据到RabbitMQ）
            //String exchange, String routingKey, BasicProperties props, byte[] body
            channel.basicPublish(EXCHANGE_NAME, ROUTINGKEY_NAME, null, message.getBytes("UTF-8"));

            System.out.println("消息发送完毕-->" + message);

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            //资源释放与关闭
            if (channel != null) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

2.设置单条消息的过期时间

AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                    .deliveryMode(2) //持久化消息
                    .contentEncoding("UTF-8") //消息编码
                    .expiration("10000") //TTL消息，10秒过期
                    .build();
                    // 单条消息的过期时间决定了在没有任何消费者消费时，消息可以存活多久；

public class TTLSender2 {

    //交换机名字
    private final static String EXCHANGE_NAME = "ttlExchange2";
    //路由key名字
    private final static String ROUTINGKEY_NAME = "ttlRoutingKey2";
    //队列名字
    private final static String QUEUE_NAME = "ttlQueue2";

    public static void main(String[] args) throws TimeoutException {
        //创建连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        //设置连接ip
        factory.setHost("192.168.6.128");
        //设置连接端口
        factory.setPort(5672);
        //设置用户名
        factory.setUsername("admin");
        //设置密码
        factory.setPassword("admin");
        //设置虚拟主机Virtual Host
        factory.setVirtualHost("/");

        Connection connection = null;
        Channel channel = null;
        try {
            //创建一个连接
            connection = factory.newConnection();

            //创建一个消息通道
            channel = connection.createChannel();

            //声明一个交换机（exchange：DirectExchange 直连交换机，精确匹配）
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

            //声明一个队列（队列是用来存放exchange路由过来的消息）
            //String queue, boolean durable, boolean exclusive, boolean autoDelete, Map<String, Object> arguments
            channel.queueDeclare(QUEUE_NAME, true, false, false, null);

            //将队列和交换机绑定（建立起关系，交换机 + 队列 通绑定起来）
            //String queue, String exchange, String routingKey
            channel.queueBind(QUEUE_NAME, EXCHANGE_NAME, ROUTINGKEY_NAME);

            //要发送的消息
            String message = "Hello RabbitMQ! The Direct Exchange Message.";

            //给消息单独设置属性，链式编程（构建器模式，也是一种设计模式）
            AMQP.BasicProperties properties = new AMQP.BasicProperties.Builder()
                    .deliveryMode(2) //持久化消息
                    .contentEncoding("UTF-8") //消息编码
                    .expiration("10000") //TTL消息，10秒过期
                    .build();

            //发送消息（也就是发送数据到RabbitMQ）
            //String exchange, String routingKey, BasicProperties props, byte[] body
            channel.basicPublish(EXCHANGE_NAME, ROUTINGKEY_NAME, properties, message.getBytes("UTF-8"));

            System.out.println("消息发送完毕-->" + message);

        } catch (UnsupportedEncodingException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        } finally {
            //资源释放与关闭
            if (channel != null) {
                try {
                    channel.close();
                } catch (IOException e) {
                    e.printStackTrace();
                } catch (TimeoutException e) {
                    e.printStackTrace();
                }
            }
            if (connection != null) {
                try {
                    connection.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }
}

3.队列配置参数

1.x-message-ttl：Number
1个发布的消息在队列中存在多长时间后被取消（单位毫秒）；

2.x-expires：Number
当Queue（队列）在指定的时间未被访问，则队列将被自动删除；

3.x-max-length：Number
队列所能容下消息的最大长度。当超出长度后，新消息将会覆盖最前面的消息，类似于Redis的LRU算法；

4.x-max-length-bytes：Number
限定队列的最大占用空间，当超出后也使用类似于Redis的LRU算法；

5.x-overflow：String
设置队列溢出行为。这决定了当达到队列的最大长度时，消息会发生什么，有效值为Drop Head或Reject Publish；

6.x-dead-letter-exchange：String
有时候我们希望当队列的消息达到上限后溢出的消息不会被删除掉，而是走到另一个队列中保存起来；

7.x-dead-letter-routing-key：String
如果不定义，则默认为溢出队列的routing-key，因此，一般和6一起定义；

8.x-max-priority：Number
如果将一个队列加上优先级参数，那么该队列为优先级队列；
1）、给队列加上优先级参数使其成为优先级队列
x-max-priority=10【0-255取值范围】
2）、给消息加上优先级属性
通过优先级特性，将一个队列实现插队消费；

9.x-queue-mode：String
队列类型x-queue-mode=lazy懒队列，在磁盘上尽可能多地保留消息以减少RAM使用，如果未设置，则队列将保留内存缓存以尽可能快地传递消息；

10.x-queue-master-locator：String
将队列设置为主位置模式，确定在节点集群上声明时队列主位置所依据的规则；