TTL是Time To Live的缩写，也就是生存时间。

RabbitMQ支持消息的过期时间，在消息发送时可以进行指定。

RabbitMQ支持队列的过期时间，从消息入队列开始计算，只要超过了队列的超时时间配置，那么消息会自动的清除。

队列属性：x-message-ttl

可以控制被publish到queue中的message 被丢弃前能够存活的时间

//Java代码：message在该queue的存过时间最大为60秒

Map<String, Object> args = new HashMap<String, Object>();

args.put("x-message-ttl", 60000);

channel.queueDeclare("myqueue", false, false, false, args);

1.DLX也是一个正常的Exchange,和一般的Exchange没有区别，它能在任何队列上被指定，实际上就是设置某个队列的属性

2.当这个队列中有死信时，RabbitMQ就会自动将这个消息重新发布到设置的Exchange上去，进而被路由到另一个队列

3.可以监听这个队列的消息做相应的处理，这个特性可以弥补RabbitMQ3.0以前支持的immediate参数的功能。

package com.dwz.rabbitmq.dlx;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeoutException;

import com.dwz.rabbitmq.util.ConnectionUtils;

import com.rabbitmq.client.AMQP;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

public class Producer {

    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

        String exchangeName = "test_dlx_exchange";

        String routingkey = "dlx.save";

        for(int i = 0; i < 1; i++) {

            String msg = "Hello rabbitmq dlc-"+i+" message!";

            Map<String, Object> headers = new HashMap<>();

            headers.put("num", i);

            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder()

                    .deliveryMode(2)

                    .contentEncoding("utf-8")

                    .expiration("10000")

                    .headers(headers)

                    .build();

            channel.basicPublish(exchangeName, routingkey, properties, msg.getBytes());

        }

        channel.close();

        connection.close();

    }

}

package com.dwz.rabbitmq.dlx;

import java.io.IOException;

import java.util.HashMap;

import java.util.Map;

import java.util.concurrent.TimeoutException;

import com.dwz.rabbitmq.util.ConnectionUtils;

import com.rabbitmq.client.Channel;

import com.rabbitmq.client.Connection;

import com.rabbitmq.client.DefaultConsumer;

import com.rabbitmq.client.Envelope;

import com.rabbitmq.client.AMQP.BasicProperties;

public class Consumer {

    public static void main(String[] args) throws IOException, TimeoutException {

        Connection connection = ConnectionUtils.getConnection();

        Channel channel = connection.createChannel();

        String exchangeName = "test_dlx_exchange";

        String routingkey = "dlx.#";

        String queueName = "test_dlx_queue";

        //这是一个普通的交换机、队列和路由

        channel.exchangeDeclare(exchangeName, "topic", true, false, null);

        Map<String, Object> arguments = new HashMap<>();

        arguments.put("x-dead-letter-exchange", "dlx.exchange");

        channel.queueDeclare(queueName, true, false, false, arguments);

        channel.queueBind(queueName, exchangeName, routingkey);

        channel.exchangeDeclare("dlx.exchange", "topic", true, false, null);

        channel.queueDeclare("dlx.queue", true, false, false, null);

        channel.queueBind("dlx.queue", "dlx.exchange", "#");

        DefaultConsumer consumer = new DefaultConsumer(channel) {

            @Override

            public void handleDelivery(String consumerTag, Envelope envelope, BasicProperties properties, byte[] body)

                    throws IOException {

                super.handleDelivery(consumerTag, envelope, properties, body);

                try {

                    Thread.sleep(2000);

                } catch (InterruptedException e) {

                    e.printStackTrace();

                }

                System.out.println("消费端：" + new String(body));

                channel.basicAck(envelope.getDeliveryTag(), false);

            }

        };

        //手工签收必须关闭autoAck设置为false

        channel.basicConsume(queueName, false, consumer);

    }

}