連RabbitMQ的5種核心消息模式都不懂，也敢說本身會用消息隊列！
SpringBoot實戰電商項目mall（35k+star）地址： https://github.com/macrozheng/mall
摘要
之前看過的關於RabbitMQ核心消息模式的文章都是基於JavaAPI的，最近看了下官方文檔，發現這些核心消息模式均可以經過Spring AMQP來實現。因而總結了下RabbitMQ的實用技巧，包括RabbitMQ在Windows和Linux下的安裝、5種核心消息模式的Spring AMQP實現，相信對於想要學習和回顧RabbitMQ的朋友都會有所幫助。html
簡介
RabbitMQ是最受歡迎的開源消息中間件之一，在全球範圍內被普遍應用。RabbitMQ是輕量級且易於部署的，能支持多種消息協議。RabbitMQ能夠部署在分佈式系統中，以知足大規模、高可用的要求。java
相關概念
咱們先來了解下RabbitMQ中的相關概念，這裏以5種消息模式中的路由模式爲例。git
| 標誌 | 中文名 | 英文名 | 描述 |
|---|---|---|---|
| P | 生產者 | Producer | 消息的發送者，能夠將消息發送到交換機 |
| C | 消費者 | Consumer | 消息的接收者，從隊列中獲取消息並進行消費 |
| X | 交換機 | Exchange | 接收生產者發送的消息，並根據路由鍵發送給指定隊列 |
| Q | 隊列 | Queue | 存儲從交換機發來的消息 |
| type | 交換機類型 | type | 不一樣類型的交換機轉發消息方式不一樣 |
| fanout | 發佈/訂閱模式 | fanout | 廣播消息給全部綁定交換機的隊列 |
| direct | 路由模式 | direct | 根據路由鍵發送消息 |
| topic | 通配符模式 | topic | 根據路由鍵的匹配規則發送消息 |
安裝及配置
接下來咱們介紹下RabbitMQ的安裝和配置，提供Windows和Linux兩種安裝方式。
Windows下的安裝
- 安裝Erlang，下載地址：http://erlang.org/download/ot...
- 安裝RabbitMQ，下載地址：https://dl.bintray.com/rabbit...
- 安裝完成後，進入RabbitMQ安裝目錄下的sbin目錄；
- 在地址欄輸入cmd並回車啓動命令行，而後輸入如下命令啓動管理功能。
rabbitmq-plugins enable rabbitmq_management
Linux下的安裝
- 下載
rabbitmq 3.7.15的Docker鏡像；
docker pull rabbitmq:3.7.15
- 使用Docker命令啓動服務；
docker run -p 5672:5672 -p 15672:15672 --name rabbitmq \ -d rabbitmq:3.7.15
- 進入容器並開啓管理功能；
docker exec -it rabbitmq /bin/bash rabbitmq-plugins enable rabbitmq_management
- 開啓防火牆便於外網訪問。
firewall-cmd --zone=public --add-port=15672/tcp --permanent firewall-cmd --zone=public --add-port=5672/tcp --permanent firewall-cmd --reload
訪問及配置
- 訪問RabbitMQ管理頁面地址，查看是否安裝成功（Linux下使用服務器IP訪問便可）：http://localhost:15672/
- 輸入帳號密碼並登陸，這裏使用默認帳號密碼登陸：guest guest
- 建立賬號並設置其角色爲管理員：mall mall
- 建立一個新的虛擬host爲：/mall
- 點擊mall用戶進入用戶配置頁面；
- 給mall用戶配置該虛擬host的權限；
- 至此，RabbitMQ的配置完成。
5種消息模式
這5種消息模式是構建基於RabbitMQ的消息應用的基礎，必定要緊緊掌握它們。學過RabbitMQ的朋友應該瞭解過這些消息模式的Java實現，這裏咱們使用Spring AMQP的形式來實現它們。
簡單模式
簡單模式是最簡單的消息模式，它包含一個生產者、一個消費者和一個隊列。生產者向隊列裏發送消息，消費者從隊列中獲取消息並消費。
模式示意圖
Spring AMQP實現
- 首先須要在
pom.xml中添加Spring AMQP的相關依賴；
<!--Spring AMQP依賴-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
- 而後修改
application.yml，添加RabbitMQ的相關配置；
spring:
rabbitmq:
host: localhost
port: 5672
virtual-host: /mall
username: mall
password: mall
publisher-confirms: true #消息發送到交換器確認
publisher-returns: true #消息發送到隊列確認
- 添加
簡單模式相關Java配置，建立一個名爲simple.hello的隊列、一個生產者和一個消費者；
/**
* Created by macro on 2020/5/19.
*/
@Configuration
public class SimpleRabbitConfig {
@Bean
public Queue hello() {
return new Queue("simple.hello");
}
@Bean
public SimpleSender simpleSender(){
return new SimpleSender();
}
@Bean
public SimpleReceiver simpleReceiver(){
return new SimpleReceiver();
}
}
- 生產者經過
send方法向隊列simple.hello中發送消息；
/**
* Created by macro on 2020/5/19.
*/
public class SimpleSender {
private static final Logger LOGGER = LoggerFactory.getLogger(SimpleSender.class);
@Autowired
private RabbitTemplate template;
private static final String queueName="simple.hello";
public void send() {
String message = "Hello World!";
this.template.convertAndSend(queueName, message);
LOGGER.info(" [x] Sent '{}'", message);
}
}
- 消費者從隊列
simple.hello中獲取消息；
/**
* Created by macro on 2020/5/19.
*/
@RabbitListener(queues = "simple.hello")
public class SimpleReceiver {
private static final Logger LOGGER = LoggerFactory.getLogger(SimpleReceiver.class);
@RabbitHandler
public void receive(String in) {
LOGGER.info(" [x] Received '{}'", in);
}
}
- 在controller中添加測試接口，調用該接口開始發送消息；
/**
* Created by macro on 2020/5/19.
*/
@Api(tags = "RabbitController", description = "RabbitMQ功能測試")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
@Autowired
private SimpleSender simpleSender;
@ApiOperation("簡單模式")
@RequestMapping(value = "/simple", method = RequestMethod.GET)
@ResponseBody
public CommonResult simpleTest() {
for(int i=0;i<10;i++){
simpleSender.send();
ThreadUtil.sleep(1000);
}
return CommonResult.success(null);
}
}
- 運行後結果以下，能夠發現生產者往隊列中發送消息，消費者從隊列中獲取消息並消費。
工做模式
工做模式是指向多個互相競爭的消費者發送消息的模式，它包含一個生產者、兩個消費者和一個隊列。兩個消費者同時綁定到一個隊列上去，當消費者獲取消息處理耗時任務時，空閒的消費者從隊列中獲取並消費消息。
模式示意圖
Spring AMQP實現
- 添加
工做模式相關Java配置，建立一個名爲work.hello的隊列、一個生產者和兩個消費者；
/**
* Created by macro on 2020/5/19.
*/
@Configuration
public class WorkRabbitConfig {
@Bean
public Queue workQueue() {
return new Queue("work.hello");
}
@Bean
public WorkReceiver workReceiver1() {
return new WorkReceiver(1);
}
@Bean
public WorkReceiver workReceiver2() {
return new WorkReceiver(2);
}
@Bean
public WorkSender workSender() {
return new WorkSender();
}
}
- 生產者經過
send方法向隊列work.hello中發送消息，消息中包含必定數量的.號；
/**
* Created by macro on 2020/5/19.
*/
public class WorkSender {
private static final Logger LOGGER = LoggerFactory.getLogger(WorkSender.class);
@Autowired
private RabbitTemplate template;
private static final String queueName = "work.hello";
public void send(int index) {
StringBuilder builder = new StringBuilder("Hello");
int limitIndex = index % 3+1;
for (int i = 0; i < limitIndex; i++) {
builder.append('.');
}
builder.append(index+1);
String message = builder.toString();
template.convertAndSend(queueName, message);
LOGGER.info(" [x] Sent '{}'", message);
}
}
- 兩個消費者從隊列
work.hello中獲取消息，名稱分別爲instance 1和instance 2，消息中包含.號越多，耗時越長；
/**
* Created by macro on 2020/5/19.
*/
@RabbitListener(queues = "work.hello")
public class WorkReceiver {
private static final Logger LOGGER = LoggerFactory.getLogger(WorkReceiver.class);
private final int instance;
public WorkReceiver(int i) {
this.instance = i;
}
@RabbitHandler
public void receive(String in) {
StopWatch watch = new StopWatch();
watch.start();
LOGGER.info("instance {} [x] Received '{}'", this.instance, in);
doWork(in);
watch.stop();
LOGGER.info("instance {} [x] Done in {}s", this.instance, watch.getTotalTimeSeconds());
}
private void doWork(String in) {
for (char ch : in.toCharArray()) {
if (ch == '.') {
ThreadUtil.sleep(1000);
}
}
}
}
- 在controller中添加測試接口，調用該接口開始發送消息；
/**
* Created by macro on 2020/5/19.
*/
@Api(tags = "RabbitController", description = "RabbitMQ功能測試")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
@Autowired
private WorkSender workSender;
@ApiOperation("工做模式")
@RequestMapping(value = "/work", method = RequestMethod.GET)
@ResponseBody
public CommonResult workTest() {
for(int i=0;i<10;i++){
workSender.send(i);
ThreadUtil.sleep(1000);
}
return CommonResult.success(null);
}
}
- 運行後結果以下，能夠發現生產者往隊列中發送包含不一樣數量
.號的消息，instance 1和instance 2消費者互相競爭，分別消費了一部分消息。
發佈/訂閱模式
發佈/訂閱模式是指同時向多個消費者發送消息的模式（相似廣播的形式），它包含一個生產者、兩個消費者、兩個隊列和一個交換機。兩個消費者同時綁定到不一樣的隊列上去，兩個隊列綁定到交換機上去，生產者經過發送消息到交換機，全部消費者接收並消費消息。
模式示意圖
Spring AMQP實現
- 添加
發佈/訂閱模式相關Java配置，建立一個名爲exchange.fanout的交換機、一個生產者、兩個消費者和兩個匿名隊列，將兩個匿名隊列都綁定到交換機；
/**
* Created by macro on 2020/5/19.
*/
@Configuration
public class FanoutRabbitConfig {
@Bean
public FanoutExchange fanout() {
return new FanoutExchange("exchange.fanout");
}
@Bean
public Queue fanoutQueue1() {
return new AnonymousQueue();
}
@Bean
public Queue fanoutQueue2() {
return new AnonymousQueue();
}
@Bean
public Binding fanoutBinding1(FanoutExchange fanout, Queue fanoutQueue1) {
return BindingBuilder.bind(fanoutQueue1).to(fanout);
}
@Bean
public Binding fanoutBinding2(FanoutExchange fanout, Queue fanoutQueue2) {
return BindingBuilder.bind(fanoutQueue2).to(fanout);
}
@Bean
public FanoutReceiver fanoutReceiver() {
return new FanoutReceiver();
}
@Bean
public FanoutSender fanoutSender() {
return new FanoutSender();
}
}
- 生產者經過
send方法向交換機exchange.fanout中發送消息，消息中包含必定數量的.號；
/**
* Created by macro on 2020/5/19.
*/
public class FanoutSender {
private static final Logger LOGGER = LoggerFactory.getLogger(FanoutSender.class);
@Autowired
private RabbitTemplate template;
private static final String exchangeName = "exchange.fanout";
public void send(int index) {
StringBuilder builder = new StringBuilder("Hello");
int limitIndex = index % 3 + 1;
for (int i = 0; i < limitIndex; i++) {
builder.append('.');
}
builder.append(index + 1);
String message = builder.toString();
template.convertAndSend(exchangeName, "", message);
LOGGER.info(" [x] Sent '{}'", message);
}
}
- 消費者從綁定的匿名隊列中獲取消息，消息中包含
.號越多，耗時越長，因爲該消費者能夠從兩個隊列中獲取並消費消息，能夠看作兩個消費者，名稱分別爲instance 1和instance 2；
/**
* Created by macro on 2020/5/19.
*/
public class FanoutReceiver {
private static final Logger LOGGER = LoggerFactory.getLogger(FanoutReceiver.class);
@RabbitListener(queues = "#{fanoutQueue1.name}")
public void receive1(String in) {
receive(in, 1);
}
@RabbitListener(queues = "#{fanoutQueue2.name}")
public void receive2(String in) {
receive(in, 2);
}
private void receive(String in, int receiver) {
StopWatch watch = new StopWatch();
watch.start();
LOGGER.info("instance {} [x] Received '{}'", receiver, in);
doWork(in);
watch.stop();
LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
}
private void doWork(String in) {
for (char ch : in.toCharArray()) {
if (ch == '.') {
ThreadUtil.sleep(1000);
}
}
}
}
- 在controller中添加測試接口，調用該接口開始發送消息；
/**
* Created by macro on 2020/5/19.
*/
@Api(tags = "RabbitController", description = "RabbitMQ功能測試")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
@Autowired
private FanoutSender fanoutSender;
@ApiOperation("發佈/訂閱模式")
@RequestMapping(value = "/fanout", method = RequestMethod.GET)
@ResponseBody
public CommonResult fanoutTest() {
for(int i=0;i<10;i++){
fanoutSender.send(i);
ThreadUtil.sleep(1000);
}
return CommonResult.success(null);
}
}
- 運行後結果以下，能夠發現生產者往隊列中發送包含不一樣數量
.號的消息，instance 1和instance 2同時獲取並消費了消息。
路由模式
路由模式是能夠根據路由鍵選擇性給多個消費者發送消息的模式，它包含一個生產者、兩個消費者、兩個隊列和一個交換機。兩個消費者同時綁定到不一樣的隊列上去，兩個隊列經過路由鍵綁定到交換機上去，生產者發送消息到交換機，交換機經過路由鍵轉發到不一樣隊列，隊列綁定的消費者接收並消費消息。
模式示意圖
Spring AMQP實現
- 添加
路由模式相關Java配置，建立一個名爲exchange.direct的交換機、一個生產者、兩個消費者和兩個匿名隊列，隊列經過路由鍵都綁定到交換機，隊列1的路由鍵爲orange和black，隊列2的路由鍵爲green和black；
/**
* Created by macro on 2020/5/19.
*/
@Configuration
public class DirectRabbitConfig {
@Bean
public DirectExchange direct() {
return new DirectExchange("exchange.direct");
}
@Bean
public Queue directQueue1() {
return new AnonymousQueue();
}
@Bean
public Queue directQueue2() {
return new AnonymousQueue();
}
@Bean
public Binding directBinding1a(DirectExchange direct, Queue directQueue1) {
return BindingBuilder.bind(directQueue1).to(direct).with("orange");
}
@Bean
public Binding directBinding1b(DirectExchange direct, Queue directQueue1) {
return BindingBuilder.bind(directQueue1).to(direct).with("black");
}
@Bean
public Binding directBinding2a(DirectExchange direct, Queue directQueue2) {
return BindingBuilder.bind(directQueue2).to(direct).with("green");
}
@Bean
public Binding directBinding2b(DirectExchange direct, Queue directQueue2) {
return BindingBuilder.bind(directQueue2).to(direct).with("black");
}
@Bean
public DirectReceiver receiver() {
return new DirectReceiver();
}
@Bean
public DirectSender directSender() {
return new DirectSender();
}
}
- 生產者經過
send方法向交換機exchange.direct中發送消息，發送時使用不一樣的路由鍵，根據路由鍵會被轉發到不一樣的隊列；
/**
* Created by macro on 2020/5/19.
*/
public class DirectSender {
@Autowired
private RabbitTemplate template;
private static final String exchangeName = "exchange.direct";
private final String[] keys = {"orange", "black", "green"};
private static final Logger LOGGER = LoggerFactory.getLogger(DirectSender.class);
public void send(int index) {
StringBuilder builder = new StringBuilder("Hello to ");
int limitIndex = index % 3;
String key = keys[limitIndex];
builder.append(key).append(' ');
builder.append(index+1);
String message = builder.toString();
template.convertAndSend(exchangeName, key, message);
LOGGER.info(" [x] Sent '{}'", message);
}
}
- 消費者從本身綁定的匿名隊列中獲取消息，因爲該消費者能夠從兩個隊列中獲取並消費消息，能夠看作兩個消費者，名稱分別爲
instance 1和instance 2；
/**
* Created by macro on 2020/5/19.
*/
public class DirectReceiver {
private static final Logger LOGGER = LoggerFactory.getLogger(DirectReceiver.class);
@RabbitListener(queues = "#{directQueue1.name}")
public void receive1(String in){
receive(in, 1);
}
@RabbitListener(queues = "#{directQueue2.name}")
public void receive2(String in){
receive(in, 2);
}
private void receive(String in, int receiver){
StopWatch watch = new StopWatch();
watch.start();
LOGGER.info("instance {} [x] Received '{}'", receiver, in);
doWork(in);
watch.stop();
LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
}
private void doWork(String in){
for (char ch : in.toCharArray()) {
if (ch == '.') {
ThreadUtil.sleep(1000);
}
}
}
}
- 在controller中添加測試接口，調用該接口開始發送消息；
/**
* Created by macro on 2020/5/19.
*/
@Api(tags = "RabbitController", description = "RabbitMQ功能測試")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
@Autowired
private DirectSender directSender;
@ApiOperation("路由模式")
@RequestMapping(value = "/direct", method = RequestMethod.GET)
@ResponseBody
public CommonResult directTest() {
for(int i=0;i<10;i++){
directSender.send(i);
ThreadUtil.sleep(1000);
}
return CommonResult.success(null);
}
}
- 運行後結果以下，能夠發現生產者往隊列中發送包含不一樣
路由鍵的消息，instance 1獲取到了orange和black消息，instance 2獲取到了green和black消息。
通配符模式
通配符模式是能夠根據路由鍵匹配規則選擇性給多個消費者發送消息的模式，它包含一個生產者、兩個消費者、兩個隊列和一個交換機。兩個消費者同時綁定到不一樣的隊列上去，兩個隊列經過路由鍵匹配規則綁定到交換機上去，生產者發送消息到交換機，交換機經過路由鍵匹配規則轉發到不一樣隊列，隊列綁定的消費者接收並消費消息。
特殊匹配符號
-
*：只能匹配一個單詞； -
#：能夠匹配零個或多個單詞。
模式示意圖
Spring AMQP實現
- 添加
通配符模式相關Java配置，建立一個名爲exchange.topic的交換機、一個生產者、兩個消費者和兩個匿名隊列，匹配*.orange.*和*.*.rabbit發送到隊列1，匹配lazy.#發送到隊列2；
/**
* Created by macro on 2020/5/19.
*/
@Configuration
public class TopicRabbitConfig {
@Bean
public TopicExchange topic() {
return new TopicExchange("exchange.topic");
}
@Bean
public Queue topicQueue1() {
return new AnonymousQueue();
}
@Bean
public Queue topicQueue2() {
return new AnonymousQueue();
}
@Bean
public Binding topicBinding1a(TopicExchange topic, Queue topicQueue1) {
return BindingBuilder.bind(topicQueue1).to(topic).with("*.orange.*");
}
@Bean
public Binding topicBinding1b(TopicExchange topic, Queue topicQueue1) {
return BindingBuilder.bind(topicQueue1).to(topic).with("*.*.rabbit");
}
@Bean
public Binding topicBinding2a(TopicExchange topic, Queue topicQueue2) {
return BindingBuilder.bind(topicQueue2).to(topic).with("lazy.#");
}
@Bean
public TopicReceiver topicReceiver() {
return new TopicReceiver();
}
@Bean
public TopicSender topicSender() {
return new TopicSender();
}
}
- 生產者經過
send方法向交換機exchange.topic中發送消息，消息中包含不一樣的路由鍵；
/**
* Created by macro on 2020/5/19.
*/
public class TopicSender {
@Autowired
private RabbitTemplate template;
private static final String exchangeName = "exchange.topic";
private static final Logger LOGGER = LoggerFactory.getLogger(TopicSender.class);
private final String[] keys = {"quick.orange.rabbit", "lazy.orange.elephant", "quick.orange.fox",
"lazy.brown.fox", "lazy.pink.rabbit", "quick.brown.fox"};
public void send(int index) {
StringBuilder builder = new StringBuilder("Hello to ");
int limitIndex = index%keys.length;
String key = keys[limitIndex];
builder.append(key).append(' ');
builder.append(index+1);
String message = builder.toString();
template.convertAndSend(exchangeName, key, message);
LOGGER.info(" [x] Sent '{}'",message);
System.out.println(" [x] Sent '" + message + "'");
}
}
- 消費者從本身綁定的匿名隊列中獲取消息，因爲該消費者能夠從兩個隊列中獲取並消費消息，能夠看作兩個消費者，名稱分別爲
instance 1和instance 2；
/**
* Created by macro on 2020/5/19.
*/
public class TopicReceiver {
private static final Logger LOGGER = LoggerFactory.getLogger(TopicReceiver.class);
@RabbitListener(queues = "#{topicQueue1.name}")
public void receive1(String in){
receive(in, 1);
}
@RabbitListener(queues = "#{topicQueue2.name}")
public void receive2(String in){
receive(in, 2);
}
public void receive(String in, int receiver){
StopWatch watch = new StopWatch();
watch.start();
LOGGER.info("instance {} [x] Received '{}'", receiver, in);
doWork(in);
watch.stop();
LOGGER.info("instance {} [x] Done in {}s", receiver, watch.getTotalTimeSeconds());
}
private void doWork(String in){
for (char ch : in.toCharArray()) {
if (ch == '.') {
ThreadUtil.sleep(1000);
}
}
}
}
- 在controller中添加測試接口，調用該接口開始發送消息；
/**
* Created by macro on 2020/5/19.
*/
@Api(tags = "RabbitController", description = "RabbitMQ功能測試")
@Controller
@RequestMapping("/rabbit")
public class RabbitController {
@Autowired
private TopicSender topicSender;
@ApiOperation("通配符模式")
@RequestMapping(value = "/topic", method = RequestMethod.GET)
@ResponseBody
public CommonResult topicTest() {
for(int i=0;i<10;i++){
topicSender.send(i);
ThreadUtil.sleep(1000);
}
return CommonResult.success(null);
}
}
- 運行後結果以下，能夠發現生產者往隊列中發送包含不一樣
路由鍵的消息，instance 1和instance 2分別獲取到了匹配的消息。
參考資料
RabbitMQ Tutorials:https://www.rabbitmq.com/gets...github
項目源碼地址
https://github.com/macrozheng...spring
公衆號
mall項目全套學習教程連載中，關注公衆號第一時間獲取。docker
相關文章
- 1. RabbitMQ五種消息隊列
- 2. RabbitMq消息隊列
- 3. 消息隊列----RabbitMQ
- 4. RabbitMQ---消息隊列
- 5. RabbitMQ消息隊列
- 6. Rabbitmq 消息隊列
- 7. 消息隊列-RabbitMQ
- 8. 消息隊列 RabbitMQ
- 9. 消息隊列——RabbitMQ
- 10. rabbitMQ 消息隊列
- 更多相關文章...
- • HTTP 消息結構 - HTTP 教程
- • C# 隊列（Queue） - C#教程
- • 委託模式
- • 常用的分佈式事務解決方案
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
最新文章
- 1. Appium入門
- 2. Spring WebFlux 源碼分析(2)-Netty 服務器啓動服務流程 --TBD
- 3. wxpython入門第六步（高級組件）
- 4. CentOS7.5安裝SVN和可視化管理工具iF.SVNAdmin
- 5. jedis 3.0.1中JedisPoolConfig對象缺少setMaxIdle、setMaxWaitMillis等方法，問題記錄
- 6. 一步一圖一代碼，一定要讓你真正徹底明白紅黑樹
- 7. 2018-04-12—（重點）源碼角度分析Handler運行原理
- 8. Spring AOP源碼詳細解析
- 9. Spring Cloud（1）
- 10. python簡單爬去油價信息發送到公衆號
歡迎關注本站公眾號,獲取更多信息
相關文章
- 1. RabbitMQ五種消息隊列
- 2. RabbitMq消息隊列
- 3. 消息隊列----RabbitMQ
- 4. RabbitMQ---消息隊列
- 5. RabbitMQ消息隊列
- 6. Rabbitmq 消息隊列
- 7. 消息隊列-RabbitMQ
- 8. 消息隊列 RabbitMQ
- 9. 消息隊列——RabbitMQ
- 10. rabbitMQ 消息隊列