rabbitmq消息确认机制
背景：
rabbitmq支持消息的回调，即生产者推送消息成功，消费者消费消息成功都可以进行消息的确认，
生产者配置项：
1、配置applicaiton.properties：
server.port = 8888
spring.application.name=spirng-boot-rabbitmq-sender
spring.rabbitmq.host=127.0.0.1
spring.rabbitmq.port=5672
spring.rabbitmq.username=guest
spring.rabbitmq.password=guest
#确认消息已经发送到交换机（Exchange）
spring.rabbitmq.publisher-confirms=true
#确认消息已经发送到队列（Queue）
spring.rabbitmq.publisher-returns=true
2、配置相关的消息确认回调函数RabbitConfig
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.connection.ConnectionFactory;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.amqp.rabbit.support.CorrelationData;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class RabbitConfig {
@Bean
public RabbitTemplate createRabbitTemplate(ConnectionFactory connectionFactory){
RabbitTemplate rabbitTemplate = new RabbitTemplate();
rabbitTemplate.setConnectionFactory(connectionFactory);
//设置开启Mandatory,才能触发回调函数,无论消息推送结果怎么样都强制调用回调函数
rabbitTemplate.setMandatory(true);
rabbitTemplate.setConfirmCallback(new RabbitTemplate.ConfirmCallback() {
@Override
public void confirm(CorrelationData correlationData, boolean ack, String cause) {
System.out.println("ConfirmCallback: "+"相关数据："+correlationData);
System.out.println("ConfirmCallback: "+"确认情况："+ack);
System.out.println("ConfirmCallback: "+"原因："+cause);
}
});
rabbitTemplate.setReturnCallback(new RabbitTemplate.ReturnCallback() {
@Override
public void returnedMessage(Message message, int replyCode, String replyText, String exchange, String routingKey) {
System.out.println("ReturnCallback: "+"消息："+message);
System.out.println("ReturnCallback: "+"回应码："+replyCode);
System.out.println("ReturnCallback: "+"回应信息："+replyText);
System.out.println("ReturnCallback: "+"交换机："+exchange);
System.out.println("ReturnCallback: "+"路由键："+routingKey);
}
});
return rabbitTemplate;
}
}到这里，生产者推送消息的消息确认调用回调函数已经完毕。可以看到上面写了两个回调函数，一个是ConfirmCallback ，一个是RetrunCallback；那么以上这两种回调函数都是在什么情况会触发呢？
3、先从总体的情况分析，推送消息存在四种情况：
1、消息推送到server，但是在server里找不到交换机
2、消息推送到server，找到交换机了，但是没找到队列
3、消息推送到sever，交换机和队列啥都没找到
4、消息推送成功
接下来我们写个消息推送接口来验证下上面的四种情况，看看这两个回调函数在什么情况下会触发。
3-1、消息推送到server，但是在server里找不到交换机
写个测试接口，把消息推送到名为directExchange1的交换机上（这个交换机是没有创建没有配置的）：
@Component
public class MessageProvider {
@Autowired
private AmqpTemplate rabbitTemplate;
@Scheduled(fixedRate=5000,initialDelay=3000)
public void send() {
String context = "hello " + new Date();
this.rabbitTemplate.convertAndSend("directExchange1", "directRouting", context);
}
}调用接口，查看rabbitmq-provider项目的控制台输出情况（原因里面有说，没有找到交换机directExchange1）：
2020-08-08 20:44:29.267 INFO 10888 --- [pool-3-thread-1] o.s.a.r.c.CachingConnectionFactory : Created new connection: rabbitConnectionFactory#b431c40:0/SimpleConnection@4dc3803e [delegate=amqp://[email protected]:5672/, localPort= 56747]
ConfirmCallback: 相关数据：null
ConfirmCallback: 确认情况：false
ConfirmCallback: 原因：channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'directExchange1' in vhost '/', class-id=60, method-id=40)
2020-08-08 20:44:29.296 ERROR 10888 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'directExchange1' in vhost '/', class-id=60, method-id=40)
结论：这种情况触发的是ConfirmCallback回调函数
3-2、消息推送到server，找到交换机了，但是没找到队列
新增一个交换机，但是不给这个交换机绑定队列，在DirectRabbitConfig里面新增一个直连交换机，名叫directExchange，但没给它做任何绑定配置操作：
@Configuration
public class DirectRabbitConfig {
@Bean
public DirectExchange directExchange() {
return new DirectExchange("directExchange");
}
}写个测试接口，把消息推送到名为directExchange的交换机上：
@Component
public class MessageProvider {
@Autowired
private AmqpTemplate rabbitTemplate;
@Scheduled(fixedRate=5000,initialDelay=3000)
public void send() {
String context = "hello " + new Date();
this.rabbitTemplate.convertAndSend("directExchange", "directRouting", context);
}
}调用接口，查看rabbitmq-provider项目的控制台输出情况（原因里面有说，没有找到交换机creditFinanceExchange1）：
ReturnCallback: 消息：(Body:'hello Sat Aug 08 20:47:31 CST 2020' MessageProperties [headers={}, timestamp=null, messageId=null, userId=null, receivedUserId=null, appId=null, clusterId=null, type=null, correlationId=null, correlationIdString=null, replyTo=null, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, deliveryMode=null, receivedDeliveryMode=PERSISTENT, expiration=null, priority=0, redelivered=null, receivedExchange=null, receivedRoutingKey=null, receivedDelay=null, deliveryTag=0, messageCount=null, consumerTag=null, consumerQueue=null])
ReturnCallback: 回应码：312
ReturnCallback: 回应信息：NO_ROUTE
ReturnCallback: 交换机：directExchange
ReturnCallback: 路由键：directRouting
ConfirmCallback: 相关数据：null
ConfirmCallback: 确认情况：true
ConfirmCallback: 原因：null结论：可以看到这种情况，两个函数都被调用了；这种情况下，消息是推送成功到服务器的，所以ConfirmCallback对消息确认情况是true；而在RetrunCallback回调函数的打印参数里面可以看到，消息是推送到了交换机成功了，但是在路由分发给队列的时候，找不到队列，所以报了错误 NO_ROUTE 。所以，这种情况触发的是ConfirmCallback和RetrunCallback两个回调函数。
3-3、消息推送到sever，交换机和队列啥都没找到
写个测试接口，把消息推送到交换机名为directExchange2，队列名为directRouting的服务上（交换机的队列都没有创建）：
@Component
public class MessageProvider {
@Autowired
private AmqpTemplate rabbitTemplate;
@Scheduled(fixedRate=5000,initialDelay=3000)
public void send() {
String context = "hello " + new Date();
this.rabbitTemplate.convertAndSend("directExchange2", "directRouting", context);
}
}调用接口，查看rabbitmq-provider项目的控制台输出情况（原因里面有说，没有找到交换机directExchange2）：
2020-08-08 20:51:57.680 INFO 1660 --- [pool-3-thread-1] o.s.a.r.c.CachingConnectionFactory : Created new connection: rabbitConnectionFactory#b431c40:0/SimpleConnection@4dc3803e [delegate=amqp://[email protected]:5672/, localPort= 57078]
ConfirmCallback: 相关数据：null
ConfirmCallback: 确认情况：false
ConfirmCallback: 原因：channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'directExchange2' in vhost '/', class-id=60, method-id=40)
2020-08-08 20:51:57.710 ERROR 1660 --- [ 127.0.0.1:5672] o.s.a.r.c.CachingConnectionFactory : Channel shutdown: channel error; protocol method: #method(reply-code=404, reply-text=NOT_FOUND - no exchange 'directExchange2' in vhost '/', class-id=60, method-id=40)
结论：这种情况触发的是ConfirmCallback回调函数，和第一种情况一样
3-4、消息推送成功
配置交换机directExchange，队列directQueue，正常数据推送
@Configuration
public class DirectRabbitConfig {
@Bean
public Queue directQueue() {
return new Queue("directQueue",true);
}
@Bean
public DirectExchange directExchange() {
return new DirectExchange("directExchange");
}
@Bean
public Binding bindingDirect() {
return BindingBuilder.bind(directQueue()).to(directExchange()).with("directRouting");
}
}@Component
public class MessageProvider {
@Autowired
private AmqpTemplate rabbitTemplate;
@Scheduled(fixedRate=5000,initialDelay=3000)
public void send() {
String context = "hello " + new Date();
this.rabbitTemplate.convertAndSend("directExchange", "directRouting", context);
}
}调用接口，查看rabbitmq-provider项目的控制台输出情况：
2020-08-08 20:56:00.492 INFO 3004 --- [pool-3-thread-1] o.s.a.r.c.CachingConnectionFactory : Created new connection: rabbitConnectionFactory#35020979:0/SimpleConnection@33325e98 [delegate=amqp://[email protected]:5672/, localPort= 57287]
ConfirmCallback: 相关数据：null
ConfirmCallback: 确认情况：true
ConfirmCallback: 原因：null
结论：这种情况触发的是ConfirmCallback回调函数
消费者配置项：
1、生产者的消息确认机制不同，因为消息接收本来就是在监听消息，符合条件的消息就会消费下来。所以，消息接收的确认机制主要存在三种模式：
a、自动确认：这也是默认的消息确认情况（AcknowledgeMode.NONE）。RabbitMQ成功将消息发出（即将消息成功写入TCP Socket）立即认为本次投递已经被正确处理，不管消费者端是否成功处理本次投递。所以这种情况如果消费端消费逻辑抛出异常，也就是消费端没有处理成功这条消息，那么就相当于丢失了消息。
一般这种情况我们都是使用try catch捕捉异常后，打印日志用于追踪数据，这样找出对应数据再做后续处理。
b、根据情况确认： 这个不做介绍
c、手动确认 ：这个比较关键，也是我们配置接收消息确认机制时，多数选择的模式。
2、在消费者项目中，新建MessageListenerConfig类，代码如下：
@Configuration
public class MessageListenerConfig {
@Autowired
private CachingConnectionFactory connectionFactory;
@Autowired
// 消息接收处理类
private MyAckReceiver myAckReceiver;
@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer() {
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
container.setConcurrentConsumers(1);
container.setMaxConcurrentConsumers(1);
// RabbitMQ默认是自动确认，这里改为手动确认消息
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
// 设置一个需要监听的队列
container.setQueueNames("directQueue");
container.setMessageListener(myAckReceiver);
return container;
}
}3、对应的手动确认消息监听类，MyAckReceiver代码如下：（手动确认模式需要实现 ChannelAwareMessageListener接口）：
@Component
public class MyAckReceiver implements ChannelAwareMessageListener {
public void onMessage(Message message, Channel channel) throws Exception {
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
//因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
String msg = message.toString();
// 可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
String[] msgArray = msg.split("'");
System.out.println("接收到的数据为"+msgArray[1]);
System.out.println("消费的主题消息来自："+message.getMessageProperties().getConsumerQueue());
System.out.println(msg);
channel.basicAck(deliveryTag, true);
// 为true会重新放回队列
//channel.basicReject(deliveryTag, true);
} catch (Exception e) {
channel.basicReject(deliveryTag, false);
e.printStackTrace();
}
}
}这时，启动刚才的消息提供者， 给直连交换机directExchange的队列directQueue推送数据，可以看到监听器正常消费了下来：
接收到的数据为hello Sat Aug 08 21:55:36 CST 2020
消费的主题消息来自：directQueue
(Body:'hello Sat Aug 08 21:55:36 CST 2020' MessageProperties [headers={spring_listener_return_correlation=6ce712de-8a89-4dd9-8aec-750cf1b78bae}, timestamp=null, messageId=null, userId=null, receivedUserId=null, appId=null, clusterId=null, type=null, correlationId=null, correlationIdString=null, replyTo=null, contentType=text/plain, contentEncoding=UTF-8, contentLength=0, deliveryMode=null, receivedDeliveryMode=PERSISTENT, expiration=null, priority=0, redelivered=false, receivedExchange=directExchange, receivedRoutingKey=directRouting, receivedDelay=null, deliveryTag=23, messageCount=0, consumerTag=amq.ctag-z7rle4GFuausEUsKtADk5w, consumerQueue=directQueue])
4、分析
消费者收到消息后，手动调用basicAck（）、basicNack（）或basicReject（）方法后(看上面的代码)，RabbitMQ收到这些消息后，才认为本次投递成功。basicAck（）用于肯定确认；basicNack（）用于否定确认（注意：这是AMQP 0-9-1的RabbitMQ扩展）；basicReject（）用于否定确认，但与basicNack（）相比有一个限制：一次只能拒绝单条消息。
消费者端以上的这三个方法都表示消息已经被正确投递，但是basicAck（）表示消息已经被正确处理。而basicNack（）和basicReject（）表示没有被正确处理：
讲下basicReject（）方法，因为有时候一些场景是需要重新入列的。channel.basicAck(deliveryTag, true); 拒绝消费当前消息，如果第二参数传入true，就是将数据重新丢回队列里，那么下次还会消费这消息。设置false，就是告诉服务器，我已经知道这条消息数据了，因为一些原因拒绝它，而且服务器也把这个消息丢掉就行。 下次不想再消费这条消息了。使用拒绝后重新入列这个确认模式要谨慎，因为一般都是出现异常的时候，catch异常再拒绝入列，选择是否重入列。但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环，会导致消息积压。
讲下basicNack（），这个也是相当于设置不消费某条消息。channel.basicNack(deliveryTag, false, true);
第一个参数依然是当前消息到的数据的唯一id；第二个参数是指是否针对多条消息；如果是true，也就是说一次性针对当前通道的消息的tagID小于当前这条消息的，都拒绝确认。第三个参数是指是否重新入列，也就是指不确认的消息是否重新丢回到队列里面去。同样使用不确认后重新入列这个确认模式要谨慎，因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况，导致积压。
5、在这个消费者项目里面，如果需要监听的好几个队列都想变成手动确认模式，而且处理的消息业务逻辑不一样。该怎么办呢？
1、向SimpleMessageListenerContainer里添加多个队列：
@Configuration
public class MessageListenerConfig {
@Autowired
private CachingConnectionFactory connectionFactory;
@Autowired
// 消息接收处理类
private MyAckReceiver myAckReceiver;
@Bean
public SimpleMessageListenerContainer simpleMessageListenerContainer() {
SimpleMessageListenerContainer container = new SimpleMessageListenerContainer(connectionFactory);
container.setConcurrentConsumers(1);
container.setMaxConcurrentConsumers(1);
// RabbitMQ默认是自动确认，这里改为手动确认消息
container.setAcknowledgeMode(AcknowledgeMode.MANUAL);
// 设置一个需要监听的队列
//container.setQueueNames("directQueue");
// 如果同时设置多个如下： 前提是队列都是必须已经创建存在的
container.setQueueNames("directQueue","directQueue2");
// 另一种设置队列的方法,如果使用这种情况,那么要设置多个,就使用addQueues
//container.setQueues(new Queue("TestDirectQueue",true));
//container.addQueues(new Queue("TestDirectQueue2",true));
//container.addQueues(new Queue("TestDirectQueue3",true));
container.setMessageListener(myAckReceiver);
return container;
}
}2、然后我们的手动确认消息监听类，MyAckReceiver就可以同时将上面设置到的队列的消息都消费下来。但是我们需要做不用的业务逻辑处理，那么只需要 根据消息来自的队列名进行区分处理即可，如：
@Component
public class MyAckReceiver implements ChannelAwareMessageListener {
public void onMessage(Message message, Channel channel) throws Exception {
long deliveryTag = message.getMessageProperties().getDeliveryTag();
try {
//因为传递消息的时候用的map传递,所以将Map从Message内取出需要做些处理
String msg = message.toString();
// 可以点进Message里面看源码,单引号直接的数据就是我们的map消息数据
String[] msgArray = msg.split("'");
if ("directQueue".equals(message.getMessageProperties().getConsumerQueue())){
System.out.println("接收到的数据为"+msgArray[1]);
System.out.println("消费的主题消息来自："+message.getMessageProperties().getConsumerQueue());
System.out.println(msg);
}
if ("directQueue2".equals(message.getMessageProperties().getConsumerQueue())){
System.out.println("接收到的数据为"+msgArray[1]);
System.out.println("消费的主题消息来自："+message.getMessageProperties().getConsumerQueue());
System.out.println(msg);
}
channel.basicAck(deliveryTag, true);
// 为true会重新放回队列
//channel.basicReject(deliveryTag, true);
} catch (Exception e) {
channel.basicReject(deliveryTag, false);
e.printStackTrace();
}
}
}3、输出结果如下：
