RabbitMQ学习09--死信队列(TTL过期)

1、死信的概念：

死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer 将消息投递到 broker 或者直接到queue 里了，consumer 从 queue 取出消息进行消费，但某些时候由于特定的原因导致 queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。

应用场景:为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中.还有比如说:用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。

 

2、死信的来源：

消息 TTL 过期

队列达到最大长度(队列满了，无法再添加数据到 mq 中)

消息被拒绝(basic.reject 或 basic.nack)并且 requeue=false.

 

3、代码示例：

 

 

工厂类：

package com.yas.config;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

public class RabbitMQClient {
    public static Connection getConnection(){
        //创建Connection工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("106.12.17.17");
        factory.setPort(5672);
        factory.setUsername("admin");
        factory.setPassword("cs1986@0312");
        factory.setVirtualHost("/");

        //创建Connection
        Connection connection = null;
        try {
            connection = factory.newConnection();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (TimeoutException e) {
            e.printStackTrace();
        }
        return connection;
    }

    public static Channel getChannel(){
        Connection connection = getConnection();
        try {
            return connection.createChannel();
        } catch (IOException e) {
            e.printStackTrace();
        }
        return null;
    }
}

 

消息生产者代码：

package com.yas.deadexchange;

import com.rabbitmq.client.AMQP;
import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

public class Publisher {
    private static final String NORMAL_EXCHANGE = "normal_exchange";

    @Test
    public void publish() throws Exception {
        try (Channel channel = RabbitMQClient.getChannel()) {
            channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
            //设置消息的 TTL 时间
            AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("10000").build();
            //该信息是用作演示队列个数限制
            for (int i = 1; i <11 ; i++) {
                String message="info"+i;
                //channel.basicPublish(NORMAL_EXCHANGE, message.getBytes());
                channel.basicPublish(NORMAL_EXCHANGE,"zhangsan",properties,message.getBytes());
                System.out.println("生产者发送消息:"+message);
            }
        }
    }
}

 

正常队列(normal_queue)消费者：

package com.yas.deadexchange;

import com.rabbitmq.client.*;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

import java.util.HashMap;
import java.util.Map;

public class Consumer01 {
    public static final String NORMAL_EXCHANGE = "normal_exchange";
    public static final String DEAD_EXCHANGE = "dead_exchange";
    public static final String NORMAL_QUEUE = "normal_queue";
    public static final String DEAD_QUEUE = "dead_queue";

    @Test
    public void consume() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();

        //声明死信交换机 类型为 direct
        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE, false, false, false, null);
        //死信队列绑定死信交换机与 routingkey
        channel.queueBind(DEAD_QUEUE, DEAD_EXCHANGE, "lisi");


        //声明普通交换机 类型为 direct
        channel.exchangeDeclare(NORMAL_EXCHANGE, BuiltinExchangeType.DIRECT);
        //正常队列绑定死信队列信息
        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");
        //声明普通队列
        channel.queueDeclare(NORMAL_QUEUE, false, false, false, params);
        //普通队列绑定普通交换机routing-key
        channel.queueBind(NORMAL_QUEUE, NORMAL_EXCHANGE, "zhangsan");
        System.out.println("等待接收消息........... ");

        //消费者回调
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer01 接收到消息"+message);
            };
        channel.basicConsume(NORMAL_QUEUE, true, deliverCallback, consumerTag -> {
        });

        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

测试方式：

1.正常消费，先执行消费者，开启消费监听。再开启生产者，则消息从normal_queue被消费。

2.死信队列，不开启消费者，只开启生产者，消息先发送到normal_queue，等10秒超时后，会从normal_queue转发给dead_queue。消息进入死信队列。

 

死信队列消费者：

package com.yas.deadexchange;

import com.rabbitmq.client.BuiltinExchangeType;
import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.DeliverCallback;
import com.yas.config.RabbitMQClient;
import org.junit.Test;

//消费死信队列中的消息
public class Consumer02 {

    private static final String DEAD_EXCHANGE = "dead_exchange";

    @Test
    public void consume() throws Exception {
        //1.获取连接对象
        Connection connection = RabbitMQClient.getConnection();
        //2.创建channel
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(DEAD_EXCHANGE, BuiltinExchangeType.DIRECT);
        String deadQueue = "dead_queue";
        channel.queueDeclare(deadQueue, false, false, false, null);
        channel.queueBind(deadQueue, DEAD_EXCHANGE, "lisi");
        System.out.println("等待接收死信队列消息........... ");
        DeliverCallback deliverCallback = (consumerTag, delivery) ->
        {String message = new String(delivery.getBody(), "UTF-8");
            System.out.println("Consumer02 接收死信队列的消息" + message);
        };
        channel.basicConsume(deadQueue, true, deliverCallback, consumerTag -> {
        });

        System.in.read();
        //5/释放资源
        channel.close();
        connection.close();
    }
}

测试方式：

对于进入死信队列的信息，可以通过启动私信队列的消费者完成消费。