背景:
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://guest@127.0.0.1:5672/, localPort= 56747]
ConfirmCallback: 相关数据:null
ConfirmCallback: 确认情况:false
ConfirmCallback: 原因:channel error; protocol method: #method<channel.close>(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<channel.close>(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://guest@127.0.0.1:5672/, localPort= 57078]
ConfirmCallback: 相关数据:null
ConfirmCallback: 确认情况:false
ConfirmCallback: 原因:channel error; protocol method: #method<channel.close>(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<channel.close>(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://guest@127.0.0.1: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、输出结果如下: