RabbitMQ 死信队列

转载：RabbitMQ 安装、原理解释

学习源码地址：https://gitee.com/an-katg/Supervene

死信队列

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

• 死信队列模型

• 成为死信队列的三种情况

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

1、代码配置

• 引入依赖。生产者和消费者一样

   <dependencies>
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-context</artifactId>
              <version>5.3.6</version>
          </dependency>
   
          <dependency>
              <groupId>org.springframework.amqp</groupId>
              <artifactId>spring-rabbit</artifactId>
              <version>2.2.6.RELEASE</version>
          </dependency>
   
          <dependency>
              <groupId>org.springframework</groupId>
              <artifactId>spring-test</artifactId>
              <version>5.3.17</version>
          </dependency>
   
          <dependency>
              <groupId>junit</groupId>
              <artifactId>junit</artifactId>
              <version>4.13</version>
              <scope>test</scope>
          </dependency>
      </dependencies>

1.1、生产端

• 目录结构

• spring-rabbitmq.xml 配置

  <!--死信队列配置  -->
          <!--正常队列：在向死信交换机发送消息时，想当与一个生产者，需要指定交换机和路由-->
      <rabbit:queue name="test_queue_dlx" id="test_queue_dlx">
          <rabbit:queue-arguments>
              <!--配置死信交换机-->
              <entry key="x-dead-letter-exchange" value="exchange_dlx"/>
              <!--配置路由（使用的使 topic 模式的交换机）-->
              <entry key="x-dead-letter-routing-key" value="dlx.haha"/>
              <!--配置队列 TTL 时间-->
              <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" id="test_exchange_dlx">
          <rabbit:bindings>
              <rabbit:binding pattern="test.dlx.#" queue="test_queue_dlx"/>
          </rabbit:bindings>
      </rabbit:topic-exchange>
   
   
          <!--死信队列-->
      <rabbit:queue id="queue_dlx" name="queue_dlx"/>
          <!--死信交换机-->
      <rabbit:topic-exchange name="exchange_dlx" id="exchange_dlx">
          <rabbit:bindings>
              <rabbit:binding pattern="dlx.#" queue="queue_dlx"/>
          </rabbit:bindings>
      </rabbit:topic-exchange>

• proTest.java : 配置三种消息进入死信队列的情况。对于前两种先不启动消费者，使消息超时或者队列中的消息个数超出对队列长度

      /*死信交换机*/
      @Test
      public void testDlx(){
  //        1、发动超时消息
          rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","hello dlx message");
   
          //2、发送超过队列长度的消息
          for (int i = 0; i < 15; i++) {
              rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","hello dlx message");
          }
   
          //3、消息拒收。开启消费者，但是监听里面有 exception  requeue 设置为false 就好了。
          rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.haha","hello dlx message");
      }

1、超出时间：

• 十秒之前在正常队列里面：

• 十秒之后进入死信队列：

2、消息个数超出队列长度

• 超出队列长度的5个直接进入死信队列

• 其余消息在达到 队列的 ttl 之后进入死信队列

3、消息发出后被拒收

• 设置消费者

• 配置 spring-rabbitmq.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"
      />
      <!--设置扫描listen 包-->
      <context:component-scan base-package="com.kkb.listener"/>
     <!--设置手动监听  manual(设置手动确认)   prefetch 表示每次取出消息的个数-->
      <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
  <!--        <rabbit:listener ref="ackListen" queue-names="test_queue_confirm"/>-->
   
          <!--限流对列 配合 prefetch 使用-->
  <!--        <rabbit:listener ref="qosListener" queue-names="test_queue_confirm"/>-->
   
          <!--死信监听器    监听的队列是会产生死信的队列-->
          <rabbit:listener ref="dlxListener" queue-names="test_queue_dlx"/>
  <!--        <rabbit:listener ref="dlxListener" queue-names="queue_dlx"/>-->
      </rabbit:listener-container>
  </beans>

• 配置监听器 DlxListener.java

  @Component
  public class DlxListener implements ChannelAwareMessageListener {
      @Override
      public void onMessage(Message message, Channel channel) throws Exception {
          try{
              throw new Exception();
          }catch(Exception e){
              System.out.println("出现异常，拒收-----------");
              System.out.println(new String(message.getBody(),"utf-8"));
              channel.basicNack(message.getMessageProperties().getDeliveryTag(),true,false);
          }
      }
  }

• 消费者：consumerTest.java

  @RunWith(SpringJUnit4ClassRunner.class)
  @ContextConfiguration(locations = {"classpath:/spring-rabbitmq.xml"})
  public class consumerTest {
      @Test
      public void test(){
   
          while(true){
   
          }
      }
  }

• 开启消费者，再开启生产者。在收到消息之后，直接就处理进入死信队列