（三）RabbitMQ的高级特性

最新推荐文章于 2024-05-20 19:27:48 发布
最新推荐文章于 2024-05-20 19:27:48 发布
阅读量537 收藏 1
点赞数
分类专栏： 中间件 文章标签： rabbitmq
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Hacker_D/article/details/107901918
版权

RabbitMQ的高级特性

消息的可靠投递

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

rabbitmq 整个消息投递的路径为：
producer—>rabbitmq broker—>exchange—>queue—>consumer
消息从 producer 到 exchange 则会返回一个 confirmCallback 。
消息从 exchange–>queue 投递失败则会返回一个 returnCallback 。
我们将利用这两个 callback 控制消息的可靠性投递

确认模式

在连接工厂里开启确认模式，默认为false，是关闭的

在这里插入图片描述

代码中的实现：

@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
public class ProducerTest {

    @Autowired
    RabbitTemplate rabbitTemplate;

    /**
     * 1.确认模式的开启  publisher-confirms="true"
     * 2.在rabbitTemplate定义ConfirmCallBack回调函数
     */
    @Test
    public void testConfirm(){

        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             *
             * @param correlationData 相关配置信息
             * @param b exchange交换机 是否收到了消息 。true成功 false代表失败
             * @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("接收消息失败："+"\n"+"原因： "+s);

                    //以后要对此失败了 做一些处理，让消息再次发送，保证它发送成功
                }

            }
        });

        rabbitTemplate.convertAndSend("test_exchange_confirm","confirm","message");

    }
}

测试：

测试成功的情况：
在这里插入图片描述

测试失败的情况（将发送消息中交换机故意该成错误的交换机 test_exchange_confirm1）：
在这里插入图片描述

回退模式

在连接工厂里开启回退模式

在这里插入图片描述

代码中的实现：

    /**
     * 回退模式： 当消息发送给Exchange后，Exchange路由到Queue失败后，才会执行 ReturnBack
     * 步骤：
     *  1.开启回退模式  publisher-returns="true"
     *  2.设置ReturnCallBack
     *  3.设置Exchange处理消息的模式
     *      1.如果消息没有路由到Queue，则丢弃消息（默认的方式）
     *      2.如果消息没有路由到Queue，返回给消息发送方ReturnBack
     */
    @Test
    public void testReturn(){

        //设置交换机处理消息的模式为 如果消息没有路由到Queue，返回给消息发送方
        rabbitTemplate.setMandatory(true);

        rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {

            /**
             *
             * @param message 消息对象
             * @param i  错误码
             * @param s  错误信息
             * @param s1 交换机名字
             * @param s2 路由键
             */
            @Override
            public void returnedMessage(Message message, int i, String s, String s1, String s2) {
                System.out.println("return执行了。。。。。。");

                System.out.println("消息对象："+message);
                System.out.println("错误码："+i);
                System.out.println("错误信息："+s);
                System.out.println("交换机名称："+s1);
                System.out.println("路由键："+s2);

            }
        });

        rabbitTemplate.convertAndSend("test_exchange_confirm","confirm111","message");

    }

测试：

测试默认的方式，如果消息没有路由到Queue，则丢弃消息（默认的方式）

我们将路由键改成错误的路由键 confirm111

我们发现没有消息打印，代表消息已被丢弃
在这里插入图片描述

设置交换机处理消息的模式为 如果消息没有路由到Queue，返回给消息发送方 rabbitTemplate.setMandatory(true);

然后同样的把我们将路由键改成错误的路由键 confirm111

结果
在这里插入图片描述

消息的可靠投递小结

设置ConnectionFactory的publisher-confirms=“true” 开启 确认模式。

使用rabbitTemplate.setConfirmCallback设置回调函数。当消息发送到exchange后回调confirm方法。在方法中判断ack，如果为true，则发送成功，如果为false，则发送失败，需要处理。

设置ConnectionFactory的publisher-returns=“true” 开启 退回模式。

使用rabbitTemplate.setReturnCallback设置退回函数，当消息从exchange路由到queue失败后，如果设置了rabbitTemplate.setMandatory(true)参数，则会将消息退回给producer。并执行回调函数returnedMessage。

在RabbitMQ中也提供了事务机制，但是性能较差，此处不做讲解。
使用channel下列方法，完成事务控制：
txSelect(), 用于将当前channel设置成transaction模式
txCommit()，用于提交事务
txRollback(),用于回滚事务

Consumer Ack

ack指Acknowledge，确认。 表示消费端收到消息后的确认方式。
有三种确认方式：
自动确认：acknowledge=“none”
手动确认：acknowledge=“manual”
根据异常情况确认：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 {
        Thread.sleep(1000);

        //获取deliveryTag
        long deliveryTag = message.getMessageProperties().getDeliveryTag();
        
        //巧妙的运用异常捕获机制 应用消息签收或者拒收
        try {
            //接收转换消息
            System.out.println(new String(message.getBody()));

            //处理业务逻辑 （此处先用简单的打印语句代替）
            System.out.println("处理业务逻辑。。。。");
//            int i=1/0; 此添加的一个异常用来测试

            /**手动签收
             * basicAck(long deliveryTag, boolean multiple)
             * 1.deliveryTag 表示收到消息的一个标签
             * 2.multiple 表示是否同时签收多条消息
             */
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            /** 拒绝签收
             *  basicNack(long deliveryTag, boolean multiple, boolean requeue)
             *  第三个参数：requeue 重回队列。如果设置为true，则消息重新回到queue，
             *            broker会重新发送消息给消费端
             */
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

测试：

我们发送一条消息

消费者端：收到消息，业务逻辑正常，成功签收
在这里插入图片描述

我们在消费者端处理业务逻辑时 手动模拟一个异常
我们再发送一个消息

消费者端：收到消息，业务逻辑出错，拒绝签收
之后，broker不断重新发送消息给消费者端
在这里插入图片描述

在这里插入图片描述

Consumer Ack 小结

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

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

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

消费端限流

这里的每秒从MQ中拉取1000个请求 就是靠的消费端限流
在这里插入图片描述

设置每次拉取消息的条数，注意前提 消费端的确认模式一定为手动确认。acknowledge=“manual”

在这里插入图片描述

生产者发送十条消息

    @Test
    public void testSend(){

        for (int i=1;i<=10;i++){
            rabbitTemplate.convertAndSend("test_exchange_confirm","confirm","message"+i);
        }
    }

消费端

/**
 * Consumer 限流机制
 * 1.确保ack机制为手动确认 acknowledge="manual"
 * 2.listener-container 配置属性
 *   prefetch= 1,表示消费端每次从mq拉去一条消息来消费，
 *   直到手动确认消费完毕后，才会继续拉取吓一条消息。
 */
@Component
public class QosListener implements ChannelAwareMessageListener {


    @Override
    public void onMessage(Message message, Channel channel) throws Exception {
        Thread.sleep(1000);//设置线程休眠，便于看一次拉取一条的效果

        System.out.println(new String(message.getBody()));

        //手动签收
        channel.basicAck(message.getMessageProperties().getDeliveryTag(),true);

    }
}

然后我们把手动签收basicAck先注掉

我们发现一次性只拉取了一条，等待签收
在这里插入图片描述

在这里插入图片描述

把手动签收打开，我们可以看到消息一条一条的被拉取
在这里插入图片描述

消费端限流小结

在rabbit:listener-container 中配置 prefetch属性设置消费端一次拉取多少消息

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

TTL

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

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

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

在这里插入图片描述

队列的统一过期

消息单独过期

    <!-- ttl -->
    <rabbit:queue name="test_queue_ttl" id="test_queue_ttl">
        <!--设置queue的参数 -->
        <rabbit:queue-arguments>
            <!-- x-message-ttl 指队列的过期时间（毫秒单位）    注意设置时间长度是integer类型 注意在后面声明数据类型，否则会报错     -->
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>
        </rabbit:queue-arguments>

    </rabbit:queue>

    <rabbit:topic-exchange name="test_exchange_ttl">
        <rabbit:bindings>
            <rabbit:binding pattern="ttl.#" queue="test_queue_ttl"></rabbit:binding>
        </rabbit:bindings>

    </rabbit:topic-exchange>

队列统一过期

消费端发送10条消息

    /**
     *TTL:过期时间
     * 1.队列统一过期
     *
     * 2.消息单独过期
     */
    @Test
    public void testTtl(){

        for (int i=1;i<=10;i++){
            rabbitTemplate.convertAndSend("test_exchange_ttl","ttl","message"+i);
        }
    }
}

在这里插入图片描述

10秒之后，消息自动过期
在这里插入图片描述

消息单独过期

    /**
     *TTL:过期时间
     * 
     * 消息单独过期
     */
    @Test
    public void testTtl(){


        //消息处理对象，设置一些消息的参数信息
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置message的信息，重点在setExpiration 设置该单条消息的过期时间
                message.getMessageProperties().setExpiration("5000");

                //返回该消息
                return message;
            }
        };

        //messagePostProcessor 单个消息的过期时间，需要传入这个对象
        rabbitTemplate.convertAndSend("test_exchange_ttl","ttl","message",messagePostProcessor);


    }
}

在这里插入图片描述

5秒之后该单条消息过期

在这里插入图片描述

两者都设置了的情况

    /**
     *TTL:过期时间
     *
     * 如果设置了消息的过期时间，也设置了队列的过期时间，它以时间短的为准
     * 队列过期后，会将队列所有消息全部移除
     * 消息过期后，只有消息在队列顶端，才会判断其是否过期（移除掉）
     */
    @Test
    public void testTtl(){


        //消息处理对象，设置一些消息的参数信息
        MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
            @Override
            public Message postProcessMessage(Message message) throws AmqpException {
                //设置message的信息，重点在setExpiration 设置该单条消息的过期时间
                message.getMessageProperties().setExpiration("5000");

                //返回该消息
                return message;
            }
        };


        for (int i=1;i<=10;i++){
            if(i==5){

                rabbitTemplate.convertAndSend("test_exchange_ttl","ttl","message",messagePostProcessor);
            }else{

                rabbitTemplate.convertAndSend("test_exchange_ttl","ttl","message");
            }

        }


    }

我们会发现就算过了5秒，其中单独设置的那个消息也没有显示过期，是因为只有消息在队列顶端，才会判断其是否过期（移除掉）

就是当轮到该消息马上要被消费了，才会立马判断过期，然后移除掉
这样做的目的是为了提高效率，省的队列需要不断轮询检查其中的某个消息是否已经过期
在这里插入图片描述

TTL 小结

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

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

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

死信队列

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

在这里插入图片描述

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

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

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

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

队列绑定死信交换机：

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

在这里插入图片描述

    <!--

     死信队列：
        1.声明正常的队列（test_queue_dlx）和交换机（test_exchange_dlx）
        2.声明死信队列（queue_dlx）和死信交换机（exchange_dlx）
        3.正常队列绑定死信交换机
            设置两个参数：
                * x-dead-letter-exchange：死信交换机机名称
                * x-dead-letter-routing-key：发送给死信交换机的routingKey
     -->

    <!--
       1.声明正常的队列（test_queue_dlx）和交换机（test_exchange_dlx）
    -->
    <rabbit:queue name="test_queue_dlx" id="test_queue_dlx">
        <!--    3.正常队列绑定死信交换机 -->
        <rabbit:queue-arguments>
            <!-- 3.1 x-dead-letter-exchange：死信交换机机名称 -->
            <entry key="x-dead-letter-exchange" value="exchange_dlx"></entry>

            <!-- 3.2 x-dead-letter-routing-key：发送给死信交换机的routingKey -->
            <entry key="x-dead-letter-routing-key" value="dlx.haha"></entry>

            <!-- 4.1设置队列的过期时间 ttl-->
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>

            <!-- 4.2 设置队列的长度限制 max-length -->
            <entry key="x-max-length" value="10"  value-type="java.lang.Integer"></entry>

        </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>


    <!--
    2.声明死信队列（queue_dlx）和死信交换机（exchange_dlx）
    -->

    <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.测试过期时间，死信消息

    @Test
    public void testDlx(){
        //1.测试过期时间，死信消息
            rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.hh","我是一条消息，我会变成一条死信吗？？？");

    }

在这里插入图片描述

10秒之后消息过期了，就到死信队列里面去了

在这里插入图片描述

2.测试长度限制后，消息死信

    @Test
    public void testDlx(){
        //2.测试长度限制后，消息死信
        for(int i =0;i<20;i++){

            rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.hh","我是一条消息，我会变成一条死信吗？？？");
        }
    }
}

我们之前设置了队列的最大长度为10 ，所以我在这里一次发送20条消息

我们会将20条消息一发送，就有10条消息立马成为死信，进入死信队列

在这里插入图片描述

然后再过10秒，其他10条也过期了，也成为了死信，进入了死信队列
在这里插入图片描述

测试拒收消息

消费端：

@Component
public class DlxListener implements ChannelAwareMessageListener {


    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        //获取deliveryTag
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //接收转换消息
            System.out.println(new String(message.getBody()));

            //处理业务逻辑 （此处先用简单的打印语句代替）
            System.out.println("处理业务逻辑。。。。");
            int i=1/0; //此添加的一个异常用来测试

            /**手动签收
             * basicAck(long deliveryTag, boolean multiple)
             * 1.deliveryTag 表示收到消息的一个标签
             * 2.multiple 表示是否同时签收多条消息
             */
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            /** 拒绝签收
             *  basicNack(long deliveryTag, boolean multiple, boolean requeue)
             *  第三个参数：requeue 重回队列。如果设置为true，则消息重新回到queue，
             *            broker会重新发送消息给消费端
             */
            System.out.println("出现异常，拒绝签收，并且不把消息重新放回原目标");

            // 将requeue的值设置为false 不把消息重新放回原目标
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

spring-rabbitmq-consumer.xml的配置

        <!--定义监听器，监听正常队列-->
        <rabbit:listener ref="dlxListener" queue-names="test_queue_dlx"></rabbit:listener>

生产者：

    @Test
    public void testDlx(){
        //3.测试消息拒收
            rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.hh","我是一条消息，我会变成一条死信吗？？？");

    }
}

测试：
在这里插入图片描述

出现错误，拒收后，消息成为死信
在这里插入图片描述

死信队列小结

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

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

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

    1. 队列消息长度到达限制；
    2. 消费者拒接消费消息，并且不重回队列；
    3. 原队列存在消息过期设置，消息到达超时时间未被消费；

延迟队列

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

需求：

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

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

实现方式：

  1. 定时器

  2. 延迟队列

在这里插入图片描述

很可惜，在RabbitMQ中并未提供延迟队列功能。

但是可以使用：TTL+死信队列 组合实现延迟队列的效果。

在这里插入图片描述

此处模拟一个业务场景

此处就模拟10秒的订单

spring-rabbitmq-producer.xml 中的相关配置

    <!--
        延迟队列：
            1.定义正常的交换机（order_exchange）和队列（order_queue）
            2.定义死信交换机（order_exchange_dlx）和队列（order_queue_dlx）
            3.绑定，设置正常队列的过期时间
    -->
    <!-- 1.定义正常的交换机（order_exchange）和队列（order_queue）  -->
    <rabbit:queue name="order_queue" id="order_queue">
        <rabbit:queue-arguments>
            <!--    3.正常队列绑定死信交换机 -->

            <!-- 3.1 x-dead-letter-exchange：死信交换机机名称 -->
            <entry key="x-dead-letter-exchange" value="order_exchange_dlx"></entry>

            <!-- 3.2 x-dead-letter-routing-key：发送给死信交换机的routingKey -->
            <entry key="x-dead-letter-routing-key" value="dlx.order.cancel"></entry>

            <!-- 设置过期时间 -->
            <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer"></entry>

        </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>

    <!--  2.定义死信交换机（order_exchange_dlx）和队列（order_queue_dlx） -->
    <rabbit:queue name="order_queue_dlx" id="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 {

        //发送订单消息。将来是在订单系统中，下单成功后，发送消息
        rabbitTemplate.convertAndSend("order_exchange","order.msg","订单信息： id=1001,price=59.80，time="+new Date());

    }

消费者端：

@Component
public class OrderListener implements ChannelAwareMessageListener {


    @Override
    public void onMessage(Message message, Channel channel) throws Exception {

        //获取deliveryTag
        long deliveryTag = message.getMessageProperties().getDeliveryTag();

        try {
            //接收转换消息
            System.out.println(new String(message.getBody()));

            //处理业务逻辑 （此处先用简单的打印语句代替）
            System.out.println("处理业务逻辑。。。。");
            System.out.println("处理订单id查询其状态。。");
            System.out.println("判断状态是否支付成功");
            System.out.println("取消订单，回滚库存");

            /**手动签收
             * basicAck(long deliveryTag, boolean multiple)
             * 1.deliveryTag 表示收到消息的一个标签
             * 2.multiple 表示是否同时签收多条消息
             */
            //手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            /** 拒绝签收
             *  basicNack(long deliveryTag, boolean multiple, boolean requeue)
             *  第三个参数：requeue 重回队列。如果设置为true，则消息重新回到queue，
             *            broker会重新发送消息给消费端
             */
            channel.basicNack(deliveryTag,true,true);
        }
    }
}

spring-rabbitmq-consumer.xml 中的配置

        <!--  延迟队列效果实现： 一定监听的是 死信队列！！！！-->
        <rabbit:listener ref="orderListener" queue-names="order_queue_dlx"></rabbit:listener>

测试：

等待10秒之后
在这里插入图片描述

延迟队列小结

  1. 延迟队列 指消息进入队列后，可以被延迟一定时间，再进行消费。

  2. RabbitMQ没有提供延迟队列功能，但是可以使用 ： TTL + DLX 来实现延迟队列效果。

日志与监控

RabbitMQ日志

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

日志包含了RabbitMQ的版本号、Erlang的版本号、RabbitMQ服务节点名称、cookie的hash值、RabbitMQ配置文件地址、内存限制、磁盘限制、默认账户guest的创建以及权限配置等等。

web管控台监控

rabbitmqctl管理和监控

查看队列 #rabbitmqctl list_queues
查看环境变量 # rabbitmqctl environment

查看exchanges # rabbitmqctl list_exchanges
查看未被确认的队列 # rabbitmqctl list_queues name messages_unacknowledged

查看用户 # rabbitmqctl list_users
查看单个队列的内存使用 # rabbitmqctl list_queues name memory

查看连接 # rabbitmqctl list_connections
查看准备就绪的队列 # rabbitmqctl list_queues name messages_ready

查看消费者信息 # rabbitmqctl list_consumers

消息追踪

在使用任何消息中间件的过程中，难免会出现某条消息异常丢失的情况。对于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命令

我们发现有一个默认的trace交换机
在这里插入图片描述

我们随便弄一个队列
在这里插入图片描述

绑定它们
在这里插入图片描述

在这里插入图片描述

然后我们开启Firehose命令 rabbitmqctl trace_on

在这里插入图片描述

我们在队列中发送一条消息

我们会发现默认的trace也会帮我们发送一条消息，里面记录了详细的信息
在这里插入图片描述

关闭掉这种消息追踪的方式
在这里插入图片描述

消息追踪-rabbitmq_tracing

rabbitmq_tracing和Firehose在实现上如出一辙，只不过rabbitmq_tracing的方式比Firehose多了一层GUI的包装，更容易使用和管理。

启用插件：rabbitmq-plugins enable rabbitmq_tracing

我们平常在控制台只看到三个选项卡
在这里插入图片描述

然后我们通过命令启用rabbitmq_tracing插件

rabbitmq-plugins enable rabbitmq_tracing

在这里插入图片描述

然后我们会在控制台看到多了一个选项卡
在这里插入图片描述

就可以在里面很方便的进行日志的查看和追踪了

关闭该插件的命令

rabbitmq-plugins disable rabbitmq_tracing
Savior.D
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
RabbitMQ高级特性
04-05
RabbitMQ高级特性
rabbitMQ课件.zip
10-26
01RabbitMQ入门篇 02RabbitMQ与Spring_SpringBoot整合 03RabbitMQ高级特性 RabbitMQ安装说明 RabbitMQ集群搭建
服务异步通信 - RabbitMQ的高级特性 - 高级篇相关软件
04-02
服务异步通信 - RabbitMQ的高级特性 - 高级篇相关软件
RabbitMQ高级特性整合SpringBoot注解版入门笔记
hrdate(菜菜菜带带带)
12-02 988
本篇的rabbitmq基本的高级特性整合SpringBoot注解版入门笔记包括：1. 消息的可靠投递 2. Consumer Ack 3. 消费端限流 4. TTL5. 死信队列DLX 6. 延迟队列 7. 日志与监控 8. 消息追踪
rabbitmq的发布确认和事务
weixin_34409741的博客
05-06 391
2019独角兽企业重金招聘Python工程师标准>>> ...
RabbitMQ高级特性(消息可靠性投递 ACK TTL+死信队列 延迟队列 日志与监控 消息可靠性分析与追踪 消息可靠性保障 消息幂等性处理)
m0_46690280的博客
09-20 510
RabbitMQ高级特性RabbitMQ一、RabbitMQ高级特性1.1 消息可靠性投递搭建consumerproviderconfirmCallback 确认模式return 退回模式1.2Consumer ACK1.3 消费端限流1.4 TTL1.5 死信队列1.6 延迟队列1.7 日志与监控1.8 消息可靠性分析与追踪二、RabbitMQ应用问题2.1 消息可靠性保障2.2 消息幂等性处理 RabbitMQ 一、RabbitMQ高级特性 1.1 消息可靠性投递 在使用 RabbitMQ 的时候，作为
(14)RabbitMQ与Spring的整合使用
没头脑遇到不高兴
04-25 1423
本节将会介绍一下RabbitMQ与Spring的整合使用：spring-amqp和spring-rabbit，RabbitTemplate、MessageListener的使用介绍，如何发送消息，如何接收消息，如何设置消费者ack确认，如何添加confirm和return回调。。。。。。 概述 从事Java开发的小伙伴一般都离不了Spring框架吧，本节就介绍一下RabbitMQ与Spring...
RabbitMQ工作模式及高级特性
业精于勤，荒于嬉
06-06 393
一、MQ 基本概念 MQ全称 Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式应用各个系统之间的通信。 优势 异步提速 例如用户在订单系统下订单，订单系统调用库存系统进行减库存操作。如果是同步通信，那么从用户下单(100ms)到更新库存(300ms)，整个流程的处理时间大概是400ms。 但如果是异步通信，那么用户下单(100ms)信息发送给MQ(10ms)之后直接给用户响应，库存系统从MQ中获取相关订单信息进行更新库存的操作，那么整个流程的处理时间大概是110ms
(16)RabbitMQ与Spring、SpringBoot整合时的坑及注意点
没头脑遇到不高兴
05-06 7492
一：消费者报错 消费者出现ERROR日志：Channel shutdown: channel error; protocol method: #method<channel.close>(reply-code=406, reply-text=PRECONDITION_FAILED - unknown delivery tag 1, class-id=60, method-id=80)...
SpringMVC + RabbitMQ实战（XML配置rabbit，监听多条队列）
Jake Weng
01-08 8968
123
RabbitMQ实战
09-19
AMQP(高级消息队列协议) 是一个异步消息传递所使用的应用层协议规范，作为线路层协议，而不是API（例如JMS），AMQP 客户端能够无视消息的来源任意发送和接受信息。AMQP的原始用途只是为金融界提供一个可以彼此协作的...
Java开发面试-RabbitMQ专区
10-28
此外，面试官还可能会询问关于RabbitMQ的高级特性，例如如何实现消息的持久化、如何实现消息的路由、如何实现消息的过期和死信等。对于这些问题，开发者需要深入了解RabbitMQ的内部机制和API，以及如何使用这些特性...
RabbitMQ @RabbitListener注解和使用
热门推荐
华棋皓
07-30 3万+
<beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:rabbit="http://www.springframework.org/schema/rabbit" xsi:schemaLocation="ht...
SpringBoot整合RabbitMQ高级特性
weixin_45962477的博客
02-16 792
持久化exchange要持久化queue要持久化message要持久化生产方确认Confirm消费方确认AckBroker高可用RabbitMQ默认日志存放路径： /var/log/rabbitmq/没有权限在命令前面加上sudo日志包含了RabbitMQ的版本号、Erlang的版本号、RabbitMQ服务节点名称、cookie的hash值、RabbitMQ配置文件地址、内存限制、磁盘限制、默认账户guest的创建以及权限配置等等。
【RabbitMQ消息中间件】10.Spring-Rabbit项目剖析
程序猿之洞
03-18 2874
之前我们详细介绍了RabbitMQ并且讲解了其5中队列模式，在期间编写了许多小例子。但是在真实的开发阶段，我们很少使用之前编写Demo时的编写方式，一个是不方便，一个是难以维护。所以，在企业级的开发中，一般是结合框架来进行开发的。一、spring-rabbit项目介绍在Java开发中，RabbitMQ的开发自然少不了与Spring框架的结合。本篇我们就来了解一下，Spring为我们提供的与Rabb...
RabbitMQ
qq_35274666的博客
08-09 125
RabbitMQ: Server: 又称Broker,接受客户端的连接，实现AMQP实体服务。 Connection: 连接，应用程序与Broker 的网络连接TCP/IP 三次握手，四次挥手。 Channel: 网络信道，几乎所有的操作都在Channel 中进行，Channel进行消息读写，客户端可以建立多个Channel,每个Channel 代表一个会话任务。 Message: 消息，服务与应用程序之间传送数据，由Properties 和Body组成，Properties可对消息进行修饰，比如消息的优
rabbitmq整合springboot:ChannelAwareMessageListener和@RabbitListener的使用
qq_41358574的博客
01-26 2849
rabbitmq两种监听器的写法
重温Rabbitmq消息中间件
法号钦尘的博客
12-21 135
MQ的基本概念 全称（...
rabbitMQ本地启动快捷方式
最新发布
kangweiwu的博客
05-20 313
【代码】rabbitMQ本地启动快捷方式。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值