Rabbitmq---消息队列

时间 2019-11-08

标签 rabbitmq 消息队列栏目 RabbitMQ 繁體版

原文原文链接

一 . MQ:message queue

　　消息队列的做用: 　　1 通讯解耦　　2 高峰限流html

原理分析:web

一开始,认证系统是强耦合的,A系统传递认证系统消息接收计算结果的过程当中spring

　　1 传给认证系统springboot

　　2 认证系统计算服务器

　　3 返回计算结果并发

　　4 读取A系统逻辑app

只要当前计算没有完成,对于认证系统来说消耗线程资源.并存在强耦合现象框架

有了消息队列,每一次链接无论是生成消息仍是消费消息,都有各自的逻辑与其余逻辑无关--通讯解耦异步

　　通讯强耦合的状况下高峰访问拒绝,达到了高峰限流的效果maven

二 . Rabbitmq

　　1 rabbitmq的结构(组件)

　　　外部: 生产者和消费者

　　　　生产者:对于消息来说,生成消息客户端是生产者

　　　　消费者:消费消息执行消费后的逻辑的客户端是消费者

　　客户端能够使用各类其余技术或者语言都不是rabbitmq自身的技术

　　2 rabbitmq内部组件

　　connection:基于底层通讯逻辑的长链接

　　channel:基于长链接建立的;能够在一次长链接的基础上屡次频繁的建立和销毁,占用资源很是少

　　交换机Exchange 优势:并发能力高并发稳定

　　　　客户端链接发送消息,多种状况都须要并发的发送,若是从客户端执行并发的发送逻辑,rabbitmq的并发能力就限制在了客户端

　　　　exchange基于erlang语言开发的(并发,可控制线程)

　　queue:rabbitmq中的队列,根据不一样的状况队列能够完成不一样的工做

　　使用场景:在项目中，将一些无需即时返回且耗时的操做提取出来，进行了异步处理，而这种异步处理的方式大大的节省了服务器的请求响应时间，从而提升了系统的吞吐量。

三 . rabbitmq的五种工做模式

　　1 简单模式

　　1 )一个生产者将消息交给默认的交换机(AMQP default)

　　2 )交换机获取消息后交给绑定的这个生产者的队列(其中关系是经过队列名称完成的)

　　3 )监听当前队列的消费者获取消息,执行消费逻辑

　　　　应用场景:短信聊天

　　2 工做模式(资源争抢)

　　1 )生产者将消息交给交换机

　　2 )交换机交给绑定的队列

　　3 )队列由多个消费者同时监听,只有其中一个能获取者一条消息,造成了资源的争抢,谁的资源空闲大,争抢到的可能越大

　　3 发布订阅(publish/fanout)

　　1 )生产者扔给交换机消息
　　2 )交换机根据自身的类型(fanout)将会把全部消息复制同步到全部与其绑定的队列
　　3 )每一个队列能够有一个消费者,接收消息进行消费逻辑

　　4 路由模式(routing/dircet)

　　1 )生产者仍是将消息发送给交换机,消息携带具体的路由key(routingKey)

　　2 )交换机类型direct,将接受到消息中的routingKey与之绑定队列的routingKey比对

　　3 )消费者监听一个队列,获取消息,执行消费逻辑.

　　5 topic主题模式

　　1 )生产端发送消息,消息携带具体的路由key
　　2 )交换机的类型topic
　　3 )队列绑定交换机不在使用具体的路由key而是一个范围值

　与路由模式的区别:路由模式中的queue绑定携带的具体的key值,路由细化划分,topic主题模式queue携带的key是一个范围的匹配,某一类消息的获取

四 . rabbitmq的安装及虚拟机和用户名的建立

　　http://www.javashuo.com/article/p-xzaoveyu-bd.html

五 . springboot整合rabbitmq

　整合思路:1 )配置信息 2 )配置类 (明确初始化对象,初始化一个工厂,就从工厂获取链接;生产端逻辑实现简单;) 3 )二次封装

　　springboot
   　　自动配置:扫描同名,下级包
           根据依赖的文件自动配置须要的内容(一旦依赖了jdbc,不配置datasource就报错)
   　　 springboot就会根据依赖的amqp自动建立链接消息队列的内部connection,封装一个对外调用的对象rabbitTemplate模板对象;作生产逻辑
    　　利用底层链接,实现异步非阻塞监听,只须要在方法上使用注解,就能够将监听内容传递给方法的参数;

1 添加依赖
   <starter-amqp>简化依赖
   　　groupId在maven库是一个具备结构的文件夹
   　　 artifactId是一整个文件夹
   　　 version是一个文件夹
   　　 org\springframework\boot\spring-boot-starter-amqp
   　<dependency>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>

2 配置文件(application.properties)

　　    spring.rabbitmq.host=10.9.100.26
   　　 spring.rabbitmq.port=5672
   　　spring.rabbitmq.username=easymall
   　　spring.rabbitmq.password=123456
　　　spring.rabbitmq.virtualHost=/easymall

3 配置文件中声明对象

　　    内部完成各类链接channel等的封装
   　　声明须要的队列和交换机
   　　配置类中完成这种声明,而且交换机,队列的对象由框架维护,什么时候调用由业务逻辑决定;

 1 package com.jt.config;
 2 import org.springframework.amqp.core.Binding;
 3 import org.springframework.amqp.core.BindingBuilder;
 4 import org.springframework.amqp.core.DirectExchange;
 5 import org.springframework.amqp.core.Queue;
 6 import org.springframework.context.annotation.Bean;
 7 import org.springframework.context.annotation.Configuration;
 8 @Configuration
 9 public class RabbitmqConfig {
10     //路由模式作案例
11     //准备2个queue,1个路由交换机
12     //声明2个队列
13     @Bean 
14     public Queue queue01(){
15         //org.springframework.amqp.core.
16         return new Queue("springboot-q1", false);
17     }  
18     @Bean 
19     public Queue queue02(){
20         //org.springframework.amqp.core.
21         return new Queue("springboot-q2", false);
22     } 
23     @Bean//声明交换机
24     public DirectExchange ex(){
25         return new DirectExchange("springboot-ex");
26     }
27     //声明绑定关系
28     @Bean
29     public Binding bind01(){
30         return BindingBuilder.
31                 bind(queue01()).to(ex()).with("item.add");
32     }
33     @Bean
34     public Binding bind02(){
35         return BindingBuilder.
36                 bind(queue02()).to(ex()).with("item.update");}}

4 编写生成者代码

　　 编写到一个controller中,接收访问的参数,利用参数做为消息发送到交换机携带路由key

 1 package com.jt.controller;
 2 
 3 import org.springframework.amqp.rabbit.core.RabbitTemplate;
 4 import org.springframework.beans.factory.annotation.Autowired;
 5 import org.springframework.stereotype.Controller;
 6 import org.springframework.web.bind.annotation.RequestMapping;
 7 import org.springframework.web.bind.annotation.ResponseBody;
 8 
 9 @Controller
10 public class MsgController {
11     @Autowired
12     private RabbitTemplate rabbit;
13     /*
14      * 接收消息msg
15      */
16     @RequestMapping("msg")
17     @ResponseBody
18     public String sendMsg(String msg,String routingKey){
19         //注入自动配置的rabbitTemplate对象发送消息
20         rabbit.convertAndSend("springboot-ex", routingKey, msg);
21         return "success";
22     }
23 }

5 消费端

　　2个消费者,监听2个队列,发送的不一样路由key会在不一样的消费端完成消费逻辑

 1 package com.jt.component;
 2 
 3 import org.springframework.amqp.rabbit.annotation.RabbitListener;
 4 import org.springframework.stereotype.Component;
 5 @Component
 6 public class ConsumerCon {
 7     //实现消费逻辑,须要完成异步监听
 8     //监听注解会绑定队列的消费者和当前的方法,一旦消费者获取消息,会把消息内容传递给
 9     //自定义的方法参数msg
10     @RabbitListener(queues="springboot-q1")
11     public void process01(String msg){
12         System.out.println("消费者1接收商品新增:"+msg);
13     }
14     
15     @RabbitListener(queues="springboot-q2")
16     public void process02(String msg){
17         System.out.println("消费者2接收到商品更新:"+msg);
18     }
19 }