rabbitmq的高级部分

producer的XML配置

 <?xml version="1.0" encoding="UTF-8"?>
   <beans xmlns="http://www.springframework.org/schema/beans"
   xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
   xmlns:context="http://www.springframework.org/schema/context"
   xmlns:rabbit="http://www.springframework.org/schema/rabbit"
   xsi:schemaLocation="http://www.springframework.org/schema/beans
   http://www.springframework.org/schema/beans/spring-beans.xsd
   http://www.springframework.org/schema/context
   https://www.springframework.org/schema/context/spring-context.xsd
   http://www.springframework.org/schema/rabbit
   http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
<!--加载配置文件-->
<context:property-placeholder location="classpath:rabbitmq.properties"/>

<!-- 定义rabbitmq connectionFactory -->
<rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                           port="${rabbitmq.port}"
                           username="${rabbitmq.username}"
                           password="${rabbitmq.password}"
                           virtual-host="${rabbitmq.virtual-host}"
                           publisher-confirms="true"
                           publisher-returns="true"
/>
<!--定义管理交换机、队列-->
<rabbit:admin connection-factory="connectionFactory"/>

<!--定义rabbitTemplate对象操作可以在代码中方便发送消息-->
<rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>

<!--消息可靠性投递（生产端）-->
<rabbit:queue id="test_queue_confirm" name="test_queue_confirm"></rabbit:queue>
<rabbit:direct-exchange name="test_exchange_confirm">
    <rabbit:bindings>
        <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
    </rabbit:bindings>
</rabbit:direct-exchange>

<!--ttl-->
<rabbit:queue name="test_queue_ttl" id="test_queue_ttl">
    <!--设置queue的参数-->
    <rabbit:queue-arguments>
        <!--x-message-ttl指队列的过期时间-->
        <entry key="x-message-ttl" value="100000" 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>

<!--
    死信队列：
        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" />

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

        <!--4.1 设置队列的过期时间 ttl-->
        <entry key="x-message-ttl" value="10000" value-type="java.lang.Integer" />
        <!--4.2 设置队列的长度限制 max-length -->
        <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>

  <!--
     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. 定义正常交换机（order_exchange）和队列(order_queue)
        2. 定义死信交换机（order_exchange_dlx）和队列(order_queue_dlx)
        3. 绑定，设置正常队列过期时间为30分钟
-->
<!-- 1. 定义正常交换机（order_exchange）和队列(order_queue)-->
<rabbit:queue id="order_queue" name="order_queue">
    <!-- 3. 绑定，设置正常队列过期时间为30分钟-->
    <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>

<!--  2. 定义死信交换机（order_exchange_dlx）和队列(order_queue_dlx)-->
<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>

1.1 消息的可靠投递

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

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

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

                @Autowired
                private RabbitTemplate rabbitTemplate;

                /**
                 * 确认模式：
                 * 步骤：
                 * 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....");
                      }

                         /**
                          * 回退模式： 当消息发送给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....");
                              }

cosumer的XML配置

        <?xml version="1.0" encoding="UTF-8"?>
        <beans xmlns="http://www.springframework.org/schema/beans"
        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns:context="http://www.springframework.org/schema/context"
        xmlns:rabbit="http://www.springframework.org/schema/rabbit"
        xsi:schemaLocation="http://www.springframework.org/schema/beans
        http://www.springframework.org/schema/beans/spring-beans.xsd
        http://www.springframework.org/schema/context
        https://www.springframework.org/schema/context/spring-context.xsd
        http://www.springframework.org/schema/rabbit
        http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
        <!--加载配置文件-->
        <context:property-placeholder location="classpath:rabbitmq.properties"/>

        <!-- 定义rabbitmq connectionFactory -->
        <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
                           port="${rabbitmq.port}"
                           username="${rabbitmq.username}"
                           password="${rabbitmq.password}"
                           virtual-host="${rabbitmq.virtual-host}"/>

        <context:component-scan base-package="com.itheima.listener" />

        <!--定义监听器容器-->
        <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1" >
        <!-- <rabbit:listener ref="ackListener" queue-names="test_queue_confirm"></rabbit:listener>-->
        <!-- <rabbit:listener ref="qosListener" queue-names="test_queue_confirm"></rabbit:listener>-->
        <!--定义监听器，监听正常队列-->
        <!--<rabbit:listener ref="dlxListener" queue-names="test_queue_dlx"></rabbit:listener>-->

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

1.2 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 {
                                    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.3 消息可靠性总结

        持久化
            exchange要持久化
            queue要持久化
            message要持久化
        生产方确认Confirm
        消费方确认Ack
        Broker高可用

1.4 消费端限流

        /**
         * 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);

                 }
         }

1.4 TTL

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

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

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

        /**
         * 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);

              }

1.5 死信队列

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

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

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

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

          @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);
                      }
                }

            }

1.6 延迟队列

   1. 延迟队列 指消息进入队列后，可以被延迟一定时间，再进行消费。
   2. RabbitMQ没有提供延迟队列功能，但是可以使用 ： TTL + DLX 来实现延迟队列效果

1.7 消息追踪

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

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

      a、消息追踪-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命令

      b、消息追踪-rabbitmq_tracing

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