RabbitMQ（三）-- 消息可靠性
RabbitMQ消息的可靠性投递主要两种实现：
1、通过实现消费的重试机制，通过@Retryable来实现重试，可以设置重试次数和重试频率；
2、生产端实现消息可靠性投递。
两种方法消费端都可能收到重复消息，要求消费端必须实现幂等性消费。
消息的可靠投递
生产端
在使用 RabbitMQ 的时候，作为消息发送方希望杜绝任何消息丢失或者投递失败场景。RabbitMQ 为我们提供了两种方式用来控制消息的投递可靠性模式
-
confirm 确认模式
-
return 退回模式
消息投递到exchange的确认模式
rabbitmq的消息投递的过程为：
producer ——> rabbitmq broker cluster ——> exchange ——> queue ——> consumer
-
生产端发送消息到rabbitmq broker cluster后，异步接受从rabbitmq返回的ack确认信息
-
生产端收到返回的ack确认消息后，根据ack是true还是false，调用confirmCallback接口进行处理
1、改yml
spring:
#rabbitmq 连接配置
rabbitmq:
publisher-confirm-type: correlated # 开启confirm确认模式
2、实现confirm方法
实现ConfirmCallback接口中的confirm方法，消息只要被 rabbitmq broker接收到就会触ConfirmCallback 回调，ack为true表示消息发送成功，ack为false表示消息发送失败
package com.rabbitmq.config;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.stereotype.Component;
/*** 实现ConfirmCallback接口 */
@Component
public class ConfirmCallbackService implements RabbitTemplate.ConfirmCallback {
/**
* @param correlationData 相关配置信息
* @param ack exchange交换机 是否成功收到了消息。true 成功，false代表失败
* @param cause 失败原因
*/
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
if (ack) {
//接收成功
System.out.println("成功发送到交换机<===>");
} else {
//接收失败
System.out.println("失败原因:===>" + cause);
//TODO 做一些处理:消息再次发送等等
}
}
}
3、测试
定义 Exchange 和 Queue
定义交换机 confirmTestExchange 和队列 confirm_test_queue ，并将队列绑定在交换机上。
package com.rabbitmq.config;
import org.springframework.amqp.core.Binding;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.FanoutExchange;
import org.springframework.amqp.core.Queue;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
/***
*队列与交换机绑定
*/
@Configuration
public class QueueConfig {
@Bean(name = "confirmTestQueue")
public Queue confirmTestQueue() {
return new Queue("confirm_test_queue", true, false, false);
}
@Bean(name = "confirmTestExchange")
public FanoutExchange confirmTestExchange() {
return new FanoutExchange("confirmTestExchange");
}
@Bean
public Binding confirmTestFanoutExchangeAndQueue(
@Qualifier("confirmTestExchange") FanoutExchange confirmTestExchange,
@Qualifier("confirmTestQueue") Queue confirmTestQueue) {
return BindingBuilder.bind(confirmTestQueue).to(confirmTestExchange);
}
}
生产者
@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitmqApplication.class)
public class Producer {
//注入rabbitmq对象
@Autowired private RabbitTemplate rabbitTemplate;
//注入 ConfirmCallback对象
@Autowired private ConfirmCallbackService confirmCallbackService;
@Test public void test() {
//
rabbitTemplate.setConfirmCallback(confirmCallbackService);
//发送消息
rabbitTemplate.convertAndSend("confirmTestExchange1", "", "hello,ConfirmCallback你好");
}
}
正确情况，ack返回true，表示投递成功。
改变交换机名字，发送到一个不存在的交换机
//发送消息
rabbitTemplate.convertAndSend("confirmTestExchange1", "", "hello,ConfirmCallback你好");
消息未投递到queue的退回模式
消息从 exchange–>queue 投递失败则会返回一个 returnCallback
生产端通过实现ReturnCallback接口，启动消息失败返回，消息路由不到队列时会触发该回调接口
1、改yml
spring:
# rabbitmq 连接配置
rabbitmq: publisher-returns: true # 开启退回模式
2、设置投递失败的模式
如果消息没有路由到Queue，则丢弃消息（默认）
如果消息没有路由到Queue，返回给消息发送方ReturnCallBack（开启后）
rabbitTemplate.setMandatory(true);
3、实现returnedMessage方法
启动消息失败返回，消息路由不到队列时会触发该回调接口
package com.rabbitmq.config;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.stereotype.Component;
@Component
public class ReturnCallbackService implements 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("消息对象===>:" + message);
System.out.println("错误码===>:" + replyCode);
System.out.println("错误信息===>:" + replyText);
System.out.println("消息使用的交换器===>:" + exchange);
System.out.println("消息使用的路由key===>:" + routingKey);
//TODO ===>做业务处理
}
}
4、测试
生产者
@RunWith(SpringRunner.class)
@SpringBootTest(classes = RabbitmqApplication.class)
public class Producer {
@Autowired
private RabbitTemplate rabbitTemplate;
//注入rabbitmq对象
@Autowired
private ConfirmCallbackService confirmCallbackService;
@Autowired
private ReturnCallbackService returnCallbackService;
@Test
public void test() {
/**
* 确保消息发送失败后可以重新返回到队列中
*/
rabbitTemplate.setMandatory(true);
/**
* 消息投递到队列失败回调处理
*/
rabbitTemplate.setReturnCallback(returnCallbackService);
/**
* 消息投递确认模式
*/
rabbitTemplate.setConfirmCallback(confirmCallbackService);
//发送消息
rabbitTemplate.convertAndSend("confirmTestExchange", "info", "hello,ConfirmCallback你好");
}
}
如果不存在路由key，会调用ReturnCallback接口
消费端
消息确认机制ack
ack指Acknowledge确认。 表示消费端收到消息后的确认方式
消费端消息的确认分为：自动确认（默认）、手动确认、不确认
-
AcknowledgeMode.NONE：不确认
-
AcknowledgeMode.AUTO：自动确认
-
AcknowledgeMode.MANUAL：手动确认
其中自动确认是指，当消息一旦被Consumer接收到，则自动确认收到，并将相应 message 从RabbitMQ 的消息 缓存中移除。
但是在实际业务处理中，很可能消息接收到，业务处理出现异常，那么该消息就会丢失。如果设置了手动确认方式，则需要在业务处理成功后，调用channel.basicAck()，手动签收，如果出现异常，则调用channel.basicNack()方法，让其自动重新发送消息。
1、yml
spring:
rabbitmq:
listener:
simple:
acknowledge-mode: manual # 手动确认
2、确认配置
@Component
@RabbitListener(queues = "confirm_test_queue")
public class ReceiverMessage {
@RabbitHandler
public void processHandler(String msg, Channel channel, Message message) throws IOException {
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
System.out.println("消息内容===>" + new String(message.getBody()));
//TODO 具体业务逻辑
//手动签收[参数1:消息投递序号,参数2:批量签收]
channel.basicAck(deliveryTag, true);
} catch (Exception e) {
//拒绝签收[参数1:消息投递序号,参数2:批量拒绝,参数3:是否重新加入队列]
channel.basicNack(deliveryTag, true, true);
}
}
}
channel.basicNack 方法与 channel.basicReject 方法区别在于basicNack可以批量拒绝多条消息，而basicReject一次只能拒绝一条消息。
