RabbitMq——死信队列

死信：由于某些原因导致队列中的消息无法被消费者消费，消息就会成为死信。

死信来源：消息ttl过期、消息被拒绝·，队列已达最大长度。

死信队列：为保护系统订单业务数据不丢失，当消息成为死信时，会将消息保存到死信队列中。

其架构图如下：

 

案例：一个生产者发送10条消息，消息5被拒收，进入死信队列，其他消息正常消费：

1、创建连接获取信道工具类，同时关闭linux防火墙和开启rabbitmq服务

//连接工厂，创建信道工具类
public class RabbitUtils {
    // 得到一个连接的 channel
    public static Channel getChannel() throws Exception {
        // 创建一个连接工厂
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("192.168.23.129");
        factory.setUsername("user");
        factory.setPassword("123");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
        return channel;
    }
}

2、生产者发送消息，声明交换机为direct交换机，发送10条消息

public class Producer {
    public static final String NORMAL_EXCHANGE="normal_exchange";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitUtils.getChannel();
        //声明交换机
        channel.exchangeDeclare(NORMAL_EXCHANGE,"direct");

        //发送10条消息
        for (int i = 0; i < 10; i++) {
            String message="消息"+i;
            channel.basicPublish(NORMAL_EXCHANGE,"normal",null,message.getBytes());
            System.out.println("生产者发送消息："+message);
        }
    }
}

3、普通队列消费者

        （1）获得连接，声明死信交换机，死信队列；

        （2）声明普通队列，设置普通队列消息被拒收后，由哪个死信交换机接收，以及该交换机与死信队列绑定的路由；

        （3）绑定死信队列与死信交换机，普通队列与普通交换机；

        （4）接收消息回调函数，调用basicReject（消息标记，是否放回队列）方法拒绝接收：消息5，其他正常接收消息则调用basicAck（消息标记，是否放回队列）方法手动应答；

        （5）调用basicConsume（队列名，是否自动应答，成功回调函数，失败回调函数）方法接收消息，一定要关闭自动应答。

public class Consumer1 {

    //普通交换机
    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";

    public static void main(String[] args) throws Exception {
        //连接获得信道
        Channel channel = RabbitUtils.getChannel();
        //声明死信交换机
        channel.exchangeDeclare(DEAD_EXCHANGE,"direct");
        //声明死信队列
        channel.queueDeclare(DEAD_QUEUE,false,false,false,null);

        //声明普通对列
        Map<String,Object> argument=new HashMap<>();
        //设置普通队列消息过期后死信队列是谁
        argument.put("x-dead-letter-exchange",DEAD_EXCHANGE);
        //设置死信路由
        argument.put("x-dead-letter-routing-key","dead");
        channel.queueDeclare(NORMAL_QUEUE,false,false,false,argument);

       
        //绑定交换机与队列
        channel.queueBind(NORMAL_QUEUE,NORMAL_EXCHANGE,"normal");
        channel.queueBind(DEAD_QUEUE,DEAD_EXCHANGE,"dead");

        DeliverCallback deliverCallback=(delivery,message)->{
            String msg=new String(message.getBody());
            //拒绝消息5
            if (msg.equals("消息5")){
                System.out.println("consumer1拒绝接收消息"+msg);
                //false表示不被放回普通队列
                channel.basicReject(message.getEnvelope().getDeliveryTag(),false);
            }else {
                System.out.println("consumer1接收消息："+new String(message.getBody()));
                //消息应答
                channel.basicAck(message.getEnvelope().getDeliveryTag(),false);
            }
        };

        //参数二关闭自动应答
        channel.basicConsume(NORMAL_QUEUE,false,deliverCallback,consumerTag->{});
    }

}

4、死信消费者，创建信道，成功接收消息回调，调用basicConsume（）接收消息

public class Consumer2 {
    //死信队列
    private static final String DEAD_QUEUE="dead_queue";

    public static void main(String[] args) throws Exception {
        Channel channel = RabbitUtils.getChannel();



        System.out.println("等待接受消息.......");

        //声明,接受消息
        DeliverCallback deliverCallback=(consumerTag, message)->{
            System.out.println("Consumer2接收消息："+new String(message.getBody(),"UTF-8"));
        };

        channel.basicConsume(DEAD_QUEUE,true,deliverCallback,cancelCallback->{});

    }
}

5、测试

 消息5被普通队列拒收，成为死信消息，放入死信队列，给消费者consumer2消费