RabbitMQ高级特性

女爷i 2024-03-26 20:43 16阅读 0赞

**目录**

RabbitMQ高级特性

1、消息的可靠投递

2、Consumer Ack

3、消费端限流

4、TTL（存活时间/过期时间）

5、死信队列

6、延迟队列

7、日志与监控

8、消息追踪

9、消息可靠性保障--消息补偿

10、RabbitMQ集群搭建

--------------------

### RabbitMQ高级特性 ###

#### 1、消息的可靠投递 ####

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

1、confirm 确认模式

2、return 退回模式

rabbitmq 整个消息投递的路径为：

producer--->rabbitmq broker--->exchange--->queue--->consumer

消息从 producer 到 exchange 则会返回一个 confirmCallback 。

消息从 exchange-->queue 投递失败则会返回一个 returnCallback 。

我们将利用这两个 callback 控制消息的可靠性投递

**确认模式**

1、设置ConnectionFactory的publisher-confirms="true" 开启 确认模式

2、使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回 调confirm

方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发 送失败，需要处理。

/**
         * 确认模式：
         * 步骤：
         * 1. 确认模式开启：ConnectionFactory中开启publisher-confirms="true"
         * 2. 在rabbitTemplate定义ConfirmCallBack回调函数
         */
        @Test
        public void testConfirm() {
    
            //2. 定义回调
            rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
                /**
                 *
                 * @param correlationData 相关配置信息
                 * @param ack   exchange交换机 是否成功收到了消息。true 成功，false代表失败
                 * @param cause 失败原因
                 */
                @Override
                public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                    System.out.println("confirm方法被执行了....");
    
                    if (ack) {
                        //接收成功
                        System.out.println("接收成功消息" + cause);
                    } else {
                        //接收失败
                        System.out.println("接收失败消息" + cause);
                        //做一些处理，让消息再次发送。
                    }
                }
            });
    
            //3. 发送消息
            rabbitTemplate.convertAndSend("test_exchange_confirm111", "confirm", "message confirm....");
        }

**回退模式**

1、设置ConnectionFactory的publisher-returns="true" 开启 退回模式

2、使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到 queue失败

后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退 回给producer。并执行回

调函数returnedMessage。

/**
         * 回退模式： 当消息发送给Exchange后，Exchange路由到Queue失败是 才会执行 ReturnCallBack
         * 步骤：
         * 1. 开启回退模式:publisher-returns="true"
         * 2. 设置ReturnCallBack
         * 3. 设置Exchange处理消息的模式：
         * 1. 如果消息没有路由到Queue，则丢弃消息（默认）
         * 2. 如果消息没有路由到Queue，返回给消息发送方ReturnCallBack
         */
    
        @Test
        public void testReturn() {
    
            //设置交换机处理失败消息的模式
            rabbitTemplate.setMandatory(true);
    
            //2.设置ReturnCallBack
            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("return 执行了....");
    
                    System.out.println(message);
                    System.out.println(replyCode);
                    System.out.println(replyText);
                    System.out.println(exchange);
                    System.out.println(routingKey);
    
                    //处理
                }
            });
    
    
            //3. 发送消息
            rabbitTemplate.convertAndSend("test_exchange_confirm", "confirm", "message confirm....");
        }

#### **2、Consumer Ack** ####

ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。

有三种确认方式：

1、自动确认：acknowledge="none"

2、手动确认：acknowledge="manual"

3、根据异常情况确认：acknowledge="auto"

其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从

RabbitMQ 的 消息缓存中移除。但是在实际业务处理中，很可能消息接收到，业务处理出现异常，

那么该消息就会丢失。如 果设置了手动确认方式，则需要在业务处理成功后，调用

channel.basicAck()，手动签收，如果出现异常，则 调用channel.basicNack()方法，让其自动重新

发送消息

/**
     * Consumer ACK机制：
     *  1. 设置手动签收。acknowledge="manual"
     *  2. 让监听器类实现ChannelAwareMessageListener接口
     *  3. 如果消息成功处理，则调用channel的 basicAck()签收
     *  4. 如果消息处理失败，则调用channel的basicNack()拒绝签收，broker重新发送给consumer
     *
     *
     */
    
    @Component
    public class AckListener implements ChannelAwareMessageListener {
    
        @Override
        public void onMessage(Message message, Channel channel) throws Exception {
            long deliveryTag = message.getMessageProperties().getDeliveryTag();
    
            try {
                //1.接收转换消息
                System.out.println(new String(message.getBody()));
    
                //2. 处理业务逻辑
                System.out.println("处理业务逻辑...");
                int i = 3/0;//出现错误
                //3. 手动签收
                channel.basicAck(deliveryTag,true);
            } catch (Exception e) {
                //e.printStackTrace();
    
                //4.拒绝签收
                /*
                第三个参数：requeue：重回队列。如果设置为true，则消息重新回到queue，broker会重新发送该消息给消费端
                 */
                channel.basicNack(deliveryTag,true,true);
                //channel.basicReject(deliveryTag,true);
            }
        }
    }

总结：

1、在rabbit:listener-container标签中设置acknowledge属性，设置ack方式 none：自动确认，manual：手动确认

2、如果在消费端没有出现异常，则调用channel.basicAck(deliveryTag,false);方法确认签收消息

3、如果出现异常，则在catch中调用 basicNack或 basicReject，拒绝消息，让MQ重新发送消息

#### **3、消费端限流** ####

请求过多的时候消费端可以限制消费的数量

/**
     * Consumer 限流机制
     *  1. 确保ack机制为手动确认。
     *  2. listener-container配置属性
     *      perfetch = 1,表示消费端每次从mq拉去一条消息来消费，直到手动确认消费完毕后，才会继续拉去下一条消息。
     */
    
    @Component
    public class QosListener implements ChannelAwareMessageListener {
    
        @Override
        public void onMessage(Message message, Channel channel) throws Exception {
    
            Thread.sleep(1000);
            //1.获取消息
            System.out.println(new String(message.getBody()));
    
            //2. 处理业务逻辑
    
            //3. 签收
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);
    
        }
    }

总结：

在 中配置 prefetch属性设置消费端一次拉取多少消息

消费端的确认模式一定为手动确认。acknowledge="manual"

#### 4、TTL（存活时间/过期时间） ####

TTL 全称 Time To Live（存活时间/过期时间）

当消息到达存活时间后，还没有被消费，会被自动清除

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

/**
         * TTL:过期时间
         *  1. 队列统一过期
         *
         *  2. 消息单独过期
         *
         *
         * 如果设置了消息的过期时间，也设置了队列的过期时间，它以时间短的为准。
         * 队列过期后，会将队列所有消息全部移除。
         * 消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉)
         *
         */
        @Test
        public void testTtl() {
    
    
          /*  for (int i = 0; i < 10; i++) {
                // 发送消息
                rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....");
            }*/
    
          // 消息后处理对象，设置一些消息的参数信息
            MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
    
                @Override
                public Message postProcessMessage(Message message) throws AmqpException {
                    //1.设置message的信息
                    message.getMessageProperties().setExpiration("5000");//消息的过期时间
                    //2.返回该消息
                    return message;
                }
            };
    
    
            //消息单独过期
            //rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....",messagePostProcessor);
    
    
            for (int i = 0; i < 10; i++) {
                if(i == 5){
                    //消息单独过期
                    rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....",messagePostProcessor);
                }else{
                    //不过期的消息
                    rabbitTemplate.convertAndSend("test_exchange_ttl", "ttl.hehe", "message ttl....");
    
                }
    
            }
    
    
        }

总结：

设置队列过期时间使用参数：x-message-ttl，单位：ms(毫秒)，会对整个队列消息统一过期。

设置消息过期时间使用参数：expiration。单位：ms(毫秒)，当该消息在队列头部时（消费时），会单独判断 这一消息是否过期。

如果两者都进行了设置，以时间短的为准

如果设置了消息的过期时间，也设置了队列的过期时间，它以时间短的为准。

队列过期后，会将队列所有消息全部移除。

消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉)

#### 5、死信队列 ####

死信队列，英文缩写：DLX 。Dead Letter Exchange（死信交换机），当消息成为Dead message后，可以 被重新发送到另一个交换机，这个交换机就是DLX

![ccf9467878c549e783ba89e7fa06e54b.png][]

消息成为死信的三种情况：

1. 队列消息长度到达限制；

2. 消费者拒接消费消息，basicNack/basicReject,并且不把消息重新放入原目标列,requeue=false；

3. 原队列存在消息过期设置，消息到达超时时间未被消费

队列绑定死信交换机:

给队列设置参数： x-dead-letter-exchange 和 x-dead-letter-routing-key

![5cf74b613104477c8850c56cbd341e51.png][]

总结：

1. 死信交换机和死信队列和普通的没有区别

2. 当消息成为死信后，如果该队列绑定了死信交换机，则消息会被死信交换机重新路由到死信队 列

声明死信队列

<rabbit:queue name="test_queue_dlx" id="test_queue_dlx">
            
            <rabbit:queue-arguments>
                
                <entry key="x-dead-letter-exchange" value="exchange_dlx" />
    
                
                <entry key="x-dead-letter-routing-key" value="dlx.hehe" />
    
                
                <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer" />
                
                <entry key="x-max-length" value="10" value-type="java.lang.Integer" />
            </rabbit:queue-arguments>
        </rabbit:queue>
        <rabbit:topic-exchange name="test_exchange_dlx">
            <rabbit:bindings>
                <rabbit:binding pattern="test.dlx.#" queue="test_queue_dlx"></rabbit:binding>
            </rabbit:bindings>
        </rabbit:topic-exchange>
    
    
        
    
        <rabbit:queue name="queue_dlx" id="queue_dlx"></rabbit:queue>
        <rabbit:topic-exchange name="exchange_dlx">
            <rabbit:bindings>
                <rabbit:binding pattern="dlx.#" queue="queue_dlx"></rabbit:binding>
            </rabbit:bindings>
        </rabbit:topic-exchange>

测试

/**
         * 发送测试死信消息：
         *  1. 过期时间
         *  2. 长度限制
         *  3. 消息拒收
         */
        @Test
        public void testDlx(){
            //1. 测试过期时间，死信消息
            //rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息，我会死吗？");
    
            //2. 测试长度限制后，消息死信
           /* for (int i = 0; i < 20; i++) {
                rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息，我会死吗？");
            }*/
    
            //3. 测试消息拒收
            rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","我是一条消息，我会死吗？");
    
        }

消费端消息拒收且不重回队列 requeue=false，消息也会发送到死信队列

@Component
    public class DlxListener implements ChannelAwareMessageListener {
    
        @Override
        public void onMessage(Message message, Channel channel) throws Exception {
            long deliveryTag = message.getMessageProperties().getDeliveryTag();
    
            try {
                //1.接收转换消息
                System.out.println(new String(message.getBody()));
    
                //2. 处理业务逻辑
                System.out.println("处理业务逻辑...");
                int i = 3/0;//出现错误
                //3. 手动签收
                channel.basicAck(deliveryTag,true);
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("出现异常，拒绝接受");
                //4.拒绝签收，不重回队列 requeue=false
                channel.basicNack(deliveryTag,true,false);
            }
        }
    }

#### 6、延迟队列 ####

延迟队列，即消息进入队列后不会立即被消费，只有到达指定时间后，才会被消费

需求：

1. 下单后，30分钟未支付，取消订单，回滚库存。

2. 新用户注册成功7天后，发送短信问候。

实现方式： 1. 定时器 2. 延迟队列

![8a38c6b403af4bdbbf7ee52390fbd3a2.png][]

在RabbitMQ中并未提供延迟队列功能。 但是可以使用：TTL+死信队列 组合实现延迟队列的效

果。

![d368e2fd7cb6404abf6f49a032708403.png][]

1、定义队列

<rabbit:queue id="order_queue" name="order_queue">
            
            <rabbit:queue-arguments>
                <entry key="x-dead-letter-exchange" value="order_exchange_dlx" />
                <entry key="x-dead-letter-routing-key" value="dlx.order.cancel" />
                <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer" />
    
            </rabbit:queue-arguments>
    
        </rabbit:queue>
        <rabbit:topic-exchange name="order_exchange">
            <rabbit:bindings>
                <rabbit:binding pattern="order.#" queue="order_queue"></rabbit:binding>
            </rabbit:bindings>
        </rabbit:topic-exchange>
    
        
        <rabbit:queue id="order_queue_dlx" name="order_queue_dlx"></rabbit:queue>
        <rabbit:topic-exchange name="order_exchange_dlx">
            <rabbit:bindings>
                <rabbit:binding pattern="dlx.order.#" queue="order_queue_dlx"></rabbit:binding>
            </rabbit:bindings>
        </rabbit:topic-exchange>

生产者发送消息

@Test
        public  void testDelay() throws InterruptedException {
            //1.发送订单消息。 将来是在订单系统中，下单成功后，发送消息
            rabbitTemplate.convertAndSend("order_exchange","order.msg","订单信息：id=1,time=2019年8月17日16:41:47");
    
    
            /*//2.打印倒计时10秒
            for (int i = 10; i > 0 ; i--) {
                System.out.println(i+"...");
                Thread.sleep(1000);
            }*/
    
    
        }

消费者接收消息

注意：延迟队列效果实现， 一定要监听 死信队列！

@Component
    public class OrderListener implements ChannelAwareMessageListener {
    
        @Override
        public void onMessage(Message message, Channel channel) throws Exception {
            long deliveryTag = message.getMessageProperties().getDeliveryTag();
    
            try {
                //1.接收转换消息
                System.out.println(new String(message.getBody()));
    
                //2. 处理业务逻辑
                System.out.println("处理业务逻辑...");
                System.out.println("根据订单id查询其状态...");
                System.out.println("判断状态是否为支付成功");
                System.out.println("取消订单，回滚库存....");
                //3. 手动签收
                channel.basicAck(deliveryTag,true);
            } catch (Exception e) {
                //e.printStackTrace();
                System.out.println("出现异常，拒绝接受");
                //4.拒绝签收，不重回队列 requeue=false
                channel.basicNack(deliveryTag,true,false);
            }
        }
    }

#### 7、日志与监控 ####

RabbitMQ默认日志存放路径： /var/log/rabbitmq/rabbit@xxx.log

日志包含了RabbitMQ的版本号、Erlang的版本号、RabbitMQ服务节点名称、cookie的hash值、

RabbitMQ配置文件地址、内存限制、磁盘限制、默认账户guest的创建以及权限配置等等。

![ec00542869374487a0de6c8d8957dc6b.png][]

rabbitmqctl管理和监控常见命令

<table style="width:500px;"> 
 <tbody> 
  <tr> 
   <td>说明</td> 
   <td>命令</td> 
  </tr> 
  <tr> 
   <td>查看队列</td> 
   <td># rabbitmqctl list_queues</td> 
  </tr> 
  <tr> 
   <td>查看exchanges</td> 
   <td># rabbitmqctl list_exchanges</td> 
  </tr> 
  <tr> 
   <td>查看用户</td> 
   <td># rabbitmqctl list_users</td> 
  </tr> 
  <tr> 
   <td>查看连接</td> 
   <td># rabbitmqctl list_connections</td> 
  </tr> 
  <tr> 
   <td>查看消费者信息</td> 
   <td># rabbitmqctl list_consumers</td> 
  </tr> 
  <tr> 
   <td>查看环境变量</td> 
   <td># rabbitmqctl environment</td> 
  </tr> 
  <tr> 
   <td>查看未被确认的队列</td> 
   <td># rabbitmqctl list_queues name messages_unacknowledged</td> 
  </tr> 
  <tr> 
   <td>查看单个队列的内存使用</td> 
   <td># rabbitmqctl list_queues name memory</td> 
  </tr> 
  <tr> 
   <td>查看准备就绪的队列</td> 
   <td># rabbitmqctl list_queues name messages_ready</td> 
  </tr> 
 </tbody> 
</table>

#### 8、消息追踪 ####

在使用任何消息中间件的过程中，难免会出现某条消息异常丢失的情况。对于RabbitMQ而言，可能 是因为生产者或消费者与RabbitMQ断开了连接，而它们与RabbitMQ又采用了不同的确认机制；也 有可能是因为交换器与队列之间不同的转发策略；甚至是交换器并没有与任何队列进行绑定，生产者 又不感知或者没有采取相应的措施；另外RabbitMQ本身的集群策略也可能导致消息的丢失。这个时 候就需要有一个较好的机制跟踪记录消息的投递过程，以此协助开发和运维人员进行问题的定位

在RabbitMQ中可以使用Firehose和rabbitmq\_tracing插件功能来实现消息追踪

**消息追踪-Firehose**

firehose的机制是将生产者投递给rabbitmq的消息，rabbitmq投递给消费者的消息按照指定的格式 发送到默认的exchange上。这个默认的exchange的名称为amq.rabbitmq.trace，它是一个topic类 型的exchange。发送到这个exchange上的消息的routing key为 publish.exchangename 和 deliver.queuename。其中exchangename和queuename为实际exchange和queue的名称，分别 对应生产者投递到exchange的消息，和消费者从queue上获取的消息。

注意：打开 trace 会影响消息写入功能，适当打开后请关闭。

rabbitmqctl trace\_on：开启Firehose命令

rabbitmqctl trace\_off：关闭Firehose命令

**消息追踪-rabbitmq\_tracing**

rabbitmq\_tracing和Firehose在实现上如出一辙，只不过rabbitmq\_tracing的方式比Firehose多了一 层GUI的包装，更容易使用和管理。 启用插件：rabbitmq-plugins enable rabbitmq\_tracing

#### 9、消息可靠性保障--消息补偿 ####

![bff639547dd34d1e9fb18cacab2dce4c.png][]

消息幂等性保障

幂等性指一次和多次请求某一个资源，对于资源本身应该具有同样的结果。也就是说，其任 意多次执行对资源本身所产生的影响均与一次执行的影响相同。

在MQ中指，消费多条相同的消息，得到与消费该消息一次相同的结果

消息幂等性保障--乐观锁机制

![7bb726f146ff405785c390dea7121d7a.png][]

#### 10、RabbitMQ集群搭建 ####

链接: https://pan.baidu.com/s/1vMpZHFcT60x7AAFVWoI7iA?pwd=5agu

提取码: 5agu

本文章是参考bilibili视频总结，原视频：[1\_MQ的重要性\_哔哩哔哩\_bilibili][1_MQ_bilibili]

[ccf9467878c549e783ba89e7fa06e54b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/774acb8a1d9842bb90458945c552fe4f.png
[5cf74b613104477c8850c56cbd341e51.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/21239f8f2a514166af878a4c39f2bcd7.png
[8a38c6b403af4bdbbf7ee52390fbd3a2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/e253ee9ae2074370920637e4eccf10e5.png
[d368e2fd7cb6404abf6f49a032708403.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b56e64c3e2e24c97be063c080d7c3fdd.png
[ec00542869374487a0de6c8d8957dc6b.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/559077e222774739a968759fe7a75a0e.png
[bff639547dd34d1e9fb18cacab2dce4c.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/13afc3b2557e4fdd946b47d1280a968d.png
[7bb726f146ff405785c390dea7121d7a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/409479fe31c44fa687654a00064453d8.png
[1_MQ_bilibili]: https://www.bilibili.com/video/BV15k4y1k7Ep?p=1&vd_source=fb08e07e88523964b1ce5104ac75d7bd