springboot学习笔记-springboot整合RabbitMQ
文章转自:https://www.cnblogs.com/hlhdidi/p/6535677.html
一 RabbitMQ的介绍
RabbitMQ是消息中间件的一种,消息中间件即分布式系统中完成消息的发送和接收的基础软件.这些软件有很多,包括ActiveMQ(apache公司的),RocketMQ(阿里巴巴公司的,现已经转让给apache).
消息中间件的工作过程可以用生产者消费者模型来表示.即,生产者不断的向消息队列发送信息,而消费者从消息队列中消费信息.具体过程如下:
从上图可看出,对于消息队列来说,生产者,消息队列,消费者是最重要的三个概念,生产者发消息到消息队列中去,消费者监听指定的消息队列,并且当消息队列收到消息之后,接收消息队列传来的消息,并且给予相应的处理.消息队列常用于分布式系统之间互相信息的传递.
对于RabbitMQ来说,除了这三个基本模块以外,还添加了一个模块,即交换机(Exchange).它使得生产者和消息队列之间产生了隔离,生产者将消息发送给交换机,而交换机则根据调度策略把相应的消息转发给对应的消息队列.那么RabitMQ的工作流程如下所示:
紧接着说一下交换机.交换机的主要作用是接收相应的消息并且绑定到指定的队列.交换机有四种类型,分别为Direct,topic,headers,Fanout.
Direct是RabbitMQ默认的交换机模式,也是最简单的模式.即创建消息队列的时候,指定一个BindingKey.当发送者发送消息的时候,指定对应的Key.当Key和消息队列的BindingKey一致的时候,消息将会被发送到该消息队列中.
topic转发信息主要是依据通配符,队列和交换机的绑定主要是依据一种模式(通配符+字符串),而当发送消息的时候,只有指定的Key和该模式相匹配的时候,消息才会被发送到该消息队列中.
headers也是根据一个规则进行匹配,在消息队列和交换机绑定的时候会指定一组键值对规则,而发送消息的时候也会指定一组键值对规则,当两组键值对规则相匹配的时候,消息会被发送到匹配的消息队列中.
Fanout是路由广播的形式,将会把消息发给绑定它的全部队列,即便设置了key,也会被忽略.
二.SpringBoot整合RabbitMQ(Direct模式)
SpringBoot整合RabbitMQ非常简单!感觉SpringBoot真的极大简化了开发的搭建环境的时间..这样我们程序员就可以把更多的时间用在业务上了,下面开始搭建环境:
首先创建两个maven工程,这是为了模拟分布式应用系统中,两个应用之间互相交流的过程,一个发送者(Sender),一个接收者(Receiver)
紧接着,配置pom.xml文件,注意其中用到了springboot对于AMQP(高级消息队列协议,即面向消息的中间件的设计)
1<parent> 2 <groupId>org.springframework.boot</groupId> 3 <artifactId>spring-boot-starter-parent</artifactId> 4 <version>1.4.0.RELEASE</version> 5 </parent> 6 <properties> 7 <java.version>1.7</java.version> 8 <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding> 9 </properties> 10 <dependencies> 11 <dependency> 12 <groupId>org.springframework.boot</groupId> 13 <artifactId>spring-boot-starter</artifactId> 14 </dependency> 15 <dependency> 16 <groupId>org.springframework.boot</groupId> 17 <artifactId>spring-boot-devtools</artifactId> 18 <optional>true</optional> 19 <scope>true</scope> 20 </dependency> 21 <dependency> 22 <groupId>org.springframework.boot</groupId> 23 <artifactId>spring-boot-starter-test</artifactId> 24 <scope>test</scope> 25 </dependency> 26 <dependency> 27 <groupId>org.springframework.boot</groupId> 28 <artifactId>spring-boot-starter-actuator</artifactId> 29 </dependency> 30 <!-- 添加springboot对amqp的支持 --> 31 <dependency> 32 <groupId>org.springframework.boot</groupId> 33 <artifactId>spring-boot-starter-amqp</artifactId> 34 </dependency> 35 <dependency> 36 <groupId>org.springframework.boot</groupId> 37 <artifactId>spring-boot-starter-tomcat</artifactId> 38 <scope>provided</scope> 39 </dependency> 40 <dependency> 41 <groupId>org.apache.tomcat.embed</groupId> 42 <artifactId>tomcat-embed-jasper</artifactId> 43 <scope>provided</scope> 44 </dependency> 45 </dependencies>
紧接着,我们编写发送者相关的代码.首先毫无疑问,要书写启动类:
1@SpringBootApplication 2public class App{ 3 public static void main(String[] args) { 4 SpringApplication.run(App.class, args); 5 } 6}
接着在application.properties中,去编辑和RabbitMQ相关的配置信息,配置信息的代表什么内容根据键就能很直观的看出了.这里端口是5672,不是15672...15672是管理端的端口!
1spring.application.name=spirng-boot-rabbitmq-sender 2spring.rabbitmq.host=127.0.0.1 3spring.rabbitmq.port=5672 4spring.rabbitmq.username=guest 5spring.rabbitmq.password=guest
随后,配置Queue(消息队列).那注意由于采用的是Direct模式,需要在配置Queue的时候,指定一个键,使其和交换机绑定.
1@Configuration 2public class SenderConf { 3 @Bean 4 public Queue queue() { 5 return new Queue("queue"); 6 } 7}
接着就可以发送消息啦!在SpringBoot中,我们使用AmqpTemplate去发送消息!代码如下:
1@Component 2public class HelloSender { 3 @Autowired 4 private AmqpTemplate template; 5 6 public void send() { 7 template.convertAndSend("queue","hello,rabbit~"); 8 } 9}
编写测试类!这样我们的发送端代码就编写完了~
1@SpringBootTest(classes=App.class) 2@RunWith(SpringJUnit4ClassRunner.class) 3public class TestRabbitMQ { 4 5 @Autowired 6 private HelloSender helloSender; 7 8 @Test 9 public void testRabbit() { 10 helloSender.send(); 11 } 12}
接着我们编写接收端.接收端的pom文件,application.properties(修改spring.application.name),Queue配置类,App启动类都是一致的!这里省略不计.主要在于我们需要配置监听器去监听绑定到的消息队列,当消息队列有消息的时候,予以接收,代码如下:
1@Component 2public class HelloReceive { 3 4 @RabbitListener(queues="queue") //监听器监听指定的Queue 5 public void processC(String str) { 6 System.out.println("Receive:"+str); 7 } 8 9}
接下来就可以测试啦,首先启动接收端的应用,紧接着运行发送端的单元测试,接收端应用打印出来接收到的消息,测试即成功!
需要注意的地方,Direct模式相当于一对一模式,一个消息被发送者发送后,会被转发到一个绑定的消息队列中,然后被一个接收者接收!
实际上RabbitMQ还可以支持发送对象:当然由于涉及到序列化和反序列化,该对象要实现Serilizable接口.HelloSender做出如下改写:
1public void send() { 2 3 User user=new User(); //实现Serializable接口 4 user.setUsername("hlhdidi"); 5 user.setPassword("123"); 6 template.convertAndSend("queue",user); 7 8}
HelloReceiver做出如下改写:
1@RabbitListener(queues="queue") //监听器监听指定的Queue 2 public void process1(User user) { //用User作为参数 3 System.out.println("Receive1:"+user); 4 }
三.SpringBoot整合RabbitMQ(Topic转发模式)
首先我们看发送端,我们需要配置队列Queue,再配置交换机(Exchange),再把队列按照相应的规则绑定到交换机上:
1@Configuration 2public class SenderConf { 3 4 @Bean(name="message") 5 public Queue queueMessage() { 6 return new Queue("topic.message"); 7 } 8 9 @Bean(name="messages") 10 public Queue queueMessages() { 11 return new Queue("topic.messages"); 12 } 13 14 @Bean 15 public TopicExchange exchange() { 16 return new TopicExchange("exchange"); 17 } 18 19 @Bean 20 Binding bindingExchangeMessage(@Qualifier("message") Queue queueMessage, TopicExchange exchange) { 21 return BindingBuilder.bind(queueMessage).to(exchange).with("topic.message"); 22 } 23 24 @Bean 25 Binding bindingExchangeMessages(@Qualifier("messages") Queue queueMessages, TopicExchange exchange) { 26 return BindingBuilder.bind(queueMessages).to(exchange).with("topic.#");//*表示一个词,#表示零个或多个词 27 } 28}
而在接收端,我们配置两个监听器,分别监听不同的队列:
1@RabbitListener(queues="topic.message") //监听器监听指定的Queue 2 public void process1(String str) { 3 System.out.println("message:"+str); 4 } 5 @RabbitListener(queues="topic.messages") //监听器监听指定的Queue 6 public void process2(String str) { 7 System.out.println("messages:"+str); 8 }
好啦!接着我们可以进行测试了!首先我们发送如下内容:
方法的第一个参数是交换机名称,第二个参数是发送的key,第三个参数是内容,RabbitMQ将会根据第二个参数去寻找有没有匹配此规则的队列,如果有,则把消息给它,如果有不止一个,则把消息分发给匹配的队列(每个队列都有消息!),显然在我们的测试中,参数2匹配了两个队列,因此消息将会被发放到这两个队列中,而监听这两个队列的监听器都将收到消息!那么如果把参数2改为topic.messages呢?显然只会匹配到一个队列,那么process2方法对应的监听器收到消息!
四.SpringBoot整合RabbitMQ(Fanout Exchange形式)
那前面已经介绍过了,Fanout Exchange形式又叫广播形式,因此我们发送到路由器的消息会使得绑定到该路由器的每一个Queue接收到消息,这个时候就算指定了Key,或者规则(即上文中convertAndSend方法的参数2),也会被忽略!那么直接上代码,发送端配置如下:
1@Configuration 2public class SenderConf { 3 4 @Bean(name="Amessage") 5 public Queue AMessage() { 6 return new Queue("fanout.A"); 7 } 8 9 10 @Bean(name="Bmessage") 11 public Queue BMessage() { 12 return new Queue("fanout.B"); 13 } 14 15 @Bean(name="Cmessage") 16 public Queue CMessage() { 17 return new Queue("fanout.C"); 18 } 19 20 @Bean 21 FanoutExchange fanoutExchange() { 22 return new FanoutExchange("fanoutExchange");//配置广播路由器 23 } 24 25 @Bean 26 Binding bindingExchangeA(@Qualifier("Amessage") Queue AMessage,FanoutExchange fanoutExchange) { 27 return BindingBuilder.bind(AMessage).to(fanoutExchange); 28 } 29 30 @Bean 31 Binding bindingExchangeB(@Qualifier("Bmessage") Queue BMessage, FanoutExchange fanoutExchange) { 32 return BindingBuilder.bind(BMessage).to(fanoutExchange); 33 } 34 35 @Bean 36 Binding bindingExchangeC(@Qualifier("Cmessage") Queue CMessage, FanoutExchange fanoutExchange) { 37 return BindingBuilder.bind(CMessage).to(fanoutExchange); 38 } 39 40}
发送端使用如下代码发送:
接收端监听器配置如下:
1@Component 2public class HelloReceive { 3 @RabbitListener(queues="fanout.A") 4 public void processA(String str1) { 5 System.out.println("ReceiveA:"+str1); 6 } 7 @RabbitListener(queues="fanout.B") 8 public void processB(String str) { 9 System.out.println("ReceiveB:"+str); 10 } 11 @RabbitListener(queues="fanout.C") 12 public void processC(String str) { 13 System.out.println("ReceiveC:"+str); 14 } 15 16 17}
运行测试代码,发现三个监听器都接收到了数据,测试成功!