Springboot整合RabbitMQ
说明:该篇文章内容包括有rabbitMq相关的一些简单理论介绍,provider消息推送实例,consumer消息消费实例,Direct、Topic、Fanout的使用。
在安装完rabbitMq后,输入http://ip:15672/ ,是可以看到一个简单后台管理界面的。
在这个界面里面我们可以做些什么?
可以手动创建虚拟host,创建用户,分配权限,创建交换机,创建队列等等,还有查看队列消息,消费效率,推送效率等等。
以上这些管理界面的操作在这篇暂时不做扩展描述,我想着重介绍后面实例里会使用到的。
首先先介绍一个简单的一个消息推送到接收的流程,提供一个简单的图:
黄色的圈圈就是我们的消息推送服务,将消息推送到 中间方框里面也就是 rabbitMq的服务器,然后经过服务器里面的交换机、队列等各种关系(后面会详细讲)将数据处理入列后,最终右边的蓝色圈圈消费者获取对应监听的消息。
常用的交换机有以下三种,因为消费者是从队列获取信息的,队列是绑定交换机的(一般),所以对应的消息推送/接收模式也会有以下几种:
Direct Exchange
直连型交换机,根据消息携带的路由键将消息投递给对应队列。
大致流程,有一个队列绑定到一个直连交换机上,同时赋予一个路由键 routing key 。
然后当一个消息携带着路由值为X,这个消息通过生产者发送给交换机时,交换机就会根据这个路由值X去寻找绑定值也是X的队列。
Fanout Exchange
扇型交换机,这个交换机没有路由键概念,就算你绑了路由键也是无视的。 这个交换机在接收到消息后,会直接转发到绑定到它上面的所有队列。
Topic Exchange
主题交换机,这个交换机其实跟直连交换机流程差不多,但是它的特点就是在它的路由键和绑定键之间是有规则的。
简单地介绍下规则:
* (星号) 用来表示一个单词 (必须出现的)
# (井号) 用来表示任意数量(零个或多个)单词
通配的绑定键是跟队列进行绑定的,举个小例子
队列Q1 绑定键为 *.TT.* 队列Q2绑定键为 TT.#
如果一条消息携带的路由键为 A.TT.B,那么队列Q1将会收到;
如果一条消息携带的路由键为TT.AA.BB,那么队列Q2将会收到;
主题交换机是非常强大的,为啥这么膨胀?
当一个队列的绑定键为 "#"(井号) 的时候,这个队列将会无视消息的路由键,接收所有的消息。
当 * (星号) 和 # (井号) 这两个特殊字符都未在绑定键中出现的时候,此时主题交换机就拥有的直连交换机的行为。
所以主题交换机也就实现了扇形交换机的功能,和直连交换机的功能。
另外还有 Header Exchange 头交换机 ,Default Exchange 默认交换机,Dead Letter Exchange 死信交换机,这几个该篇暂不做讲述。
本次实例教程需要创建2个springboot项目,一个生产者,一个消费者。
首先创建 生产者,
pom.xml里用到的jar依赖:
1 2 3 4 5 | <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> |
application.yml:
1 2 3 4 5 6 7 8 9 10 11 12 13 | #本机端口 server: port: 8082 spring: #给项目来个名字 application: name: rabbitmq-provider #配置rabbitMq 服务器 rabbitmq: host: 127.0 . 0.1 port: 5672 username: guest password: guest |
然后先使用下direct exchange(直连型交换机),创建DirectRabbitConfig.java
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 | package com.wx.test.rtmdemo.config; import org.springframework.amqp.core.*; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; import java.util.HashMap; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Configuration public class DirectRabbitConfig { //队列 起名:TestDirectQueue @Bean public Queue TestDirectQueue() { //队列的三个参数讲解 // durable:是否持久化,默认是false,持久化队列:会被存储在磁盘上,当消息代理重启时仍然存在,暂存队列:当前连接有效 // exclusive:默认也是false,只能被当前创建的连接使用,而且当连接关闭后队列即被删除。此参考优先级高于durable // autoDelete:是否自动删除,当没有生产者或者消费者使用此队列,该队列会自动删除。 // return new Queue("TestDirectQueue",true,true,false); //一般设置一下队列的持久化就好,其余两个就是默认false return new Queue( "TestDirectQueue" , true ); } //Direct交换机 起名:TestDirectExchange @Bean DirectExchange TestDirectExchange() { // return new DirectExchange("TestDirectExchange",true,true); return new DirectExchange( "TestDirectExchange" , true , false ); } //绑定 将队列和交换机绑定, 并设置用于匹配键:TestDirectRouting @Bean Binding bindingDirect() { return BindingBuilder.bind(TestDirectQueue()).to(TestDirectExchange()).with( "TestDirectRouting" ); } } |
然后写个简单的接口进行消息推送:
1 2 3 4 5 6 7 8 9 10 11 12 13 | @GetMapping ( "/sendDirectMessage" ) public String sendDirectMessage() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "test message, hello!" ; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss" )); Map<String,Object> map= new HashMap<>(); map.put( "messageId" ,messageId); map.put( "messageData" ,messageData); map.put( "createTime" ,createTime); //将消息携带绑定键值:TestDirectRouting 发送到交换机TestDirectExchange rabbitTemplate.convertAndSend( "TestDirectExchange" , "TestDirectRouting" , map); return "ok" ; } |
将项目运行起来,调用这个接口:
此时,在rabbitMq管理页面可以看到,有一条推送的消息。
然后有一个消息等待被消费。
此时,说明我们的生产者的消息已经生产成功,只需要等待消费者消费即可!
接下来创建消费者服务:
首先是pom.xml文件的依赖:
1 2 3 4 5 | <!--rabbitmq--> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-amqp</artifactId> </dependency> |
然后是application.yml:
server: port: 8083 spring: #给项目来个名字 application: name: rabbitmq-consumer #配置rabbitMq 服务器 rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest
然后是创建消息接收监听类,DirectReceiver.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 | package com.wx.test.consumer.config; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.util.Map; @Component @RabbitListener (queues = "TestDirectQueue" ) //监听的队列名称 TestDirectQueue public class DirectReceiver { @RabbitHandler public void process(Map testMessage) { System.out.println( "DirectReceiver消费者收到消息 : " + testMessage.toString()); } } |
然后启动项目,可以看到生产者的消息,在这边被成功消费了。
接下来是Topic Exchange交换机,配置文件以及依赖包不变,新建一个TopicRabbitConfig.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 | package com.wx.test.rtmdemo.config; import org.springframework.amqp.core.Binding; import org.springframework.amqp.core.BindingBuilder; import org.springframework.amqp.core.Queue; import org.springframework.amqp.core.TopicExchange; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Configuration public class TopicRabbitConfig { //绑定键 public final static String man = "topic.man" ; public final static String woman = "topic.woman" ; @Bean public Queue firstQueue() { return new Queue(TopicRabbitConfig.man); } @Bean public Queue secondQueue() { return new Queue(TopicRabbitConfig.woman); } @Bean TopicExchange exchange() { return new TopicExchange( "topicExchange" ); } //将firstQueue和topicExchange绑定,而且绑定的键值为topic.man //这样只要是消息携带的路由键是topic.man,才会分发到该队列 @Bean Binding bindingExchangeMessage() { return BindingBuilder.bind(firstQueue()).to(exchange()).with(man); } //将secondQueue和topicExchange绑定,而且绑定的键值为用上通配路由键规则topic.# // 这样只要是消息携带的路由键是以topic.开头,都会分发到该队列 @Bean Binding bindingExchangeMessage2() { return BindingBuilder.bind(secondQueue()).to(exchange()).with( "topic.#" ); } } |
然后在创建两个接口,用于测试:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 | @GetMapping ( "/sendTopicMessage1" ) public String sendTopicMessage1() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "message: M A N " ; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss" )); Map<String, Object> manMap = new HashMap<>(); manMap.put( "messageId" , messageId); manMap.put( "messageData" , messageData); manMap.put( "createTime" , createTime); rabbitTemplate.convertAndSend( "topicExchange" , "topic.man" , manMap); return "ok" ; } @GetMapping ( "/sendTopicMessage2" ) public String sendTopicMessage2() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "message: woman is all " ; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss" )); Map<String, Object> womanMap = new HashMap<>(); womanMap.put( "messageId" , messageId); womanMap.put( "messageData" , messageData); womanMap.put( "createTime" , createTime); rabbitTemplate.convertAndSend( "topicExchange" , "topic.woman123" , womanMap); return "ok" ; } |
然后在创建一个消费者TopicManReceiver.java::
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | package com.wx.test.consumer.config; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Component @RabbitListener (queues = "topic.man" ) public class TopicManReceiver { @RabbitHandler public void process(Map testMessage) { System.out.println( "TopicManReceiver消费者收到消息 : " + testMessage.toString()); } } |
然后再创建一个消费者TopicTotalReceiver.java::
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | package com.wx.test.consumer.config; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Component @RabbitListener (queues = "topic.woman" ) public class TopicTotalReceiver { @RabbitHandler public void process(Map testMessage) { System.out.println( "TopicTotalReceiver消费者收到消息 : " + testMessage.toString()); } } |
启动项目,调用sendTopicMessage1这个接口:
可以看到,两个消费者都消费了这条消息。
注意:
TopicManReceiver监听队列1,绑定键为:topic.man
TopicTotalReceiver监听队列2,绑定键为:topic.#
而当前推送的消息,携带的路由键为:topic.man
再调用sendTopicMessage2这个接口:
这时,只有TopicTotalReceiver成功消费了。
然后是Fanout Exchang交换机:
首先,创建生产者:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 | package com.wx.test.rtmdemo.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.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Configuration public class FanoutRabbitConfig { /** * 创建三个队列 :fanout.A fanout.B fanout.C * 将三个队列都绑定在交换机 fanoutExchange 上 * 因为是扇型交换机, 路由键无需配置,配置也不起作用 */ @Bean public Queue queueA() { return new Queue( "fanout.A" ); } @Bean public Queue queueB() { return new Queue( "fanout.B" ); } @Bean public Queue queueC() { return new Queue( "fanout.C" ); } @Bean FanoutExchange fanoutExchange() { return new FanoutExchange( "fanoutExchange" ); } @Bean Binding bindingExchangeA() { return BindingBuilder.bind(queueA()).to(fanoutExchange()); } @Bean Binding bindingExchangeB() { return BindingBuilder.bind(queueB()).to(fanoutExchange()); } @Bean Binding bindingExchangeC() { return BindingBuilder.bind(queueC()).to(fanoutExchange()); } } |
同样写一个接口,用于生产一条消息:
1 2 3 4 5 6 7 8 9 10 11 12 | @GetMapping ( "/sendFanoutMessage" ) public String sendFanoutMessage() { String messageId = String.valueOf(UUID.randomUUID()); String messageData = "message: testFanoutMessage " ; String createTime = LocalDateTime.now().format(DateTimeFormatter.ofPattern( "yyyy-MM-dd HH:mm:ss" )); Map<String, Object> map = new HashMap<>(); map.put( "messageId" , messageId); map.put( "messageData" , messageData); map.put( "createTime" , createTime); rabbitTemplate.convertAndSend( "fanoutExchange" , null , map); return "ok" ; } |
接下来在消费者里面创建一个类,用于接收消息:
FanoutReceiverA.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | package com.wx.test.consumer.config; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Component @RabbitListener (queues = "fanout.A" ) public class FanoutReceiverA { @RabbitHandler public void process(Map testMessage) { System.out.println( "FanoutReceiverA消费者收到消息 : " +testMessage.toString()); } } |
FanoutReceiverB.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 | package com.wx.test.consumer.config; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Component @RabbitListener (queues = "fanout.B" ) public class FanoutReceiverB { @RabbitHandler public void process(Map testMessage) { System.out.println( "FanoutReceiverB消费者收到消息 : " +testMessage.toString()); } } |
FanoutReceiverC.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 | package com.wx.test.consumer.config; import org.springframework.amqp.rabbit.annotation.RabbitHandler; import org.springframework.amqp.rabbit.annotation.RabbitListener; import org.springframework.stereotype.Component; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Component @RabbitListener (queues = "fanout.C" ) public class FanoutReceiverC { @RabbitHandler public void process(Map testMessage) { System.out.println( "FanoutReceiverC消费者收到消息 : " +testMessage.toString()); } } |
最后启动项目,调用我们生产者的接口,查看消息消费情况:
可以看到,这三个类都消费到消息。
接下来配置消息的回调。其实就是消息确认(生产者推送消息成功,消费者接收消息成功)。
在rabbitmq-provider项目的application.yml文件上,加上消息确认的配置项(publisher-confirm-type: correlated):
spring: #配置rabbitMq 服务器 rabbitmq: host: 127.0.0.1 port: 5672 username: guest password: guest publisher-confirm-type: correlated publisher-returns: true
配置相关的消息确认回调函数,RabbitConfig.java:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 | package com.mq.demo.config; import org.springframework.amqp.core.Message; import org.springframework.amqp.rabbit.connection.ConnectionFactory; import org.springframework.amqp.rabbit.connection.CorrelationData; import org.springframework.amqp.rabbit.core.RabbitTemplate; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @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;
那么以上这两种回调函数都是在什么情况会触发呢?
先从总体的情况分析,推送消息存在四种情况:
①消息推送到server,但是在server里找不到交换机
②消息推送到server,找到交换机了,但是没找到队列
③消息推送到sever,交换机和队列啥都没找到
④消息推送成功
通过调用结果会发现:
①这种情况触发的是 ConfirmCallback 回调函数。
②这种情况触发的是 ConfirmCallback和RetrunCallback两个回调函数。
③这种情况触发的是 ConfirmCallback 回调函数。
④这种情况触发的是 ConfirmCallback 回调函数。
在然后就是,消费者接收到消息的消息确认机制。
和生产者的消息确认机制不同,因为消息接收本来就是在监听消息,符合条件的消息就会消费下来。
所以,消息接收的确认机制主要存在三种模式:
①自动确认, 这也是默认的消息确认情况。 AcknowledgeMode.NONE
RabbitMQ成功将消息发出(即将消息成功写入TCP Socket)中立即认为本次投递已经被正确处理,不管消费者端是否成功处理本次投递。
② 根据情况确认, 这个不做介绍
③ 手动确认 , 这个比较关键,也是我们配置接收消息确认机制时,多数选择的模式。
消费者收到消息后,手动调用basic.ack/basic.nack/basic.reject后,RabbitMQ收到这些消息后,才认为本次投递成功。
basic.ack用于肯定确认
basic.nack用于否定确认(注意:这是AMQP 0-9-1的RabbitMQ扩展)
basic.reject用于否定确认,但与basic.nack相比有一个限制:一次只能拒绝单条消息
消费者端以上的3个方法都表示消息已经被正确投递,但是basic.ack表示消息已经被正确处理。
而basic.nack,basic.reject表示没有被正确处理:
着重讲下reject,因为有时候一些场景是需要重新入列的。
channel.basicReject(deliveryTag, true); 拒绝消费当前消息,如果第二参数传入true,就是将数据重新丢回队列里,那么下次还会消费这消息。设置false,就是告诉服务器,我已经知道这条消息数据了,因为一些原因拒绝它,而且服务器也把这个消息丢掉就行。 下次不想再消费这条消息了。
使用拒绝后重新入列这个确认模式要谨慎,因为一般都是出现异常的时候,catch异常再拒绝入列,选择是否重入列。
但是如果使用不当会导致一些每次都被你重入列的消息一直消费-入列-消费-入列这样循环,会导致消息积压。
顺便也简单讲讲 nack,这个也是相当于设置不消费某条消息。
channel.basicNack(deliveryTag, false, true);
第一个参数依然是当前消息到的数据的唯一id;
第二个参数是指是否针对多条消息;如果是true,也就是说一次性针对当前通道的消息的tagID小于当前这条消息的,都拒绝确认。
第三个参数是指是否重新入列,也就是指不确认的消息是否重新丢回到队列里面去。
同样使用不确认后重新入列这个确认模式要谨慎,因为这里也可能因为考虑不周出现消息一直被重新丢回去的情况,导致积压。
在消费者项目里,新建MessageListenerConfig.java上添加代码相关的配置代码:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 | package com.mq.demo.config; import org.springframework.amqp.core.AcknowledgeMode; import org.springframework.amqp.core.Queue; import org.springframework.amqp.rabbit.connection.CachingConnectionFactory; import org.springframework.amqp.rabbit.listener.SimpleMessageListenerContainer; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.context.annotation.Bean; import org.springframework.context.annotation.Configuration; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @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( "TestDirectQueue" ); container.setMessageListener(myAckReceiver); return container; } } |
对应的手动确认消息监听类,MyAckReceiver.java(手动确认模式需要实现 ChannelAwareMessageListener):
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 | package com.mq.demo.config; import com.rabbitmq.client.Channel; import org.springframework.amqp.core.Message; import org.springframework.amqp.rabbit.listener.api.ChannelAwareMessageListener; import org.springframework.stereotype.Component; import java.io.ByteArrayInputStream; import java.io.ObjectInputStream; import java.util.Map; /** * @Author : laz * @CreateTime : 2021/11/14 * @Description : **/ @Component public class MyAckReceiver implements ChannelAwareMessageListener { @Override public void onMessage(Message message, Channel channel) throws Exception { long deliveryTag = message.getMessageProperties().getDeliveryTag(); try { byte [] body = message.getBody(); ObjectInputStream ois = new ObjectInputStream( new ByteArrayInputStream(body)); Map<String,String> msgMap = (Map<String,String>) ois.readObject(); String messageId = msgMap. get ( "messageId" ); String messageData = msgMap. get ( "messageData" ); String createTime = msgMap. get ( "createTime" ); ois.close(); System. out .println( " MyAckReceiver messageId:" +messageId+ " messageData:" +messageData+ " createTime:" +createTime); System. out .println( "消费的主题消息来自:" +message.getMessageProperties().getConsumerQueue()); //第二个参数,手动确认可以被批处理,当该参数为 true 时,则可以一次性确认 delivery_tag 小于等于传入值的所有消息 channel.basicAck(deliveryTag, true ); //第二个参数,true会重新放回队列,所以需要自己根据业务逻辑判断什么时候使用拒绝 //channel.basicReject(deliveryTag, true); } catch (Exception e) { channel.basicReject(deliveryTag, false ); e.printStackTrace(); } } } |
这时,先调用接口/sendDirectMessage, 给直连交换机TestDirectExchange 的队列TestDirectQueue 推送一条消息,可以看到监听器正常消费了下来:
想看更加详细的教程,请移步https://blog.csdn.net/weixin_43926382/article/details/122822803
好了,这篇Springboot整合rabbitMq教程就暂且到此。本文若有错误,还请各路大佬指正指正!
【推荐】国内首个AI IDE,深度理解中文开发场景,立即下载体验Trae
【推荐】编程新体验,更懂你的AI,立即体验豆包MarsCode编程助手
【推荐】抖音旗下AI助手豆包,你的智能百科全书,全免费不限次数
【推荐】轻量又高性能的 SSH 工具 IShell:AI 加持,快人一步
· Linux系列:如何用heaptrack跟踪.NET程序的非托管内存泄露
· 开发者必知的日志记录最佳实践
· SQL Server 2025 AI相关能力初探
· Linux系列:如何用 C#调用 C方法造成内存泄露
· AI与.NET技术实操系列(二):开始使用ML.NET
· 被坑几百块钱后,我竟然真的恢复了删除的微信聊天记录!
· 没有Manus邀请码?试试免邀请码的MGX或者开源的OpenManus吧
· 【自荐】一款简洁、开源的在线白板工具 Drawnix
· 园子的第一款AI主题卫衣上架——"HELLO! HOW CAN I ASSIST YOU TODAY
· Docker 太简单,K8s 太复杂?w7panel 让容器管理更轻松!