十次方——RabbitMQ之介绍

矫情吗；* 2022-03-01 05:30 321阅读 0赞

# 一  RabbitMQ简介 #

### 1.1  消息队列中间件 ###

消息队列中间件是分布式系统中重要的组件，主要解决应用耦合，异步消息，流量削锋等问题实现高性能，高可用，可伸缩和最终一致性\[架构\]

使用较多的消息队列有ActiveMQ，RabbitMQ，ZeroMQ，Kafka，MetaMQ，RocketMQ。其使用场景为：异步处理，应用解耦，流量削锋和消息通讯四个场景。

### 1.2  什么是RabbitMQ ###

RabbitMQ 是一个由 Erlang 语言开发的 AMQP 的开源实现。

AMQP ：Advanced Message Queue，高级消息队列协议。它是应用层协议的一个开放标准，为面向消息的中间件设计，基于此协议的客户端与消息中间件可传递消息，并不受产品、开发语言等条件的限制。

RabbitMQ 最初起源于金融系统，用于在分布式系统中存储转发消息，在易用性、扩展性、高可用性等方面表现不俗。具体特点包括：

1.  **可靠性(Reliability)**：RabbitMQ 使用一些机制来保证可靠性，如持久化、传输确认、发布确认。
2.  **灵活的路由(Flexible Routing)**：在消息进入队列之前，通过 Exchange 来路由消息的。对于典型的路由功能，RabbitMQ已经提供了一些内置的 Exchange 来实现。针对更复杂的路由功能，可以将多个Exchange 绑定在一起，也通过插件机制实现自己的 Exchange 。
3.  **消息集群(Clustering)**：多个 RabbitMQ 服务器可以组成一个集群，形成一个逻辑 Broker 。
4.  **高可用(Highly Available Queues)**：队列可以在集群中的机器上进行镜像，使得在部分节点出问题的情况下队列仍然可用。
5.  **多种协议(Multi-protocol)**：RabbitMQ 支持多种消息队列协议，比如 STOMP、MQTT 等等。
6.  **多语言客户端(Many Clients)**：RabbitMQ 几乎支持所有常用语言，比如 Java、.NET、Ruby 等等。
7.  **管理界面(Management UI)**：RabbitMQ 提供了一个易用的用户界面，使得用户可以监控和管理消息 Broker 的许多方  
    面。
8.  **跟踪机制(Tracing)**：如果消息异常，RabbitMQ 提供了消息跟踪机制，使用者可以找出发生了什么。
9.  **插件机制(Plugin System)**：RabbitMQ 提供了许多插件，来从多方面进行扩展，也可以编写自己的插件

### 1.3  架构图 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70][]

### 1.4  主要概念 ###

**RabbitMQ** **Server**： 也叫broker server，它是一种传输服务。 他的角色就是维护一条从Producer到Consumer的路线，保证数据能够按照指定的方式进行传输。

**Producer**： 消息生产者，如图A、B、C，数据的发送方。消息生产者连接RabbitMQ服务器然后将消息投递到Exchange。

**Consumer**：消息消费者，如图1、2、3，数据的接收方。消息消费者订阅队列，RabbitMQ将Queue中的消息发送到消息消费者。

**Exchange**：生产者将消息发送到Exchange（交换器），由Exchange将消息路由到一个或多个Queue中（或者丢弃）。Exchange并不存储消息。RabbitMQ中的Exchange有direct、fanout、topic、headers四种类型，每种类型对应不同的路由规则。

**Queue**：（队列）是RabbitMQ的内部对象，用于存储消息。消息消费者就是通过订阅队列来获取消息的，RabbitMQ中的消息都只能存储在Queue中，生产者生产消息并最终投递到Queue中，消费者可以从Queue中获取消息并消费。多个消费者可以订阅同一个Queue，这时Queue中的消息会被平均分摊给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理。

**RoutingKey**：生产者在将消息发送给Exchange的时候，一般会指定一个routing key，来指定这个消息的路由规则，而这个routing key需要与Exchange Type及binding key联合使用才能最终生效。在Exchange Type与binding key固定的情况下（在正常使用时一般这些内容都是固定配置好的），我们的生产者就可以在发送消息给Exchange时，通过指定routing key来决定消息流向哪里。RabbitMQ为routing key设定的长度限制为255bytes，

**Connection**： （连接）：Producer和Consumer都是通过TCP连接到RabbitMQ Server的。以后我们可以看到，程序的起始处就是建立这个TCP连接。

**Channels**： （信道）：它建立在上述的TCP连接中。数据流动都是在Channel中进行的。也就是说，一般情况是程序起始建立TCP连接，第二步就是建立这个Channel。

**VirtualHost**：权限控制的基本单位，一个VirtualHost里面有若干Exchange和MessageQueue，以及指定被哪些user使用

# 二  RabbitMQ安装 #

安装看我这篇博文： [十次方——Linux部分][Linux]

# 三   RabbitMQ三种模式 #

## 3.1 直接模式 ##

### 3.1.1  介绍 ###

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 1][]

我们需要将消息发给唯一一个节点时使用这种模式，这是最简单的一种形式。

任何发送到Direct Exchange的消息都会被转发到RouteKey中指定的Queue。

1.  一般情况可以使用rabbitMQ自带的Exchange：”"(该Exchange的名字为空字符串，下文称其为default Exchange)。
2.  这种模式下不需要将Exchange进行任何绑定(binding)操作
3.  消息传递时需要一个“RouteKey”，可以简单的理解为要发送到的队列名字。
4.  如果vhost中不存在RouteKey中指定的队列名，则该消息会被抛弃。

### 3.1.2  创建队列 ###

首先在浏览器登录RabbitMQ：[http://192.168.2XX.129:15672][http_192.168.2XX.129_15672] ，按照下图创建一个队列就可以了

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 2][]

![20190325144609244.png][]

### 3.1.3   写代码 ###

接下来开始写代码，准备工作还是老三套，jar包，配置文件与启动类（我们这只是一个测试队列模式的模块，在后面无需在十次方项目里面进行集成，所以像配置文件里面的端口号，名字啥都可以不写）

![20190325150107251.png][]

![20190325150111944.png][]

![20190325150115782.png][]

接下来我们写生产者代码（生产者采用Junit和SpringBoot整合），在test->java目录下

package com.tensquare.test;
    
    import com.tensquare.rabbit.RabbitApplication;
    import org.junit.Test;
    import org.junit.runner.RunWith;
    import org.springframework.amqp.rabbit.core.RabbitTemplate;
    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.boot.test.context.SpringBootTest;
    import org.springframework.test.context.junit4.SpringRunner;
    
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = RabbitApplication.class)
    public class ProductTest {
    
        @Autowired
        private RabbitTemplate rabbitTemplate;
    
        @Test
        public void sendMsg(){
            rabbitTemplate.convertAndSend("itcast","直接模式测试");
        }
    }

此时你运行生产者函数时，在消息队列的界面会显示一条消息（Ready）

消费者代码，在mian->java目录下

package com.tensquare.rabbit.customer;
    
    
    import org.springframework.amqp.rabbit.annotation.RabbitHandler;
    import org.springframework.amqp.rabbit.annotation.RabbitListener;
    import org.springframework.stereotype.Component;
    
    @Component
    @RabbitListener(queues = "itcast")
    public class Customer1 {
    
        @RabbitHandler
        public void getMsg(String msg){
            System.out.println("111直接模式消费消息"+msg);
        }
    }

当你运行消费者代码时，在run栏会打印出：

![20190325154721641.png][]

当然，你想设置多个消费者时，我们可以将springboot单例运行选项去掉

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 3][]

然后改掉配置文件的端口号，重新把程序跑一次，这样，就有两个消费者了，再改端口号，再运行就是三个消费者了。多运行几次生产者的测试函数，三个消费者会轮流输出（因为这里是默认负载均衡的，所有会轮流输出）。

## 3.2  分裂模式 ##

### 3.2.1   介绍 ###

当我们需要将消息一次发给多个队列时，需要使用这种模式。如下图：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 4][]

任何发送到Fanout Exchange的消息都会被转发到与该Exchange绑定(Binding)的所有Queue上。

1.  可以理解为路由表的模式
2.  这种模式不需要RouteKey
3.  这种模式需要提前将Exchange与Queue进行绑定，一个Exchange可以绑定多个Queue，一个Queue可以同多个Exchange进行绑定。
4.  如果接受到消息的Exchange没有与任何Queue绑定，则消息会被抛弃。

### 3.2.2   交换器绑定队列 ###

先创建三个队列itcast，itheima，kudingyu

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 5][]

创建chuanzhi交换器

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 6][]

将chuanzhi交换器与三个队列绑定

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 7][]

这样向chuanzhi交换器里发消息，交换器就会向绑定的三个消息队列里面发消息（）。

## ##

### 3.2.3  代码实现 ###

生产者

package com.tensquare.test;
    
    //省略
    
    @RunWith(SpringRunner.class)
    @SpringBootTest(classes = RabbitApplication.class)
    public class ProductTest {
    
        @Autowired
        private RabbitTemplate rabbitTemplate;
    
        @Test
        public void sendMsg2(){
            rabbitTemplate.convertAndSend("chuanzhi","","分裂模式测试");
        }
    }

消费者1，2，3

@Component
    @RabbitListener(queues = "itcast")
    public class Customer1 {
        @RabbitHandler
        public void getMsg(String msg){
            System.out.println("itcast："+msg);
        }
    }

@Component
    @RabbitListener(queues = "itheima")
    public class Customer2 {
        @RabbitHandler
        public void getMsg(String msg){
            System.out.println("itheima："+msg);
        }
    }

@Component
    @RabbitListener(queues = "kudingyu")
    public class Customer3 {
        @RabbitHandler
        public void getMsg(String msg){
            System.out.println("kudingyu："+msg);
        }
    }

运行后可得下面结果

![20190325205516445.png][]

## 3.3  主题模式 ##

### 3.3.1  介绍 ###

任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定话题的Queue上

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 8][]

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 9][]

如上图所示此类交换器使得来自不同的源头的消息可以到达一个对列，其实说的更明白一点就是模糊匹配的意思，例如：上图中红色对列的routekey为usa.\#，\#代表匹配任意字符，但是要想消息能到达此对列，usa.必须匹配后面的\#好可以随意。图中usa.newsusa.weather,都能找到红色队列，符号 \# 匹配一个或多个词，符号 \* 匹配不多不少一个词。因此 usa.\# 能够匹配到 usa.news.XXX ，但是 usa.\* 只会匹配到 usa.XXX 。

注：  
交换器说到底是一个名称与队列绑定的列表。当消息发布到交换器时，实际上是由你所连接的信道，将消息路由键同交换器上绑定的列表进行比较，最后路由消息。任何发送到Topic Exchange的消息都会被转发到所有关心RouteKey中指定话题的Queue上

1.  这种模式较为复杂，简单来说，就是每个队列都有其关心的主题，所有的消息都带有一个“标题”(RouteKey)，Exchange会将消息转发到所有关注主题能与RouteKey模糊匹配的队列。
2.  这种模式需要RouteKey，也许要提前绑定Exchange与Queue。
3.  在进行绑定时，要提供一个该队列关心的主题，如“\#.log.\#”表示该队列关心所有涉及log的消息(一个RouteKey为”MQ.log.error”的消息会被转发到该队列)。
4.  “\#”表示0个或若干个关键字，“”表示一个关键字。如“log.”能与“log.warn”匹配，无法与“log.warn.timeout”匹配；但是“log.\#”能与上述两者匹配。
5.  同样，如果Exchange没有发现能够与RouteKey匹配的Queue，则会抛弃此消息

## ##

### 3.3.2  创建队列与绑定 ###

和分裂模式一样，只是在Exchanges设置里面添加Routing  Key

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 10][]

### 3.3.3   代码编写 ###

和分裂模式一样，只需要在3个Customer类里面修改下convertAndSend的参数就可以了

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 11][]

最后，控制台显示

![20190325214352222.png][]

只有itcast接收到了消息

所以可以看到，主题模式是加强版的分裂模式，它多了RoutingKey

# 四  普通用户和后台用户的区别 #

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 12][]

#      #

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70]: /images/20220301/6721fb4ff4194f9ca966ff1f6f4156a2.png
[Linux]: https://blog.csdn.net/qq_36582604/article/details/88742137
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 1]: /images/20220301/6a7d8d319a904f9bb8c45e84a9b38bc7.png
[http_192.168.2XX.129_15672]: http://192.168.228.129:15672
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 2]: /images/20220301/53291511d2de472590b5496f6f039a8b.png
[20190325144609244.png]: /images/20220301/e1f027276a3c4432b416a651bbf4ea37.png
[20190325150107251.png]: /images/20220301/e606445a159a4ea288861078216db687.png
[20190325150111944.png]: /images/20220301/eb9ca6acc999498d9d5bfc002bdffc1e.png
[20190325150115782.png]: /images/20220301/6ed1cc3dd10d4f39919e9f47a629af60.png
[20190325154721641.png]: /images/20220301/131b3658b95c450ba611d72cb7eb51e4.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 3]: /images/20220301/d0893a7cb21c4b6ab11f2ce0b35cad8e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 4]: /images/20220301/51894e487c5d48e7a1980ac7d4fe1a48.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 5]: /images/20220301/3b3f14bd90ae42a3ae751a463ed78902.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 6]: /images/20220301/e20390448cc5438eae6931e3499f2bf3.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 7]: /images/20220301/03a0494794784e7084bbe44c974628ef.png
[20190325205516445.png]: /images/20220301/76e4e0ee4e014aec9f86346425337110.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 8]: /images/20220301/83f78f1587cc4f8f879214752a706b5e.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 9]: /images/20220301/b3b191c5ffda4b3aa1fa9ca1c4f3c1dd.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 10]: /images/20220301/a5a8056a23fe4a3799b1f651ee7656ef.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 11]: /images/20220301/98a20701b61a497181b54f61e76f572e.png
[20190325214352222.png]: /images/20220301/17d065ff5232453f8ff1d004959ac45c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzM2NTgyNjA0_size_16_color_FFFFFF_t_70 12]: /images/20220301/23cbd171eafd48d5b21c654dfb77872d.png