RabbitMQ高级之消息可靠性投递

什么是可靠性投递？

生产者：作为消息发送方希望杜绝任何消息丢失或者投递失败场景。

RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式。

分别是：

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

消息投递路线

如下所示是生产者到消费者的模型：

RabbitMQ的整个消息投递的路径

Producer--->RabbitMQ Broker(Server)--->Exchange--->Queue--->Consumer

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

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

确认模式

消息从 producer 到 exchange 则会返回一个 confirmCallback ，不论消息是否成功到达exchange ，回调都会执行，只不过返回的bool类型的值是true or false的区别。

代码实现很简单，两步即可

步骤

（1）在XML配置文件中设置 ConnectionFactory 开启 publisher-confirms="true"

（2）在 rabbitTemplate 定义 ConfirmCallBack() 回调函数

代码实现 

spring-rabbitmq-producer.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  6.        xmlns:rabb="http://www.springframework.org/schema/rabbit"
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  8.        http://www.springframework.org/schema/beans/spring-beans.xsd
  9.        http://www.springframework.org/schema/context
  10.        https://www.springframework.org/schema/context/spring-context.xsd
  11.        http://www.springframework.org/schema/rabbit
  12.        http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
  13.  
  14.     <!-- 1.加载配置文件-->
  15.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  16.  
  17.     <!-- 2.定义rabbitmq connectionFactory -->
  18.     <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
  19.                                port="${rabbitmq.port}"
  20.                                username="${rabbitmq.username}"
  21.                                password="${rabbitmq.password}"
  22.                                virtual-host="${rabbitmq.virtual-host}"
  23.                                
  24.                                publisher-confirms="true"/>
  25.     <!-- publisher-confirms="true" 确认模式开启！！！ -->
  26.  
  27.     <!-- 3.定义管理交换机、队列-->
  28.     <rabbit:admin connection-factory="connectionFactory"/>
  29.  
  30.     <!-- 消息的可靠性投递 -->
  31.     <rabbit:queue id="test_queue_confirm" name="test_queue_confirm"></rabbit:queue>
  32.     <rabbit:direct-exchange name="test_exchange_confirm">
  33.         <rabbit:bindings>
  34.             <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
  35.         </rabbit:bindings>
  36.     </rabbit:direct-exchange>
  37.  
  38.     <!-- 定义rabbitTemplate对象操作可以在代码中方便发送消息-->
  39.     <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
  40.  
  41. </beans>

ProducerTest

  1. package com.Harmony;
  2.  
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.amqp.core.Message;
  6. import org.springframework.amqp.rabbit.connection.CorrelationData;
  7. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.test.context.ContextConfiguration;
  10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  11.  
  12. @RunWith(SpringJUnit4ClassRunner.class)
  13. @ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
  14. public class ProducerTest {
  15.     /**
  16.      *   确认模式
  17.      *   开启：
  18.      *   1. ConnectionFactory 中开启 publisher-confirms="true"
  19.      *   2. 在 rabbitTemplate 定义 ConfirmCallBack() 回调函数
  20.      */
  21.     @Autowired
  22.     private RabbitTemplate rabbitTemplate;
  23.     // 2. 定义回调
  24.  
  25.     // 一、确认模式
  26.     @Test
  27.     public void testConfirm() throws InterruptedException {
  28.         rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
  29.             /**
  30.              *
  31.              * @param correlationData: 配置信息，在convertAndSend()中的重载方法有该参数
  32.              * @param ack: 代表exchange交换机是否收到了信息，true为成功，false为失败
  33.              * @param cause: 失败原因; 如果成功为null
  34.              */
  35.             @Override
  36.             public void confirm(CorrelationData correlationData, boolean ack, String cause) {
  37.                 System.out.println(ack);
  38.                 System.out.println("confirm方法被执行了......");
  39.                 if (ack) {
  40.                     System.out.println("接收成功：" + cause);
  41.                 } else {
  42.                     System.out.println("接收失败：" + cause);
  43.                     // 以后可能会做一些处理
  44.                 }
  45.             }
  46.         });
  47.         // 3. 发送消息
  48.         rabbitTemplate.convertAndSend("test_exchange_confirm","confirm","message confirm......");
  49.         // 由于在测试种，执行结束线程直接没有了！
  50.         Thread.sleep(2000);
  51.     }
  52.    
  53. }

退回模式

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

步骤

（1）开启回退模式 publisher-returns="true"

（2）设置ReturnCallback

（3）设置Exchange处理消息的模式：

        如果消息没有路由到Queue，则会丢弃消息（默认）

        如果消息没有路由到Queue，返回给消息发送方

代码实现

spring-rabbitmq-producer.xml

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <beans xmlns="http://www.springframework.org/schema/beans"
  3.        xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  4.        xmlns:context="http://www.springframework.org/schema/context"
  5.        xmlns:rabbit="http://www.springframework.org/schema/rabbit"
  6.        xmlns:rabb="http://www.springframework.org/schema/rabbit"
  7.        xsi:schemaLocation="http://www.springframework.org/schema/beans
  8.        http://www.springframework.org/schema/beans/spring-beans.xsd
  9.        http://www.springframework.org/schema/context
  10.        https://www.springframework.org/schema/context/spring-context.xsd
  11.        http://www.springframework.org/schema/rabbit
  12.        http://www.springframework.org/schema/rabbit/spring-rabbit.xsd">
  13.  
  14.     <!-- 1.加载配置文件-->
  15.     <context:property-placeholder location="classpath:rabbitmq.properties"/>
  16.  
  17.     <!-- 2.定义rabbitmq connectionFactory -->
  18.     <rabbit:connection-factory id="connectionFactory" host="${rabbitmq.host}"
  19.                                port="${rabbitmq.port}"
  20.                                username="${rabbitmq.username}"
  21.                                password="${rabbitmq.password}"
  22.                                virtual-host="${rabbitmq.virtual-host}"
  23.  
  24.                                publisher-returns="true" />
  25.     <!-- publisher-returns="true" 回退模式开启！！！ -->
  26.  
  27.     <!-- 3.定义管理交换机、队列-->
  28.     <rabbit:admin connection-factory="connectionFactory"/>
  29.  
  30.     <!-- 消息的可靠性投递 -->
  31.     <rabbit:queue id="test_queue_confirm" name="test_queue_confirm"></rabbit:queue>
  32.     <rabbit:direct-exchange name="test_exchange_confirm">
  33.         <rabbit:bindings>
  34.             <rabbit:binding queue="test_queue_confirm" key="confirm"></rabbit:binding>
  35.         </rabbit:bindings>
  36.     </rabbit:direct-exchange>
  37.  
  38.     <!-- 定义rabbitTemplate对象操作可以在代码中方便发送消息-->
  39.     <rabbit:template id="rabbitTemplate" connection-factory="connectionFactory"/>
  40.  
  41. </beans>

ProducerTest

  1. package com.Harmony;
  2.  
  3. import org.junit.Test;
  4. import org.junit.runner.RunWith;
  5. import org.springframework.amqp.core.Message;
  6. import org.springframework.amqp.rabbit.connection.CorrelationData;
  7. import org.springframework.amqp.rabbit.core.RabbitTemplate;
  8. import org.springframework.beans.factory.annotation.Autowired;
  9. import org.springframework.test.context.ContextConfiguration;
  10. import org.springframework.test.context.junit4.SpringJUnit4ClassRunner;
  11.  
  12. @RunWith(SpringJUnit4ClassRunner.class)
  13. @ContextConfiguration(locations = "classpath:spring-rabbitmq-producer.xml")
  14. public class ProducerTest {
  15.  
  16.     @Autowired
  17.     private RabbitTemplate rabbitTemplate;
  18.  
  19.     @Test
  20.     public void testReturn() throws InterruptedException {
  21.         // 设置交换机处理失败消息的模式
  22.         // 生产者可以拿到之前发送失败的消息
  23.         rabbitTemplate.setMandatory(true);
  24.  
  25.         rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
  26.             /**
  27.              *
  28.              * @param message: 消息对象
  29.              * @param replyCode: 错误码
  30.              * @param replyText: 错误信息
  31.              * @param exchange: 交换机
  32.              * @param routingKey: 路由键
  33.              */
  34.             @Override
  35.             public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
  36.                 System.out.println("return 执行了...");
  37.                 System.out.println(message);
  38.                 System.out.println(replyCode);
  39.                 System.out.println(replyText);
  40.                 System.out.println(exchange);
  41.                 System.out.println(routingKey);
  42.             }
  43.         });
  44.         // 3. 发送消息
  45.         rabbitTemplate.convertAndSend("test_exchange_confirm","confirm","message confirm......");
  46.         Thread.sleep(2000);
  47.     }
  48.  
  49. }

总述

➢ 设置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(),用于回滚事务

文章知识点与官方知识档案匹配，可进一步学习相关知识
Java技能树首页概览120777 人正在系统学习中
posted @ 2023-06-20 14:15  离人怎挽_wdj  阅读(28)  评论(0)  编辑  收藏  举报