一 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
  2. public class App{
  3. public static void main(String[] args) {
  4. SpringApplication.run(App.class, args);
  5. }
  6. }

  接着在application.properties中,去编辑和RabbitMQ相关的配置信息,配置信息的代表什么内容根据键就能很直观的看出了.这里端口是5672,不是15672...15672是管理端的端口!

  1. spring.application.name=spirng-boot-rabbitmq-sender
  2. spring.rabbitmq.host=127.0.0.1
  3. spring.rabbitmq.port=5672
  4. spring.rabbitmq.username=guest
  5. spring.rabbitmq.password=guest

  随后,配置Queue(消息队列).那注意由于采用的是Direct模式,需要在配置Queue的时候,指定一个键,使其和交换机绑定.

  1. @Configuration
  2. public class SenderConf {
  3. @Bean
  4. public Queue queue() {
  5. return new Queue("queue");
  6. }
  7. }

  接着就可以发送消息啦!在SpringBoot中,我们使用AmqpTemplate去发送消息!代码如下:

  1. @Component
  2. public 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)
  3. public 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
  2. public 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做出如下改写:

  1. public 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
  2. public 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
  2. public class SenderConf {
  3.  
  4. @Bean(name="Amessage")
  5. public Queue AMessage() {
  6. return new Queue("fanout.A");
  7. }
  8.  
  9. @Bean(name="Bmessage")
  10. public Queue BMessage() {
  11. return new Queue("fanout.B");
  12. }
  13.  
  14. @Bean(name="Cmessage")
  15. public Queue CMessage() {
  16. return new Queue("fanout.C");
  17. }
  18.  
  19. @Bean
  20. FanoutExchange fanoutExchange() {
  21. return new FanoutExchange("fanoutExchange");//配置广播路由器
  22. }
  23.  
  24. @Bean
  25. Binding bindingExchangeA(@Qualifier("Amessage") Queue AMessage,FanoutExchange fanoutExchange) {
  26. return BindingBuilder.bind(AMessage).to(fanoutExchange);
  27. }
  28.  
  29. @Bean
  30. Binding bindingExchangeB(@Qualifier("Bmessage") Queue BMessage, FanoutExchange fanoutExchange) {
  31. return BindingBuilder.bind(BMessage).to(fanoutExchange);
  32. }
  33.  
  34. @Bean
  35. Binding bindingExchangeC(@Qualifier("Cmessage") Queue CMessage, FanoutExchange fanoutExchange) {
  36. return BindingBuilder.bind(CMessage).to(fanoutExchange);
  37. }
  38.  
  39. }

  发送端使用如下代码发送:

  接收端监听器配置如下:

  1. @Component
  2. public 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. }

  运行测试代码,发现三个监听器都接收到了数据,测试成功!

springboot学习笔记-6 springboot整合RabbitMQ的更多相关文章

  1. springboot 学习之路 20 (整合RabbitMQ)

    整合RabbitMQ: 我的操作系统是window7 ,所以在整合ribbotMQ之前需要先安装rabbitMq服务:安装步骤请参考:window下安装RabbitMQ  这个详细介绍了安装步骤,请按 ...

  2. SpringBoot学习笔记(4)----SpringBoot中freemarker、thymeleaf的使用

    1. freemarker引擎的使用 如果你使用的是idea或者eclipse中安装了sts插件,那么在新建项目时就可以直接指定试图模板 如图: 勾选freeMarker,此时springboot项目 ...

  3. springboot学习笔记-5 springboot整合shiro

    shiro是一个权限框架,具体的使用可以查看其官网 http://shiro.apache.org/  它提供了很方便的权限认证和登录的功能. 而springboot作为一个开源框架,必然提供了和sh ...

  4. 【转】SpringBoot学习笔记(7) SpringBoot整合Dubbo(使用yml配置)

    http://blog.csdn.net/a67474506/article/details/61640548 Dubbo是什么东西我这里就不详细介绍了,自己可以去谷歌 SpringBoot整合Dub ...

  5. SpringBoot学习笔记(16)----SpringBoot整合Swagger2

    Swagger 是一个规范和完整的框架,用于生成,描述,调用和可视化RESTful风格的web服务 http://swagger.io Springfox的前身是swagger-springmvc,是 ...

  6. SpringBoot学习笔记(11)-----SpringBoot中使用rabbitmq,activemq消息队列和rest服务的调用

    1. activemq 首先引入依赖 pom.xml文件 <dependency> <groupId>org.springframework.boot</groupId& ...

  7. SpringBoot学习笔记(9)----SpringBoot中使用关系型数据库以及事务处理

    在实际的运用开发中,跟数据库之间的交互是必不可少的,SpringBoot也提供了两种跟数据库交互的方式. 1. 使用JdbcTemplate 在SpringBoot中提供了JdbcTemplate模板 ...

  8. SpringBoot学习笔记(6) SpringBoot数据缓存Cache [Guava和Redis实现]

    https://blog.csdn.net/a67474506/article/details/52608855 Spring定义了org.springframework.cache.CacheMan ...

  9. SpringBoot学习笔记(15)----SpringBoot使用Druid

    直接访问Druid官网wiki,有详细教程,地址如下: SpringBoot支持Druid地址:https://github.com/alibaba/druid/tree/master/druid-s ...

随机推荐

  1. itexpdf同一个段落不同文字,如何设置不同的格式

    Java使用itexpdf生成PDF,正常情况下,新建一个段落Paragraph,然后可以给段落添加一个格式BaseFont Paragraph paragraphBlue = new Paragra ...

  2. day30 hashlib模块

    hashlib 提供摘要算法 最常见的就是MD5,当然一般来说MD5已经被足够了 不管算法多不一样,但是摘要的功能是不变的 对于相同的字符串进行摘要,使用同一个算法得到的值总是不变的 不同算法的话,会 ...

  3. MT【16】证明无理数(2)

    证明:$sin10^0$为无理数. 分析:此处用$sin$的三倍角公式,结合多项式有有理根必须满足的系数之间的关系可以证明. 评:证明$sin9^0$为无理数就不那么简单.思路:先利用$sin54^0 ...

  4. 沉迷Link-Cut tree无法自拔之:[BZOJ2049]洞穴勘探(蒟蒻的LCT板子)

    来自蒟蒻 \(Hero \_of \_Someone\) 的 \(LCT\) 学习笔记 最近学了一波 \(LCT\) , 于是怒刷 \(LCT\) 合集...... $ $ 学的时候借鉴了 Clove ...

  5. 【CF961G】Partitions(第二类斯特林数)

    [CF961G]Partitions(第二类斯特林数) 题面 CodeForces 洛谷 题解 考虑每个数的贡献,显然每个数前面贡献的系数都是一样的. 枚举当前数所在的集合大小,所以前面的系数\(p\ ...

  6. py3+requests+re+urllib,爬取并下载不得姐视频

    实现原理及思路请参考我的另外几篇爬虫实践博客 py3+urllib+bs4+反爬,20+行代码教你爬取豆瓣妹子图:http://www.cnblogs.com/UncleYong/p/6892688. ...

  7. 洛谷 P1417烹调方案

    题目大意: 一共有n件食材,每件食材有三个属性,ai,bi和ci,如果在t时刻完成第i样食材则得到ai-t*bi的美味指数,用第i件食材做饭要花去ci的时间. 求最大美味指数之和. 分析: 显然的0/ ...

  8. A1058. A+B in Hogwarts

    If you are a fan of Harry Potter, you would know the world of magic has its own currency system -- a ...

  9. Solr7.1--- 生产环境搭建

    准备三台虚拟机,把Solr-7.1.0.tgz上传到三个节点上.我上传到了自定义的目录/mysoft. 我的环境是CentOS7+Solr7.1.0 如果发现图文不符,因为我之前操作截图后,关闭出去吃 ...

  10. Swing的特性

    1.Swing组件的多样化 2.MVC(model-view-controller)体系结构 3.可存取性支持 4.支持键盘代替鼠标的操作 5.设置边框 6.使用图标 ———————————————— ...