RabbitMQ消息队列基础概念、原理学习

  • 2019 年 11 月 5 日
  • 笔记

使用RabbitMQ实现解耦合的设计,对添加代码是开发的,对修改代码是关闭的。

1、什么是生产者Provider?

  答:消息生产者,就是投递消息的程序。

2、什么是消费者Consumer?

  答:消息消费者,就是接受消息的程序。

3、没有使用消息队列时消息传递方式。

4、使用消息队列后消息传递方式。

5、什么是队列?

  答:队列就像存放了商品的仓库或者商店,是生产商品的工厂和购买商品的用户之间的中转站。

6、队列里存储了什么?

  答:在RabbitMQ 中,信息流从你的应用程序出发,来到 Rabbitmq 的队列,所有信息可以只存储在一个队列中。队列可以存储很多信息,因为它基本上是一个无限制的缓冲区,前提是你的机器有足够的存储空间。

7、队列和应用程序的关系?

  答:多个生产者可以将消息发送到同一个队列中,多个消息者也可以只从同一个队列接收数据。

8、RabbitMQ的生产者消费者模型、使用SpringBoot搭建。由于创建的SpringBoot项目,使用Maven。依赖包如下所示:

 1 <?xml version="1.0" encoding="UTF-8"?>   2 <project xmlns="http://maven.apache.org/POM/4.0.0"   3     xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"   4     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0   5     https://maven.apache.org/xsd/maven-4.0.0.xsd">   6     <modelVersion>4.0.0</modelVersion>   7     <parent>   8         <groupId>org.springframework.boot</groupId>   9         <artifactId>spring-boot-starter-parent</artifactId>  10         <version>2.1.1.RELEASE</version>  11         <relativePath /> <!-- lookup parent from repository -->  12     </parent>  13     <groupId>com.bie</groupId>  14     <artifactId>rabbitmq</artifactId>  15     <version>0.0.1-SNAPSHOT</version>  16     <name>rabbitmq</name>  17     <description>Demo project for Spring Boot</description>  18  19     <properties>  20         <java.version>1.8</java.version>  21     </properties>  22  23     <dependencies>  24         <dependency>  25             <groupId>org.springframework.boot</groupId>  26             <artifactId>spring-boot-starter</artifactId>  27         </dependency>  28         <dependency>  29             <groupId>org.springframework.boot</groupId>  30             <artifactId>spring-boot-starter-web</artifactId>  31         </dependency>  32         <dependency>  33             <groupId>org.springframework.boot</groupId>  34             <artifactId>spring-boot-starter-test</artifactId>  35             <scope>test</scope>  36         </dependency>  37         <dependency>  38             <groupId>org.springframework.boot</groupId>  39             <artifactId>spring-boot-starter-amqp</artifactId>  40         </dependency>  41     </dependencies>  42  43     <build>  44         <plugins>  45             <plugin>  46                 <groupId>org.springframework.boot</groupId>  47                 <artifactId>spring-boot-maven-plugin</artifactId>  48             </plugin>  49         </plugins>  50     </build>  51  52 </project>

配置你的SpringBoot的配置文件application.properties。

 1 # 给当前项目起名称.   2 spring.application.name=rabbitmq   3   4 # 配置rabbitmq的参数.   5 # rabbitmq服务器的ip地址.   6 spring.rabbitmq.host=192.168.110.133   7 # rabbitmq的端口号5672,区别于浏览器访问界面的15672端口号.   8 spring.rabbitmq.port=5672   9 # rabbitmq的账号.  10 spring.rabbitmq.username=guest  11 # rabbitmq的密码.  12 spring.rabbitmq.password=guest  13  14 # 队列的名称  15 rabbitmq.queue=queue001

然后,创建一个队列,创建的队列,在项目启动的时候加载,这样使用队列的时候就可以直接使用。

 1 package com.example.bie.config;   2   3 import org.springframework.amqp.core.Queue;   4 import org.springframework.beans.factory.annotation.Value;   5 import org.springframework.context.annotation.Bean;   6 import org.springframework.context.annotation.Configuration;   7   8 /**   9  *  10  * @author biehl  11  *  12  * @Configuration项目启动加载本类  13  *  14  */  15 @Configuration  16 public class RabbitMqQueueConfig {  17  18     @Value("${rabbitmq.queue}")  19     private String queueName;  20  21     /**  22      * 创建一个队列  23      *  24      * @return  25      */  26     @Bean  27     public Queue createQueue() {  28         return new Queue(this.queueName);  29     }  30  31 }

然后,创建一个Rabbitmq的生产者,生产消息,这里使用传入参数的方法生产消息。可以测试单条消息和多条消息。

 1 package com.example.bie.rabbitmq.producer;   2   3 import org.springframework.amqp.core.AmqpTemplate;   4 import org.springframework.beans.factory.annotation.Autowired;   5 import org.springframework.beans.factory.annotation.Value;   6 import org.springframework.stereotype.Component;   7   8 /**   9  *  10  * @author biehl  11  *  12  *         RabbitmqProducer消息发送者  13  *  14  * @Component加入到容器中.  15  *  16  */  17 @Component  18 public class RabbitmqProducer {  19  20     @Autowired  21     private AmqpTemplate rabbitmqAmqpTemplate;  22  23     @Value("${rabbitmq.queue}")  24     private String queueName;  25  26     /**  27      * 发送消息的方法  28      */  29     public void producer(String msg) {  30         // 向消息队列中发送消息  31         // 参数1,队列的名称  32         // 参数2,发送的消息  33         this.rabbitmqAmqpTemplate.convertAndSend(this.queueName, msg);  34     }  35  36 }

创建消费者消费消息,由于使用的是消费事件监听器,这里使用注解方式,一旦发现队列里面的消息发生变化,就触发该事件,从而触发方法进行消息的消费。

 1 package com.example.bie.rabbitmq.consumer;   2   3 import org.springframework.amqp.rabbit.annotation.RabbitListener;   4 import org.springframework.beans.factory.annotation.Value;   5 import org.springframework.stereotype.Component;   6   7 /**   8  *   9  * @author biehl  10  *  11  *         RabbitmqConsumer消息消费者  12  *  13  *         消费者是根据消息队列的监听器,进行消息的接收和消费。  14  *  15  *         消息队列发生变化,消息事件就会产生,触发方法进行消息的接收。  16  *  17  */  18 @Component  19 public class RabbitmqConsumer {  20  21     @Value("${rabbitmq.queue}")  22     private String queueName;  23  24     /**  25      * 消费者消费消息,接受消息的方法,采用消息队列监听机制.  26      *  27      * @RabbitListener  28      *  29      *                 意思是当队列发生变化,消息事件产生了或者生产者发送消息了。  30      *  31      *                 马上就会触发这个方法,进行消息的消费。  32      */  33     @RabbitListener(queues = "queue001")  34     public void consumer(String msg) {  35         // 打印消息  36         System.out.println("消费者===>消费<===消息message: " + msg);  37     }  38  39 }

创建完毕队列,生产者,消费者,配置好配置文件,可以使用单元测试,或者使用Controller的方式进行测试。由于使用单元测试,SpringBoot项目停止,就无法进行消费,不方便测试,这里使用web容器进行测试,创建一个Controller,页面访问进行触发方法的执行。当生产者生产消息多的时候可以在浏览器进行观察生产、消费的效果。

 1 package com.example.bie.controller;   2   3 import org.springframework.beans.factory.annotation.Autowired;   4 import org.springframework.stereotype.Controller;   5 import org.springframework.web.bind.annotation.RequestMapping;   6 import org.springframework.web.bind.annotation.ResponseBody;   7   8 import com.example.bie.rabbitmq.producer.RabbitmqProducer;   9  10 /**  11  *  12  * @author biehl  13  *  14  */  15 @Controller  16 public class RabbitmqController {  17  18     @Autowired  19     private RabbitmqProducer rabbitmqProducer;  20  21     @RequestMapping(value = "/sendMessage")  22     @ResponseBody  23     public void rabbitmqSendMessage() {  24         String msg = "消息产===>生者<===消息message: ";  25         for (int i = 0; i < 100000; i++) {  26             rabbitmqProducer.producer(msg + i);  27         }  28     }  29  30 }

最后就可以启动你的SpringBoot项目了。

 1 package com.example;   2   3 import org.springframework.boot.SpringApplication;   4 import org.springframework.boot.autoconfigure.SpringBootApplication;   5   6 @SpringBootApplication   7 public class RabbitmqApplication {   8   9     public static void main(String[] args) {  10         SpringApplication.run(RabbitmqApplication.class, args);  11     }  12  13 }

运行效果如下所示:

9、RabbitMQ原理理解,概念的理解。

1)、RabbitMQ的消息Message。

  消息。消息是不具名的,它由消息头、消息体组成。消息体是不透明的,而消息头则由一系列可选属性组成,这些属性包括:routing-key(路由键)、priority(相对于其他消息的优先权)、delivery-mode(指出消息可能持久性存储)等。

2)、RabbitMQ的生产者Provider或者Publisher。

  消息的生产者。也是一个向交换器发布消息的客户端应用程序。

3)、RabbitMQ的消费者Consumer。

  消息的消费者。表示一个从消息队列中取得消息的客户端应用程序。

4)、RabbitMQ的交换器或者称为交换机Exchange。

  交换器。用来接收生产者发送的消息并将这些消息路由给服务器中的队列。三种常用的交换器类型,包含,direct(发布与订阅 完全匹配,默认使用)、fanout(广播)、topic(主题,规则匹配)。

5)、RabbitMQ的绑定Binding。

  绑定。用于消息队列Queue和交换器Exchange之间的关联。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则,所以可以将交换器理解成一个由绑定构成的路由表。

6)、RabbitMQ的消息队列Queue。

  消息队列。用来保存消息直到发送给消费者。它是消息的容器,也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面,等待消费者链接到这个队列将其取走。

7)、RabbitMQ的路由键Routing-key。

  路由键。RabbitMQ 决定消息该投递到哪个队列的规则。队列通过路由键绑定到交换器。消息发送到 MQ 服务器时,消息将拥有一个路由键,即便是空的,RabbitMQ 也会将其和绑定使用的路由键进行匹配。如果相匹配,消息将会投递到该队列。如果不匹配,消息将会进入黑洞。

8)、RabbitMQ的链接Connection。

  链接。指Rabbitmq 服务器和服务建立的 TCP 链接。

9)、RabbitMQ的信道Channel。

  信道。

a、Channel 中文叫做信道,是 TCP 里面的虚拟链接。例如:电缆相当于 TCP,信道是一个独立光纤束,一条 TCP 连接上创建多条信道是没有问题的。

b、TCP 一旦打开,就会创建 AMQP 信道。c、无论是发布消息、接收消息、订阅队列,这些动作都是通过信道完成的。

10)、RabbitMQ的虚拟主机Virtual Host。

  虚拟主机。表示一批交换器,消息队列和相关对象。虚拟主机是共享相同的身份认证和加密环境的独立服务器域。每个 vhost 本质上就是一个 mini 版的 RabbitMQ 服务器,拥有自己的队列、交换器、绑定和权限机制。vhost 是 AMQP 概念的基础,必须在链接时指定, RabbitMQ 默认的 vhost 是/。

11)、RabbitMQ的消息队列服务器实体Borker。

  表示消息队列服务器实体。

12)、RabbitMQ交换器和队列的关系。

  交换器是通过路由键和队列绑定在一起的,如果消息拥有的路由键跟队列和交换器的路由键匹配,那么消息就会被路由到该绑定的队列中。   也就是说,消息到队列的过程中,消息首先会经过交换器,接下来交换器在通过路由键匹配分发消息到具体的队列中。   路由键可以理解为匹配的规则。

13)、RabbitMQ 为什么需要信道?为什么不是 TCP 直接通信?

  TCP 的创建和销毁开销特别大。创建需要 3 次握手,销毁需要 4 次分手。   如果不用信道,那应用程序就会以 TCP 链接 Rabbit,高峰时每秒成千上万条链接会造成资源巨大的浪费,而且操作系统每秒处理 TCP 链接数也是有限制的,必定造成性能瓶颈。   信道的原理是一条线程一条通道,多条线程多条通道同用一条 TCP 链接。一条 TCP 链接可以容纳无限的信道,即使每秒成千上万的请求也不会成为性能的瓶颈。

10、RabbitMQ的架构设计,如下图所示。