RabbitMQ高级特性

有什么奇怪！

于 2022-08-28 18:43:29 发布

阅读量593

点赞数

分类专栏： # MQ 文章标签： java-rabbitmq rabbitmq java

本文链接：https://blog.csdn.net/weixin_45483328/article/details/126571794

版权

MQ 专栏收录该内容

2 篇文章 0 订阅

订阅专栏

文章目录

1. 简述
2. 特性示例：

1. 简述

在rabbitMQ都官方文档中，高级特性又叫做Our Extensions
在这里插入图片描述
常用的有：

消息可靠性投递
Consumer ACK
消费端限流
TTL
死信队列
延迟队列

2. 特性示例：

2.1 消息可靠性投递

在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

confirm 确认模式
return 退回模式

其中rabbitmq 整个消息投递的路径为：
producer ---> rabbitmq broker ---> exchange ---> queue ---> consumer

消息从 producer 到 exchange 则会返回一个 confirmCallback 。
消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。

我们使用这两个callBack控制消息的可靠性投递

// 生产者
 	/**
     * 确认模式：
     *      1. 开启确认模式，在yml中将 publisher-confirms 设置为true
     *      2. 在rabbitTemplate中定义回调函数 setConfirmCallback
     */
    @Test
    public void testConfirm() throws InterruptedException {

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             *
             * @param correlationData 交换机相关配置
             * @param b 是否发送成功， true 为成功
             * @param s 发送失败的原因
             */
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("发送消息....");
                if (b) {
                    System.out.println("消息发送成功 " + s);
                } else {
                    System.out.println("消息发送失败 " + s);
                }
            }
        });
        rabbitTemplate.convertAndSend("test_Exchange_confirm","confirm","mq confirm ~~~");

        Thread.sleep(2000);
    }

    /**
     * 回退模式： 当exchange将消息发送给 queue后，发送失败，才会执行returnCallBack
     *  步骤：
     *      1. 开启回退模式： publisher-returns: true
     *      2. 设置 returnCallBack
     *      3. 设置Exchange的处理模式
     *          1. 如果消息没有路由到queue，丢弃消息 （默认）
     *          2. 如果消息没有路由到queue， 返回给消息发送方 returnCallBack
     */
    @Test
    public void testReturn() throws InterruptedException {
        // 设置交换机处理消息的模式
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
            /**
             * @param message 消息对象
             * @param replyCode 错误码
             * @param replyText 错误信息
             * @param exchange 交换机信息
             * @param routingKey 路由键
             */
            @Override
            public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
                System.out.println("执行returnCallBack");
                System.out.println(message);
                System.out.println(replyCode);
                System.out.println(replyText);
                System.out.println(exchange);
                System.out.println(routingKey);
            }
        });

        rabbitTemplate.convertAndSend("test_Exchange_confirm","confirm","mq confirm ~~~");
        Thread.sleep(3000);
    }

步骤：

开启消息发送的回调模式
重写ConfirmCallback和ReturnCallBack 两个方法，用来接收消息是否完成发送的信息

小结：

设置ConnectionFactory的publisher-confirms=“true” 开启确认模式。
使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回
调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发
送失败，需要处理。
设置ConnectionFactory的publisher-returns=“true” 开启退回模式
使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到
queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退
回给producer。并执行回调函数returnedMessage。

2.2 Consumer Ack

当 RabbitMQ 将消息传递给消费者时，RabbbitMQ需要知道这个消息是否到达，那么消费者共有三种模式：

自动确认：acknowledge=“none”
手动确认：acknowledge=“manual”
根据异常情况确认：acknowledge=“auto”

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。
但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。

开启手动确认模式

acknowledge-mode: manual

注意：
当节点将消息传递给使用者时，它必须决定是否应将该消息视为由使用者处理（或至少接收）。由于多个事物（客户端连接、使用者应用等）可能会失败，因此此决策是一个数据安全问题。消息传递协议通常提供一种确认机制，允许使用者确认对其所连接到的节点的传递。是否使用该机制是在消费者订阅时决定的。

根据所使用的确认模式，RabbitMQ 可以认为消息在发送出去（写入 TCP 套接字）或收到显式（“手动”）客户端确认后立即成功传递。手动发送的确认可以是正数或负数，并使用以下协议方法之一：

basic.ack : 用于正面确认
basic.nack : 用于否定确认，可以异常拒绝多个失败请求
basic.reject: 用于否定确认，只能拒绝一个

	/**
     *  consumer Ack步骤：
     *      1. 在yml中开启 acknowledge-mode: manual
     *      2. 监听器加上RabbitHandler
     *      3. 定义方法参数为 （String msg, Channel channel, Message message)
     *      4. 如果方法执行成功，调用 channel.basicAck
     *      5. 如果方法执行失败，调用 channel.basicNAck
     * @param message
     */

    @RabbitHandler
    public void ListenerMessage(String msg, Channel channel, Message message) throws InterruptedException {
        Thread.sleep(1000);
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        try {
            System.out.println("接收到消息 ：" + msg);
            System.out.println("开始处理消息");
            int a = 1 / 0;
            /**
             * basicAck(long deliveryTag, boolean multiple)
             *      deliveryTag 类似于TCP中的ACK号
             *      multiple 确认所有消息到达
             */
            channel.basicAck(deliveryTag, true);
            System.out.println("消息处理成功");
        } catch (Exception e) {
            try {
                /**
                 * basicNack(long deliveryTag, boolean multiple, boolean requeue)
                 *      requeue : true 表示重新丢回队列
                 *                  false 表示直接丢弃
                 */
                channel.basicNack(deliveryTag, true, true);
                System.out.println("消息发送失败。。。");
            } catch (IOException ioException) {
                ioException.printStackTrace();
            }
        }
    }

在自动确认模式下，消息在发送后立即被视为已成功传递。这种模式以更高的吞吐量（只要消费者能够跟上）换取降低交付和消费者处理的安全性。这种模式通常被称为“即发即弃”。与手动确认模型不同，如果消费者的TCP连接或通道在成功传递之前关闭，则服务器发送的消息将丢失。因此，应将自动消息确认视为不安全，并且不适合所有工作负荷。
使用自动确认模式时要考虑的另一件重要事情是使用者重载。手动确认模式通常与有界通道预取一起使用，该预取限制通道上未完成（“进行中”）传递的数量。但是，使用自动确认时，根据定义没有这样的限制。因此，消费者可能会被交付速度所淹没，这可能会在内存中积累积压并耗尽堆或使其进程作系统终止。某些客户端库将应用 TCP 背压（停止从套接字读取，直到未处理的交付的积压超过一定限制）。因此，自动确认模式仅推荐给能够高效且稳定地处理交付的消费者。

2.3 消费端限流

根据消费端处理能力来决定消费端一次最多可以拉取的消息
属性为： prefetch
例如： prefetch = 1 表示消费端一秒只接受一条消息，直到手动确认接收完毕，才接收下一条消息

值得注意的是，如果prefetch=0表示可以接收任意数量的未确认消息

2.4 TTL

TTL 全称 Time To Live（存活时间/过期时间）。当消息到达存活时间后，还没有被消费，会被自动清除。

RabbitMQ可以对消息设置过期时间，也可以对整个队列（Queue）设置过期时间。

	@Test
    public void testSent() throws InterruptedException {
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            @Override
            public void confirm(CorrelationData correlationData, boolean b, String s) {
                System.out.println("发送消息....");
                if (b) {
                    System.out.println("消息发送成功 " + s);
                } else {
                    System.out.println("消息发送失败 " + s);
                }
            }
        });

        /**
         * 消息后处理对象，设置消息的一些参数
         */
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                // 1. 设置过期时间
                message.getMessageProperties().setExpiration("10000");
                // 2. 返回消息
                return message;
            }
        };
        /**
         * TTL 过期有两种设置
         *      1. 队列整个消息过期 ： 需要在队列参数中设置 "x-message-ttl", 10000
         *      2. 单个消息设置过期：
         *          如果设置了队列的过期时间和单个消息的过期时间，谁时间段谁就生效
         *          队列过期后，会将所有消息都清除
         *          RabbitMQ并不会轮询消息，而是消息到了队列顶端，才会判断消息是否过期
         */
        for (int i = 0; i < 10; i++) {
            rabbitTemplate.convertAndSend("test_Exchange_TTL","ttl.hhh","mq ttl ~~~" + i, messagePostProcessor);
        }


        Thread.sleep(100000);
    }

2.5 死信队列

在这里插入图片描述

消息成为死信的三种方式：

队列消息长度到达限制；
消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标队列,requeue=false；
原队列存在消息过期设置，消息到达超时时间未被消费；

配置死信队列

 	/** 测试死信队列
    * 分别创建正常的队列(test_queue_dlx)和正常的交换机(test-exchange_dlx)
    * 创建死信队列(queue_dlx)和死信交换机(exchange_dlx)
    * 正常队列绑定死信交换机，并且指定
    *      x-dead-letter-exchange
    *      x-dead-letter-routing-key
    */

    /**
     * 创建正常队列和正常交换机
     */

    @Bean("test_queue_dlx")
    public Queue testQueueDlx() {
        return QueueBuilder.durable("test_queue_dlx")
                .withArgument("x-dead-letter-exchange", "exchange_dlx") //指定死信交换机
                .withArgument("x-dead-letter-routing-key", "dlx.hhh")  // 指定路由key
                .withArgument("x-message-ttl", 10000) //设置队列过期时间
                .withArgument("x-max-length", 10) //设置最大长度
                .build();
    }

    @Bean("test_exchange_dlx")
    public Exchange testExchangeDlx() {
        return ExchangeBuilder.topicExchange("test_exchange_dlx").build();
    }

    @Bean
    public Binding DlxBinding(@Qualifier("test_queue_dlx") Queue queue, @Qualifier("test_exchange_dlx") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("test.dlx.#").noargs();
    }

    /**
     * 创建死信队列和死信交换机
     */

    @Bean("queue_dlx")
    public Queue QueueDlx() {
        return QueueBuilder.durable("queue_dlx").build();
    }

    @Bean("exchange_dlx")
    public Exchange ExchangeDlx() {
        return ExchangeBuilder.topicExchange("exchange_dlx").build();
    }

    @Bean
    public Binding DlxBindingDead(@Qualifier("queue_dlx") Queue queue, @Qualifier("exchange_dlx") Exchange exchange) {
        return BindingBuilder.bind(queue).to(exchange).with("dlx.#").noargs();
    }

测试死信队列

	// 1. 队列消息过期
    rabbitTemplate.convertAndSend("test_exchange_dlx", "test.dlx.hhh", "我那些残梦灵翼九霄");

    // 2. 队列长度超出，设置队列长度为10
        for (int i = 0; i < 20; i++) {
            rabbitTemplate.convertAndSend("test_exchange_dlx", "test.dlx.hhh", "我那些残梦灵翼九霄");
       }

        //3. 测试消息拒收
        rabbitTemplate.convertAndSend("test_exchange_dlx", "test.dlx.hhh", "我那些残梦灵翼九霄");

2.6 延迟队列

使用TTL + 死信队列，就是延迟队列
TTL用于定时，消费者从死信队列中取值

有什么奇怪！

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
RabbitMQ高级特性

但是，使用自动确认时，根据定义没有这样的限制。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。根据所使用的确认模式，RabbitMQ 可以认为消息在发送出去（写入 TCP 套接字）或收到显式（“手动”）客户端确认后立即成功传递。其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从 RabbitMQ 的消息缓存中移除。...
复制链接

扫一扫