RabbitMQ -高级特性

2024-02-26 07:52:03

RabbitMQ - 高级特性

1. 高级特性

1.1 消息的可靠投递

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

confirm - 确认模式
return - 退回模式

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

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

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

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

1.1.1 确认模式

配置文件

<?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
       http://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:properties/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:direct-exchange name="test_exchange_confirm">
        <rabbit:bindings>
            <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>
</beans>

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

/**
 * 生产者
 *
 * @author murphy
 */
@RunWith(SpringJUnit4ClassRunner.class)
@ContextConfiguration(locations = "classpath:/spring/spring-rabbitmq.xml")
public class ProducerTest {

    @Autowired
    private RabbitTemplate rabbitTemplate;

    /**
     * 消息可靠性投递
     * 确认模式
     *      1. 确认模式开启：ConnectionFactory中开启publisher-confirms="true"
     *      2. 在rabbitTemplate定义ConfirmCallBack回调函数
     */
    @Test
    public void testConfirm() {
        // 定义回调
        rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
            /**
             * @param correlationData 相关配置信息
             * @param ack exchange交换机 是否成功收到了消息。true 成功，false代表失败
             * @param cause 失败原因
             */
            public void confirm(CorrelationData correlationData, boolean ack, String cause) {
                System.out.println("Do Confirm.");
                if (ack) {
                    // 接收成功
                    System.out.println("Receiving Successful! " + cause);
                } else {
                    // 接收失败
                    System.out.println("Failed! " + cause);
                    // 业务处理 - 重发消息...
                }
            }
        });
        // 3. 发送消息
      	// - 失败案例 - 消息无法发送
        rabbitTemplate.convertAndSend("test_exchange_confirm1","confirm","Message Confirm.");
      	// - 成功案例
      	rabbitTemplate.convertAndSend("test_exchange_confirm","confirm","Message Confirm.");
    }
}

1.1.2 退回模式

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

/**
 * 回退模式: 当消息发送给Exchange后，Exchange路由到Queue失败是 才会执行 ReturnCallBack
 * 步骤：
 *      1. 开启回退模式:publisher-returns="true"
 *      2. 设置ReturnCallBack
 *      3. 设置Exchange处理消息失败的模式:setMandatory
 *
 * 如果消息没有路由到Queue，则丢弃消息(默认)
 * 如果消息没有路由到Queue，返回给消息发送方ReturnCallBack
 */
@Test
public void testReturn() {
    // 设置交换机处理失败消息的模式 - false则直接丢弃消息，不进入回调 / true进入回调函数
    rabbitTemplate.setMandatory(true);
    // 2.设置ReturnCallBack
    rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
        /**
         *
         * @param message - 消息对象
         * @param replyCode - 错误码
         * @param replyText - 错误信息
         * @param exchange - 交换机
         * @param routingKey - 路由键
         */
        public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
            System.out.println("Do ...");

            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 - Wrong","Message Confirm.");
}

1.2 Consumer Ack

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

自动确认：acknowledge="none"
手动确认：acknowledge="manual"
根据异常情况确认：acknowledge="auto" (这种方式使用麻烦，不作讲解)

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

配置文件

<?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
       http://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:properties/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.murphy.listener"/>

    <!-- 监听器 -->
    <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual">
        <rabbit:listener ref="ackListener" queue-names="test_queue_confirm"></rabbit:listener>
    </rabbit:listener-container>
</beans>

AckListener

/**
 * 消费端 - 收到消息的确认方式
 *
 * @author murphy
 * @since 2021/9/12 3:30 下午
 */
@Component
public class AckListener implements ChannelAwareMessageListener {

    public void onMessage(Message message, Channel channel) throws Exception {
        long deliverTag = message.getMessageProperties().getDeliveryTag();
        try {
            // 1. 接收转换消息
            System.out.println(new String(message.getBody()));
            // 2. 处理业务逻辑
            System.out.println("- 处理业务逻辑 -");
            // 模拟业务处理异常
            int i = 3/0;
            // 3. 手动签收
            channel.basicAck(deliverTag,true);

        } catch (Exception e) {
            e.printStackTrace();
            // 4. 拒绝签收 - requeue：true - 如果设置为true，则消息重新回到queue，broker会重新发送该消息给消费端
            channel.basicNack(deliverTag,true,true);
            channel.basicReject(deliverTag,true);
        }
    }

    public void onMessage(Message message) {

    }
}

1.3 消费端限流

配置文件

<?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
       http://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:properties/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.murphy.listener"/>

    <!-- 监听器 -->
    <rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
        <rabbit:listener ref="qsListener" queue-names="test_queue_confirm"></rabbit:listener>
    </rabbit:listener-container>
</beans>

Consumer 限流机制

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

1.4 TTL - Time To Live

TTL：消息过期时间设置

管控台设置队列TTL

管控台创建交换机

绑定交换机

模拟发送消息 - 存在时间仅10S

1.4.1 代码实现

配置文件

<?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
       http://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:properties/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}" />
    <!-- 定义管理交换机、队列 -->
    <rabbit:admin connection-factory="connectionFactory"/>

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

    <!-- TTL -->
    <rabbit:queue name="test_queue_ttl" id="test_queue_ttl">
        <rabbit:queue-arguments>
            <entry key="x-message-ttl" value="100000" value-type="java.lang.Integer"></entry>
        </rabbit:queue-arguments>
    </rabbit:queue>
    
    <rabbit:topic-exchange id="test_exchange_ttl" name="test_exchange_ttl">
        <rabbit:bindings>
            <rabbit:binding pattern="ttl.#" queue="test_queue_ttl"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:topic-exchange>
</beans>

测试实现

/**
 * TTL：过期时间
 * 1. 队列统一过期
 * 2. 消息单独过期
 * 
 * 如果设置了消息的过期时间，也设置了队列的过期时间，它以时间短的为准。
 * 队列过期后，会将队列所有消息全部移除。
 * 消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉)
 */
@Test
public void testTTL() {
//        for (int i=0; i<10; i++) {
//            // 发送消息
//            rabbitTemplate.convertAndSend("test_exchange_ttl","ttl.murphy","Message TTL." + (i+1));
//        }

    // 消息后处理对象，设置一些消息的参数信息
    MessagePostProcessor messagePostProcessor = new MessagePostProcessor() {
        public Message postProcessMessage(Message message) throws AmqpException {
            // 1. 设置message的信息
            // 消息的过期时间
            message.getMessageProperties().setExpiration("5000");
            // 2. 返回该消息
            return message;
        }
    };

//        // 消息的单独过期
//        rabbitTemplate.convertAndSend("test_exchange_ttl","ttl.murphy",
//                "Message TTL.", messagePostProcessor);

    for (int i = 0; i < 10; i++) {
        if (i == 5) {
            // 消息单独过期 - 消息过期后，只有消息在队列顶端，才会判断其是否过期(移除掉) - 因此下述设置无效
            rabbitTemplate.convertAndSend("test_exchange_ttl","ttl.murphy","Message TTL.", messagePostProcessor);
        } else {
            // 不过期的消息
            rabbitTemplate.convertAndSend("test_exchange_ttl","ttl.murphy","Message TTL." + (i+1));
        }
    }

}

1.5 死信队列

死信队列(DLX) 。Dead Letter Exchange(死信交换机)，当消息成为Dead Message后，可以被重新发送到另一个交换机，这个交换机就是DLX。

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

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

队列绑定死信交换机：

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

管控台实现

设置死信队列 - queue_dlx

设置死信交换机 - exchange_dlx

死信绑定

设置正常队列 - test_queue_dlx

设置正常交换机 - test_exchange_dlx

绑定正常队列

发送正常消息 - 10秒后成为死信 - 通过死信交换机进入死信队列

死信进入死信队列

代码实现

配置文件

<?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
       http://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:properties/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:direct-exchange name="test_exchange_confirm">
        <rabbit:bindings>
            <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-exchange>

    <!-- 1. 声明正常的队列(test_queue_dlx)和交换机(test_exchange_dlx) -->
    <rabbit:queue id="test_queue_dlx" name="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:发送给死信交换机的routing key -->
            <entry key="x-dead-letter-routing-key" value="dlx.murphy"/>
            <!-- 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:bindings>
    </rabbit:topic-exchange>

    <!-- 2. 声明死信队列(queue_dlx)和死信交换机(exchange_dlx) -->
    <rabbit:queue id="queue_dlx" name="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>
</beans>

测试代码

生产端测试

/**
 * 发送测试死信消息：
 *      1. 过期时间
 *      2. 长度限制
 *      3. 消息拒收
 */
@Test
public void testDlx() {
    // 1. 测试过期时间，死信消息
    rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.murphy",
            "Dead Letter - TTL");

    // 2. 测试长度限制后，消息死信
    for (int i=0; i<20; i++) {
        rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.murphy",
                "Dead Letter - OutOfLength - " + (i+1));
    }

    // 3. 测试消息拒收
    rabbitTemplate.convertAndSend("test_exchange_dlx","test.dlx.murphy",
            "Dead Letter - Reject");
}

消息端监听器

/**
 * 死信监听
 *
 * @author murphy
 */
@Component
public class DlxListener implements ChannelAwareMessageListener {
    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("Do..");
            // 出现错误
            int i = 3 / 0;
            // 3. 手动签收
            channel.basicAck(deliveryTag,true);
        } catch (Exception e) {
            System.out.println("出现异常，拒绝接收！");
            // 4. 拒绝签收，不重回队列 - requeue=false
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

// 监听器注册
<!-- 监听器 -->
<rabbit:listener-container connection-factory="connectionFactory">
    <rabbit:listener ref="dlxListener" queue-names="test_queue_dlx"></rabbit:listener>
</rabbit:listener-container>

运行结果

1.6 延迟队列

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

需求：

下单后，30分钟未支付，取消订单，回滚库存。
新用户注册成功 7 天后，发送短信问候。

实现方式：

定时器
延迟队列

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

代码实现

配置文件

<?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
       http://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:properties/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:direct-exchange name="test_exchange_confirm">
        <rabbit:bindings>
            <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
        </rabbit:bindings>
    </rabbit:direct-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>
</beans>

消费端监听

/**
 * 订单系统监听 - 案例30分钟
 *
 * @author murphy
 */
@Component
public class OrderListener implements ChannelAwareMessageListener {

    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) {
            System.out.println("出现异常，拒绝签收！");
            // 4. 拒绝签收，不重回队列 requeue=false
            channel.basicNack(deliveryTag,true,false);
        }
    }
}

注册监听器

<!-- 监听器：在消费者配置文件中注册监听器 -->
<rabbit:listener-container connection-factory="connectionFactory" acknowledge="manual" prefetch="1">
    <rabbit:listener ref="orderListener" queue-names="order_queue_dlx"></rabbit:listener>
</rabbit:listener-container>

生产者端测试

@Test
public void testDelay() throws InterruptedException {
    // 1. 发送订单消息。 将来是在订单系统中，下单成功后，发送消息
    SimpleDateFormat sdf = new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
    rabbitTemplate.convertAndSend("order_exchange", "order.msg",
            "订单信息：ID=91231，Time=" + sdf.format(new Date()));
    // 2. 打印倒计时 10s
    for (int i = 0; i < 10; i++) {
        System.out.println((i+1) + "...");
        Thread.sleep(1000);
    }
}

运行结果 - 10秒后判断订单状态，若没有被消费，则取消订单，进行相关业务处理

码农公寓

RabbitMQ -高级特性

RabbitMQ - 高级特性

目录

1. 高级特性

1.1 消息的可靠投递

1.1.1 确认模式

1.1.2 退回模式

1.2 Consumer Ack

1.3 消费端限流

1.4 TTL - Time To Live

1.4.1 代码实现

1.5 死信队列

1.6 延迟队列

码农公寓

RabbitMQ - 高级特性

目录

1. 高级特性

1.1 消息的可靠投递

1.1.1 确认模式

1.1.2 退回模式

1.2 Consumer Ack

1.3 消费端限流

1.4 TTL - Time To Live

1.4.1 代码实现

1.5 死信队列

1.6 延迟队列

相关文章