RabbitMQ初步到精通-第六章-RabbitMQ之死信队列

已于 2022-11-19 22:00:39 修改
阅读量1.2k 收藏 2
点赞数
分类专栏： RabbitMQ 文章标签： java-rabbitmq rabbitmq java spring
于 2022-11-19 21:58:46 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/blucastle/article/details/127941119
版权

目录

第六章-RabbitMQ之死信队列

1. 死信概念

2. 死信架构

3. 死信来源

3.1 消息 TTL 过期

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

3.3 消息被拒绝（basic.reject 或 basic.nack）并且 requeue=false（不再重新入队）

4. 验证代码

4.1 TTL

4.2 超过Length

4.3 拒绝

5. 总结

第六章-RabbitMQ之死信队列

1. 死信概念

未了解死信这块的内容的时候，经常听到别人提及 ‘死信’ - What? 信息死了？ 按字面意思去看就是一个信息由于某些原因导致无法正常消费，造成了这个信息死亡的结果，造成的原因我们再单说。

死信- Dead Letter . 由于消息未正常消费，导致了消息的再次转移或被丢弃-成为死信。本文中涉及到的内容，是消息从原正常消费队列中又重定向路由到了另外一个预留的队列-死信队列。

应用场景：我们应用最多的应该是在消息防丢处理中使用，消费者消费的时候，出现了异常，我们可以使用死信队列的机制，将此条信息转移到一个预留的队列中，再有对应的消费者去处理这部分数据内容。-还是模糊-继续往下-

2. 死信架构

如上图所示，我们可以看出 黄色的部分内容 为 正常业务的交换机 Exchange，以及正常业务的对列1 Queue， 而绿色的部分为 另外一套 交换机与队列，他们的创建与正常的类型无异，姑且我们称他们为 死信交换机及死信队列2. 那现在我们就有两套交换机与队列。

那最核心的内容是需要将死信交换机与正常业务的队列1做好绑定关系，这样就能实现当正常队列1无法消费或其他原因时，将消息重定向至死信的交换机中去，死信的交换机再将消息路由至队列2中。

总结一下：生产者生产了一条消息，将消息推送到Broker 中的 正常交换机Exchange，交换机将消息路由至队列1 ，这时由于队列1中的消息未能正常消费，过期了，导致队列1又将消息投递到了死信交换机中，死信交换机再将消息路由到队列2，从而是的消费者2正常消费到了队列2中的死信消息。

3. 死信来源

上文也提到了，消息过期了，导致消息未正常消费，那我们在这里总结一下所有死信的来源

3.1 消息 TTL 过期

TTL意思是 Time to live , 即消息的存活时间，那时间到期了，消息也就达到了他的生命的尽头成为了死信。那如何设置TTL呢？

3.1.1 设置消息的TTL

发送消息的时候设置属性，可以每条消息设置不同的ttl

AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("1000").build();

3.1.2 设置队列的TTL

声明消息队列的时候，这个是全局的，所有发到这个队列的消息的过期时间是一样的

deadLetterParams.put("x-message-ttl", 1000);

队列设置好TTL，则面板中会提示：

 假如你两种都设置了，以小的ttl为准

那这两者设置有啥区别呢？

区别：queue的全局ttl，消息过期立刻就会被删掉；如果是发送消息时设置的ttl，过期之后并不会立刻删掉，这时候消息是否过期是需要投递给消费者的时候判断的。【这个可以做个小实验-投递两条消息，第一条设置过期时间10s，第二条1s, 投递完成，都不进行消费理论第二条应该先过期，但由于第一条没消费，第二条也不会过期】

原因：queue的全局ttl，队列的有效期都一样，先入队列的队列头部，头部也是最早过期的消息，rabbitmq会有一个定时任务从队列的头部开始扫描是否有过期消息即可。而每条设置不同的ttl，只有遍历整个队列才可以筛选出来过期的消息，这样的效率实在是太低，而且如果消息量大了根本不可行，所以rabbitmq在等到消息投递给消费者的时候判断当前消息是否过期，虽然删除的不及时但是不影响功能。
 

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

队列设置最大长度及存储

Map<String, Object> args = new HashMap<String, Object>();
args.put("x-max-length",10);/∥设置queue的最大长度10
args.put("x-max-length-bytes",1024);//设置最大总字节数1KB
channel.queueDeclare("myqueue", false, false, false, args);

面板展示：

当消息超限会被丢弃或转向至死信队列中。

3.3 消息被拒绝（basic.reject 或 basic.nack）并且 requeue=false（不再重新入队）

消息拒绝方式：这两者的区别是 basic.nack 多一个参数，boolean multiple 支持批量拒绝。其余一致。

channel.basicReject(envelope.getDeliveryTag(), false);
channel.basicNack(envelope.getDeliveryTag(), false, false);

4. 验证代码

4.1 TTL

生产者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 死信队列-
 * 当消息在一个队列中变为死信后，它被重新发送到另一个Exchange。
 * @createTime 2022/07/27 19:34:00
 */
public class DeadLetterTTLProducer {

    private static String NORMAL_EXCHANGE_NAME = "normal_exchange_ttl";

    //生产者
    public static void main(String[] args) throws Exception {
        //1、获取connection
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        for (int i = 0; i < 5; i++) {
            sendMsg(channel);
        }
        //4、关闭管道和连接
        channel.close();
        connection.close();
    }

    private static void sendMsg(Channel channel) throws IOException, InterruptedException {
        // 1. 设置消息 TTL 过期时间
        // 2. 设置 队列 TTL 过期时间
        AMQP.BasicProperties properties = new AMQP.BasicProperties().builder().expiration("1000").build();
        String message = "info";
        channel.basicPublish(NORMAL_EXCHANGE_NAME, "normal-key", properties, message.getBytes());
        System.out.println("消息发送完成：" + message);
    }

}

消费者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 正常队列消费者，除了正常的消费者 需要创建 队列、交换机，绑定关系外，
 * 还需要创建 死信的队列、交换机、绑定关系。
 * 最核心的一点还有，需要将 死信队列的交换机信息做为一个参数，绑定到正常的队列中去。
 * @createTime 2022/11/17 16:53:00
 */
public class DeadLetterTTLConsumer_Normal {

    private static String NORMAL_EXCHANGE_NAME = "normal_exchange_ttl";
    private static String NORMAL_QUEUE_NAME = "normal_queue_ttl";
    private static String DEAD_EXCHANGE_NAME = "dead_exchange";
    private static String DEAD_QUEUE_NAME = "dead-queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、获取连对象、
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        //3. 创建死信队列与交换机及绑定关系
        handleQueueAndBinding(channel, DEAD_QUEUE_NAME, null, DEAD_EXCHANGE_NAME, "dead-letter-key");

        // 正常队列与死信交换机的绑定关系
        Map<String, Object> deadLetterParams = getNormalAndDeadParams();

        // 4.声明一个正常队列与交换机及绑定关系
        handleQueueAndBinding(channel, NORMAL_QUEUE_NAME, deadLetterParams, NORMAL_EXCHANGE_NAME, "normal-key");

        channel.basicQos(1);

        //5.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Normal消费者接收消息: " + new String(body, "UTF-8"));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };

        channel.basicConsume(NORMAL_QUEUE_NAME, false, consumer);

        System.out.println("Normal消费者启动接收消息......");

        //5、键盘录入，让程序不结束！
        System.in.read();

        //6、释放资源
        channel.close();
        connection.close();

    }

    private static Map<String, Object> getNormalAndDeadParams() {
        Map<String, Object> deadLetterParams = new HashMap<>();
        deadLetterParams.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
        deadLetterParams.put("x-dead-letter-routing-key", "dead-letter-key");
        //队列过期时间限制
        //deadLetterParams.put("x-message-ttl", 1000);
        return deadLetterParams;
    }

    /**
     * 处理队列与绑定关系
     *
     * @param channel
     * @param deadQueueName
     * @param o
     * @param deadExchangeName
     * @param routingKey
     * @throws IOException
     */
    private static void handleQueueAndBinding(Channel channel, String deadQueueName, Map<String, Object> o, String deadExchangeName, String routingKey) throws IOException {
        // 声明一个队列
        channel.queueDeclare(deadQueueName, false, false, false, o);
        // 声明一个交换机
        channel.exchangeDeclare(deadExchangeName, BuiltinExchangeType.DIRECT);
        // 队列与交换机绑定
        channel.queueBind(deadQueueName, deadExchangeName, routingKey);
    }

}

死信消费者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 死信队列消费者
 * 与正常消费者一致 监听自己的队列消息即可
 * @createTime 2022/11/17 16:54:00
 */
public class DeadLetterConsumer_Dead {

    private static String DEAD_QUEUE_NAME = "dead-queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、获取连对象、
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        //3.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("死信消费者接收消息: " + new String(body, "UTF-8"));
            }
        };

        channel.basicConsume(DEAD_QUEUE_NAME, true, consumer);
        System.out.println("死信消费者启动等待消费消息：");
        //5、键盘录入，让程序不结束！
        System.in.read();
        //6、释放资源
        channel.close();
        connection.close();
    }

}

结果：

生产者：

消息发送完成：info
消息发送完成：info
消息发送完成：info
消息发送完成：info
消息发送完成：info

消费者：

Normal消费者启动接收消息......
Normal消费者接收消息: info

死信消费者：

死信消费者启动等待消费消息：
死信消费者接收消息: info
死信消费者接收消息: info
死信消费者接收消息: info
死信消费者接收消息: info

4.2 超过Length

生产者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 普通的生产者
 * @createTime 2022/11/17 16:51:00
 */
public class DeadLetterLengthProducer {

    private static String EXCHANGE_NAME = "normal_exchange";

    public static void main(String[] args) throws IOException {
        //1、获取连对象、
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        //3. 发送消息
        for (int i = 1; i <= 10; i++) {
            String message = "info" + i;
            channel.basicPublish(EXCHANGE_NAME, "normal-key", null, message.getBytes());
            System.out.println("生产者已发送消息：" + message);
        }
        System.out.println("消息发送完成");
    }
}

消费者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 正常队列消费者，除了正常的消费者 需要创建 队列、交换机，绑定关系外，
 * 还需要创建 死信的队列、交换机、绑定关系。
 * 最核心的一点还有，需要将 死信队列的交换机信息做为一个参数，绑定到正常的队列中去。
 * @createTime 2022/11/17 16:53:00
 */
public class DeadLetterLengthConsumer_Normal {

    private static String NORMAL_EXCHANGE_NAME = "normal_exchange";
    private static String NORMAL_QUEUE_NAME = "normal-queue";
    private static String DEAD_EXCHANGE_NAME = "dead_exchange";
    private static String DEAD_QUEUE_NAME = "dead-queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、获取连对象、
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        //3. 创建死信队列与交换机及绑定关系
        handleQueueAndBinding(channel, DEAD_QUEUE_NAME, null, DEAD_EXCHANGE_NAME, "dead-letter-key");

        // 正常队列与死信交换机的绑定关系
        Map<String, Object> deadLetterParams = getNormalAndDeadParams();

        // 4.声明一个正常队列与交换机及绑定关系
        handleQueueAndBinding(channel, NORMAL_QUEUE_NAME, deadLetterParams, NORMAL_EXCHANGE_NAME, "normal-key");

        channel.basicQos(1);

        //5.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("Normal消费者接收消息: " + new String(body, "UTF-8"));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        };

        channel.basicConsume(NORMAL_QUEUE_NAME, false, consumer);

        System.out.println("Normal消费者启动接收消息......");

        //5、键盘录入，让程序不结束！
        System.in.read();

        //6、释放资源
        channel.close();
        connection.close();

    }

    private static Map<String, Object> getNormalAndDeadParams() {
        Map<String, Object> deadLetterParams = new HashMap<>();
        deadLetterParams.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
        deadLetterParams.put("x-dead-letter-routing-key", "dead-letter-key");
        deadLetterParams.put("x-max-length", 6);
        return deadLetterParams;
    }

    /**
     * 处理队列与绑定关系
     *
     * @param channel
     * @param deadQueueName
     * @param o
     * @param deadExchangeName
     * @param routingKey
     * @throws IOException
     */
    private static void handleQueueAndBinding(Channel channel, String deadQueueName, Map<String, Object> o, String deadExchangeName, String routingKey) throws IOException {
        // 声明一个队列
        channel.queueDeclare(deadQueueName, false, false, false, o);
        // 声明一个交换机
        channel.exchangeDeclare(deadExchangeName, BuiltinExchangeType.DIRECT);
        // 队列与交换机绑定
        channel.queueBind(deadQueueName, deadExchangeName, routingKey);
    }

}

死信消费者：同上

结果：

生产者：

生产者已发送消息：info1
生产者已发送消息：info2
生产者已发送消息：info3
生产者已发送消息：info4
生产者已发送消息：info5
生产者已发送消息：info6
生产者已发送消息：info7
生产者已发送消息：info8
生产者已发送消息：info9
生产者已发送消息：info10
消息发送完成

消费者：

Normal消费者启动接收消息......
Normal消费者接收消息: info1
Normal消费者接收消息: info5
Normal消费者接收消息: info6
Normal消费者接收消息: info7
Normal消费者接收消息: info8
Normal消费者接收消息: info9
Normal消费者接收消息: info10

死信消费者：

死信消费者启动等待消费消息：
死信消费者接收消息: info2
死信消费者接收消息: info3
死信消费者接收消息: info4

4.3 拒绝

生产者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 普通的生产者
 * @createTime 2022/11/17 16:51:00
 */
public class DeadLetterRejectProducer {

    private static String EXCHANGE_NAME = "normal_exchange_reject";

    public static void main(String[] args) throws IOException {
        //1、获取连对象、
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        //3. 发送消息
        for (int i = 1; i <= 10; i++) {
            String message = "info" + i;
            channel.basicPublish(EXCHANGE_NAME, "normal-key", null, message.getBytes());
            System.out.println("生产者已发送消息：" + message);
        }
        System.out.println("消息发送完成");
    }
}

消费者：


/**
 * @author rabbit
 * @version 1.0.0
 * @Description 正常队列消费者，除了正常的消费者 需要创建 队列、交换机，绑定关系外，
 * 还需要创建 死信的队列、交换机、绑定关系。
 * 最核心的一点还有，需要将 死信队列的交换机信息做为一个参数，绑定到正常的队列中去。
 * @createTime 2022/11/17 16:53:00
 */
public class DeadLetterRejectConsumer_Normal {

    private static String NORMAL_EXCHANGE_NAME = "normal_exchange_reject";
    private static String NORMAL_QUEUE_NAME = "normal_queue_reject";
    private static String DEAD_EXCHANGE_NAME = "dead_exchange";
    private static String DEAD_QUEUE_NAME = "dead-queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //1、获取连对象、
        Connection connection = RabbitCommonConfig.getConnection();
        //2、创建channel
        Channel channel = connection.createChannel();
        //3. 创建死信队列与交换机及绑定关系
        handleQueueAndBinding(channel, DEAD_QUEUE_NAME, null, DEAD_EXCHANGE_NAME, "dead-letter-key");

        // 正常队列与死信交换机的绑定关系
        Map<String, Object> deadLetterParams = getNormalAndDeadParams();

        // 4.声明一个正常队列与交换机及绑定关系
        handleQueueAndBinding(channel, NORMAL_QUEUE_NAME, deadLetterParams, NORMAL_EXCHANGE_NAME, "normal-key");

        channel.basicQos(1);

        //5.开启监听Queue
        DefaultConsumer consumer = new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                if ("info5".equals(new String(body, "UTF-8"))) {
                    System.out.println("Normal消费者接收消息：" + new String(body, "UTF-8") + "并且拒绝签收了");
                    // 禁止重新入队
                    //channel.basicReject(envelope.getDeliveryTag(), false);
                    channel.basicNack(envelope.getDeliveryTag(), false, false);
                } else {
                    System.out.println("Normal消费者接收消息：" + new String(body, "UTF-8"));
                    channel.basicAck(envelope.getDeliveryTag(), false);
                }
            }
        };

        channel.basicConsume(NORMAL_QUEUE_NAME, false, consumer);

        System.out.println("Normal消费者启动接收消息......");

        //5、键盘录入，让程序不结束！
        System.in.read();

        //6、释放资源
        channel.close();
        connection.close();

    }

    private static Map<String, Object> getNormalAndDeadParams() {
        Map<String, Object> deadLetterParams = new HashMap<>();
        deadLetterParams.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
        deadLetterParams.put("x-dead-letter-routing-key", "dead-letter-key");
        return deadLetterParams;
    }

    /**
     * 处理队列与绑定关系
     *
     * @param channel
     * @param deadQueueName
     * @param o
     * @param deadExchangeName
     * @param routingKey
     * @throws IOException
     */
    private static void handleQueueAndBinding(Channel channel, String deadQueueName, Map<String, Object> o, String deadExchangeName, String routingKey) throws IOException {
        // 声明一个队列
        channel.queueDeclare(deadQueueName, false, false, false, o);
        // 声明一个交换机
        channel.exchangeDeclare(deadExchangeName, BuiltinExchangeType.DIRECT);
        // 队列与交换机绑定
        channel.queueBind(deadQueueName, deadExchangeName, routingKey);
    }

}

死信消费者：同上

结果：

生产者：

生产者已发送消息：info1
生产者已发送消息：info2
生产者已发送消息：info3
生产者已发送消息：info4
生产者已发送消息：info5
生产者已发送消息：info6
生产者已发送消息：info7
生产者已发送消息：info8
生产者已发送消息：info9
生产者已发送消息：info10
消息发送完成

消费者：

Normal消费者启动接收消息......
Normal消费者接收消息：info1
Normal消费者接收消息：info2
Normal消费者接收消息：info3
Normal消费者接收消息：info4
Normal消费者接收消息：info5并且拒绝签收了
Normal消费者接收消息：info6
Normal消费者接收消息：info7
Normal消费者接收消息：info8
Normal消费者接收消息：info9
Normal消费者接收消息：info10


死信消费者：

死信消费者启动等待消费消息：
死信消费者接收消息: info5

5. 总结

其实死信队列没什么神秘的内容，只是：

1. 在原来的基础上增加了一套死信Exchange和死信Queue

2. 与原来的Queue 和死信Exchange做好了绑定关系。

绑定关系依靠参数设置在业务正常queue声明的时候进行传入：

 Map<String, Object> deadLetterParams = new HashMap<>();
 deadLetterParams.put("x-dead-letter-exchange", DEAD_EXCHANGE_NAME);
 deadLetterParams.put("x-dead-letter-routing-key", "dead-letter-key");

channel.queueDeclare(deadQueueName, false, false, false, deadLetterParams );

与业务Queue绑定好关系后，看下面板的体现：

 这里的 DLX - dead-letter-exchange  = 业务中的参数 ："x-dead-letter-exchange" 指向的 死信Exchange

这里的DLK -dead-letter-routing-key" = 业务中的参数："x-dead-letter-routing-key" 指向的是 死信的 路由键

Mr-昊哥
关注
  • 0
    点赞
  • 踩
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ 死信队列详解
dingd1234的博客
05-28 1万+
一、死信的概念 死信，顾名思义就是无法被消费的消息。一般来说，Producer 将消息投递到 Broker 或者直接到 Queue 里了，Consumer 从 Queue 取出消息进行消费，但某些时候由于特定的原因导致 Queue 中的某些消息无法被消费，这样的消息如果没有后续的处理，就变成了死信，有死信自然就有了死信队列。 应用场景：为了保证订单业务的消息数据不丢失，需要使用到 RabbitMQ 的死信队列机制，档消息消费发生异常时，将消息投入到死信队列中。还有比如说：用户在商城下单成功并点击支付后再指定
RabbitMQ系列（15）--死信队列的简介与死信队列和死信消费者的实现
m0_64284147的博客
07-06 3189
(21)查看Consumer01控制台的输出，观察dead_queue队列消息数量的变化，因为没有开启Consumer02消费dead_queue队列，可以看到dead_queue队列堆积了1条消息，查看这条消息，可以看出就是我们拒绝掉的info5，这证明消费者拒绝消费消息info5后，消息info5从normal_queue队列移到了dead_queue队列里，由此可见当消息被拒绝消费后，死信队列成功运行。(18)修改Consumer01的代码，注释掉限制队列长度的代码，修改消息应答的部分代码。
RabbitMQ--死信队列
最新发布
DreamDlee的博客
05-13 1056
死信顾名思义就是没办法被消费的消息；
RabbitMQ之死信队列
m0_55993923的博客
05-20 707
​ 死信，就是无法被消费的消息。​ 一般来说，producer将消息投递到broker或者直接到queue里了，consumer从queue取出消息进行消费，但某些时候由于特定的原因导致queue中的某些消息无法被消费，如果没有后续的处理，就变成了死信。​ 应用场景：为了保证订单业务的数据不丢失，需要使用到RabbitMQ的死信队列机制，当消息消费发生异常时，将消息投入死信队列中。或者用户在商城下单成功并点击去支付后在指定时间未支付时自动失效。
rabbitmq死信队列详解与使用
dotNET跨平台
11-19 627
先从概念解释上搞清楚这个定义，死信，顾名思义就是无法被消费的消息，字面意思可以这样理解，一般来说，producer将消息投递到broker或者直接到queue里了，con...
「RabbitMQ」实现消息确认机制以确保消息的可靠发送、接收和拒收
技术路上的探险家
06-08 1921
RabbitMQ的消息确认机制应用场景非常广泛，尤其是在需要确保消息可靠性和避免消息丢失的场合下更为重要，例如：金融系统、电商交易系统等。
rabbitmq-dump-queue:将消息从 RabbitMQ 队列转储到文件，而不影响队列
08-05
将消息从 RabbitMQ 队列转储到文件，而不影响队列。 安装 下载一个版本 可以在页面上找到预编译的二进制包。 从源代码编译 如果您安装了 ，则可以通过运行以下命令从源代码安装 rabbitmq-dump-queue： go get ...
erlang-21.0.9-1.el7，rabbitmq-server-3.7.7-1.el7
08-15
erlang-21.0.9-1.el7.centos.x86_64.rpm，rabbitmq-server-3.7.7-1.el7.noarch.rpm
rabbitmq-server-3.10.5-1.el8.noarch.rpm
07-01
rabbitmq-server-3.10.5-1.el8.noarch.rpm
rabbitmq-server-3.6.15-1.el7.noarch.zip
05-27
我传一个rabbitmq-server-3.6.15-1.el7.noarch.rpm 5积分的，个个都要30+以上
rabbitmq-server-generic-unix-3.7.18.tar.xz
09-29
rabbitmq-server-generic-unix-3.7.18.tar.xz版本服务器安装 有需要的可以去官网查看一下rabbitmq版本对erlang版本的一个支持情况，官网地址：http://www.rabbitmq.com/which-erlang.html
RabbitMQ：死信队列
梦想也许遥不可及，但重要的是追梦的过程，用博客记录自己的成长，记录自己一步一步向上攀登的印记
10-12 8425
队列中不能被消费的消息称为死信队列有时候因为特殊原因，可能导致队列中的某些信息无法被消费，而队列中这些不能被消费的消息在后期没有进行处理，就会变成死信队列，死信队列中的消息称为死信。应用场景:未来保证订单业务的消息数据不丢失，我们需要使用到RabbitMQ的死信队列机制，当消息消费发生异常的时候，我们就把消息投入到死信队列中，比如说用户买东西，下单成功后去支付，但是没有在指定时间支付的时候就会自动失效。死信队列，英文缩写：DLX。
RabbitMQ的死信队列
一江溪水
11-13 6804
什么是死信 在 RabbitMQ 中充当主角的就是消息，在不同场景下，消息会有不同地表现。 死信就是消息在特定场景下的一种表现形式，这些场景包括： 消息被拒绝访问，即 RabbitMQ返回 nack 的信号时 消息的 TTL 过期时 消息队列达到最大长度 消息不能入队时。 上述场景经常产生死信，即消息在这些场景中时，被称为死信。 什么是死信队列 死信队列就是用于储存死信的消息队列，在死信队列中，有且只有死信构成，不会存在其余类型的消息。 死信队列在 RabbitMQ 中并不会单独存在，往往死信队列都会绑
消息队列的坑（重复消费、顺序消费、消息丢失）
装睡的小5郎的博客
09-26 8163
一.常用的一些消息队列 1.rabbitmq erlang语言开发，时效性最高 2.rocketmq 吞吐量高，时效性高，但在大数据方面需要自己写代码支持 3.kafka 超高的吞吐量，消息较少时可能会有延迟（kafka是堆积一波消息后发送） 二.消息队列模型 1.常用的是topic订阅发布模型 同一个topic下，不同的group均能收到消息，同一个group则只能有一个消费者收到消息 2.点.........
RabbitMQ实现消息的消费确认，死信队列、延迟重试队列
白鸿源的博客
06-29 4834
消息的消费确认实现原理: 当消费者的消息消费异常时，消息进入延迟重试队列，待超时后重新发送到重试队列指定的死信队列，死信队列重新消费信息，如果又出现死信情况，继续进入延时重试队列，依次循环，当重试超过3次后，消息进入失败队列等待相应的消费者特殊处理或人工处理。 死信队列 死信队列*中（dead letter）死信的消息来源： 消息被拒绝（basic.reject或basic.nack）并且req...
RabbitMQ的死信队列的应用
热门推荐
通往精英的成长之路
03-11 3万+
强烈推荐一个大神的人工智能的教程：http://www.captainbed.net/zhanghan 【前言】 最近在项目中用到了RabbitMQ来做异步处理，自己将这块儿系统的搞了搞，下面主要记录一下自己在研究过程中对死信队列的一些研究。 【实践】 一、如何配置死信队列？ 1、增加死信队列（exchange-ttl-to.q...
基于死信队列实现RabbitMQ消息消费失败后的处理方案
lzf的博客
03-29 1526
死信队列的使用：处理失败的消息 一般生产环境中，如果你有丰富的架构设计经验，都会在使用MQ的时候设计两个队列：一个是核心业务队列，一个是死信队列。 核心业务队列，就是比如上面专门用来让订单系统发送订单消息的，然后另外一个死信队列就是用来处理异常情况的。 之所以我们这篇文章抛出一个面试题，结果先长篇大论说一个生产实践案例和业务场景，就是因为面试被问到这个问题时，必须要结合你自己的业务实践经验来说。 你需要先给面试官说有血有肉的业务系统场景，然后再结合这个场景回答他的问题，因为面试官想听的就是你
RabbitMQ的死信队列机制
qq_39794062的博客
06-24 706
一、死信队列 死信指的是无法被消费的消息，由于消息TTL过期、队列达到最大长度、消息被拒绝等原因，导致队列中一些消息无法被消费，这样的消息如果没有进行后续的处理，就会变成死信。为了保证消息数据不丢失，需要使用死信队列机制。 二、死信队列的实现 1、消息 TTL 过期 普通队列消费者Consumer01 public class Consumer01 { //不同交换机 public static final String NORMAL_EXCHANGE = "normal_exchang
ActiveMQ-死信配置项及丢弃和重新消费
phs999的博客
01-02 1100
https://blog.csdn.net/z69183787/article/details/88534988 当对消息设置存活过期时间时，消息超过时间仍然未被消费，则会自动移动到死信队列中。DLQ-死信队列(Dead Letter Queue)用来保存处理失败或者过期的消息。 producer.setTimeToLive(1);//设置消息的存活时间 producer.send(message); 默认的队列名称为ActiveMQ.DLQ ，也可以通过修改配置文件指定。 修改死信.
RabbitMq消息队列指南.docx
07-05
RabbitMQ 是由 Erlang 语言开发，基于 AMQP（Advanced Message Queue 高级消息队列协议）协议实现的消息队列。它是一种应用程序之间的通信方法，在分布式系统开发中应用非常广泛。MQ（Message Queue）是消息队列的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值