RabbitMQ由淺入深入門全總結（一）

BWH_Steven發表於2021-06-15

寫在最前面

距離上一次發文章已經很久了，其實這段時間一直也沒有停筆，只不過在忙著找工作還有學校結課的事情，重新弄了一下部落格，後面也會陸陸續續會把文章最近更新出來~

這篇文章有點長，就分了兩篇Q
PS：那個Github上Java知識問答的文章也沒有停筆，最近也會陸續更新

1. 淺淺道來

1.1 什麼是中介軟體？

IDC（網際網路資料中心）的定義：中介軟體是一種獨立的系統軟體服務程式，分散式應用軟體藉助這種軟體在不同的技術之間共享資源，中介軟體位於客戶機伺服器的作業系統之上，管理計算資源和網路通訊。

首先，中介軟體是某一類軟體的總稱，而不是某一種具體的軟體。它是一種位於平臺（作業系統硬體）和應用程式之間的通用服務，它遮蔽了底層作業系統的各種複雜性，減輕了開發人員的技術負擔，同時它的設計不針對某一具體目標，而是提供具有普遍通用特點的功能模組服務，這些服務具有標準的程式介面和協議，根據平臺的不同，也可以有不同的實現。

通俗的例子（僅供參考，並不算完全一致）：

我開了一家咖啡店，我身邊有 A B C 等 n 家咖啡豆的供應商，但是我肯定要挑選價格又實惠，質量還不錯的豆子，但是市場是受到多方面因素波動的，可能我現在的選擇，在一段時間後已經不是最佳選項了。所以我專門找到一家市場中介，讓他幫我操心這一攤子事情，我只和你說清價格和質量要求，你去找就是了，過程我一點也不操心。這個中介的概念，就類似中介軟體的

1.1.1 分散式的概念（補充）

這一段，來自我之前寫的 Dubbo 入門的那篇文章哈

在百度以及維基中的定義都相對專業且晦澀，大部分部落格或者教程經常會使用《分散式系統原理和範型》中的定義，即：“分散式系統是若干獨立計算機的集合，這些計算機對於使用者來說就像是單個相關係統”

下面我們用一些篇幅來通俗的解釋一下什麼叫做分散式

1.1.1.1 什麼是集中式系統

提到分散式，不得不提的就是 “集中式系統”，這個概念最好理解了，它就是將功能，程式等安裝在同一臺裝置上，就由這一臺主機裝置向外提供服務

舉個最簡單的例子：你拿一臺PC主機，將其改裝成了一臺簡單的伺服器，配置好各種內容後，你將MySQL，Web伺服器，FTP，Nginx 等等，全部安裝在其中，打包部署專案後，就可以對外提供服務了，但是一旦這臺機器無論是軟體還是硬體出現了問題，整個系統都會受到嚴重的牽連錯誤，雞蛋放在一個籃子裡，要打就全打了

1.1.12 什麼是分散式系統

既然集中式系統有這樣一種牽一髮而動全身的問題，那麼分散式的其中一個作用，自然是來解決這樣的問題了，正如定義中所知，分散式系統在使用者的體驗感官裡，就像傳統的單系統一樣，一些變化都是這個系統本身內部進行的，對於使用者並沒有什麼太大的感覺

例如：淘寶，京東這種大型電商平臺，它們的主機都是數以萬計的，否則根本沒法處理大量的資料和請求，具體其中有什麼劃分，以及操作，我們下面會說到，但是對於使用者的我們，我們不需要也不想關心這些，我們仍可以單純的認為，我們面對的就是 “淘寶” 這一臺 “主機”

所以分散式的一個相對專業一些的說法是這樣的（程式粒度）兩個或者多個程式，分別執行在不同的主機程式上，它們互相配合協調，完成共同的功能，那麼這幾個程式之間構成的系統就可以叫做分散式系統

這幾者都是相同的程式 —— 分散式
這幾者都是不同的程式 —— 叢集

1.2 什麼是訊息中介軟體/訊息佇列（MQ）

訊息中介軟體，顧名思義就是用來處理訊息相關服務的中介軟體，它提供了一種系統之間通訊互動的通道，例如傳送方只需要把想傳輸的資訊交給訊息中介軟體，而傳送的協議，方式，傳送過程中出現的網路，故障等等問題，都由中介軟體進行處理，因此它負責保證資訊的可靠傳輸。

所以訊息中介軟體，就是一種用來接受資料，儲存資料，傳送資料的技術，它提供了各種功能，可以實現訊息的高可用，高可靠，也提供了很好的容錯機制等。可以程式對系統資源的佔用，以及傳輸效率的提升有很大幫助。

常說的 MQ 就是指訊息佇列，即 Message Quene，常見的訊息佇列有，經典的 ActivieMQ，熱門的 Kafka，阿里的 RocketMQ 等等，以及這裡講解的 RabbitMQ。
- 不同的 MQ 有著不同的特點，以及其更加擅長的方向，倒也說不上誰好誰壞，只有誰更合適。

1.2.1 訊息佇列應用場景

根據業務的需要，其實它可以有多種應用場景，例如解耦，削峰填谷，廣播等，我們舉兩個場景來梳理一下簡單的過程

1.2.1.1 業務解耦

最近在考慮買幾本書看，就以買書下訂單舉例，當我點選購買之後，可能會有這麼一串業務邏輯執行，① 減去庫存容量 ② 生成訂單 ③ 支付 ④ 更新訂單狀態 ⑤ 傳送購買成功簡訊 ⑥ 更新商品快遞攬收狀態。在初期階段，我們完全可以讓這些業務同步執行，但是後期為了提升效率，就可以將需要立即執行的任務和可稍緩執行的任務進行分離，例如 ⑤ 傳送購買成功簡訊 ⑥ 更新商品快遞攬收狀態，都可以考慮異執行。在主流程執行結束後，這些可稍緩的業務可以通過給 MQ 傳送訊息，就判定已經執行，保證流程先結束。然後再通過拉取 MQ 訊息，或者 MQ 主動推送去非同步執行其他的業務。

1.2.1.2 削峰填谷

例如傳送一條帶有已讀未讀標識的公告資訊，所以需要對每一個使用者都寫一條這樣的公告訊息，例如存到 MongoDB 中，即便 MongoDB 也支撐不下來瞬時寫入百萬、千萬記錄的情況，所以可以考慮使用訊息佇列。比如說我們可以在Java後端系統上面，用非同步多執行緒的方法，向訊息佇列MQ中傳送訊息，這樣Web系統釋出公告訊息的時候就不佔用資料庫正常的 CRUD 操作。系統訊息儲存在訊息佇列中，我們只是用它來做削峰填谷，系統訊息最終還是要儲存在資料庫上面。於是我們可以這樣設計，在使用者登陸系統的時候，用非同步執行緒從訊息佇列MQ中，接收該使用者的系統訊息，然後把系統訊息儲存在資料庫中，最後訊息佇列MQ中的該條訊息自動刪除。因為使用者的錯峰登入，所以往資料庫中寫入訊息的任務也變成了錯峰寫入。

1.3 什麼是 RabbitMQ

RabbitMQ 是一個使用 Erlang 語言編寫，且遵循 AMQP協議的開源訊息佇列系統，支援多種客戶端（語言），用於在分散式系統中儲存訊息，轉發訊息，具有高可用，高可擴性，易用性等特徵。

更詳細的介紹可以直接看一下官網：

https://www.rabbitmq.com/

總之這就是一種常見的訊息佇列，它的這些特點，都會在後面逐條講解到，我們首先從入門下載安裝部分先說起，然後再到使用。

2. 下載與安裝

一般來說，安裝的方式有手動安裝和 Docker 安裝，大部分場景下，都會使用 Docker 安裝，但是作為學習階段，如果不是特別著急，學習一下手動安裝，也不是什麼壞事。

注：雲伺服器和虛擬機器都可以，演示的 Linux 版本為 CentOS 7.9

2.1 手動安裝

2.1.1 下載安裝過程

注：可以在 Linux 中通過 yum 直接下載安裝，這裡選擇了在自己的 Windows 主機先下載檔案，然後再通過 FTP 傳到 Linux 上，直接安裝。可以避免虛擬機器上因為網路而造成的一些下載問題。

首先開啟官網的下載目錄，然後根據自己 Linux 的版本，選擇版本。
- 地址：https://www.rabbitmq.com/download.html

因為 RabbitMQ 是 Erlang 語言編寫的，所以還需要提供 Erlang 環境，接著去下載 Erlang。
- 地址：https://www.erlang-solutions.com/downloads
  - A：此網站訪問速度極慢，請耐心等待，或者需要掛上梯子
  - B：Erlang 版本需要與 RabbitMQ 匹配（如圖，有最大和最小版本的限制）
    - 版本檢視地址：https://www.rabbitmq.com/which-erlang.html
    - 這裡選擇了 RabbitMQ 3.8.14 和 Erlang 23.2.3

將檔案上傳到 Linux 中（我這裡指定位置是 /usr/local/bin/rabbitmq ，可以自己更改選擇）
- 現在很多 Shell 軟體都自帶內建的 FTP 上傳，例如 FinalShell，MobaXterm 等等
- 上傳後的檔案和目錄位置如下

[root@centos7 rabbitmq]# ls
esl-erlang_23.2.3-1_centos_7_amd64.rpm  rabbitmq-server-3.8.14-1.el7.noarch.rpm
[root@centos7 rabbitmq]# pwd
/usr/local/bin/rabbitmq

安裝 Erlang 、Socat 和 RabbitMQ
- Erlang 、Socat 都是 RabbitMQ 所依賴的

# 安裝 Erlang，安裝後執行 erl -v 顯示版本號則代表成功
rpm -ivh esl-erlang_23.2.3-1_centos_7_amd64.rpm

# 安裝 Socat 這裡沒有下載原始檔，而是直接通過 yum 線上安裝，因為它並不大
yum install -y socat

# 安裝 RabbitMQ
rpm -ivh rabbitmq-server-3.8.14-1.el7.noarch.rpm

安裝結束，啟動服務檢視 RabbitMQ 是否可以啟動成功

# 啟動服務
systemctl start rabbitmq-server
# 開機自啟
systemctl enable rabbitmq-server
# 停止服務
systemctl stop rabbitmq-server
# 檢視服務狀態
systemctl status rabbitmq-server.service

如圖所示，即安裝啟動成功

若安裝錯誤，處理參考：

2.1.2 配置 Web 介面管理

上面的安裝其實已經結束了，但是 RabbitMQ 提供給了我們一個 Web 形式的管理介面，預設是沒有的，需要進行安裝。

安裝 Web 管理外掛，然後重啟服務

# 安裝命令
rabbitmq-plugins enable rabbitmq_management

# 重啟服務
systemctl restart rabbitmq-server

一定要開放 Linux 防火牆的 15672 埠，否則就會無法訪問，在學習階段，你甚至可以去查詢命令把防火牆關掉
- 對應伺服器（阿里雲，騰訊雲等）就是在安全組中開放 15672 埠
- 訪問 Linux IP:15672 ，例如 http://192.168.122.1:15672

# 查詢 15672 是否開放，一般預設都是 no
firewall-cmd --query-port=15672/tcp
# 開放指定埠 15672 
firewall-cmd --add-port=15672/tcp --permanent
# 重新載入
firewall-cmd --reload
# 再次查詢，結果就是 yes 了
firewall-cmd --query-port=15672/tcp

新增遠端登入的賬戶
- RabbitMQ 有一個預設賬號和密碼都是 guest 但是隻能在 localhost 下訪問

# 新增使用者 使用者名稱和密碼都是 admin
rabbitmqctl add_user admin admin

為遠端登入的賬戶新增許可權
- administrator（超級管理員）：登入控制檯、檢視所有資訊、操作使用者、操作策略
- monitoring（監控者）：登入控制檯、檢視所有資訊
- policymaker（策略制定者）：登入控制檯、指定策略
- managment（普通管理員）：登入控制檯

# 設定使用者分配操作許可權，admin 使用者的許可權為 administrator
rabbitmqctl set_user_tags admin administrator

為使用者新增資源許可權
- 因為 admin 已經是超級管理員許可權了，所以其實不分配資源許可權也可以，會預設去做。

# 命令格式為: set_permissions [-p <vhostpath>] <user> <conf> <write> <read>
# 這裡即為 admin 使用者開啟 配置檔案和讀寫的許可權
rabbitmqctl set_permissions -p / admin ".*"".*"".*"

訪問 Linux IP:15672 ，例如 http://192.168.122.1:15672 ，輸入剛才設定好的使用者名稱密碼 admin
- 如圖：訪問成功

2.1.2.1 命令小結

新增使用者：rabbitmqctl add_user <username> <password>
修改密碼：rabbitmqctl change_password <username> <newpass>
刪除使用者：rabbitmqctl delete_user <username>
使用者列表：rabbitmqctl list_users
設定使用者角色：rabbitmqctl set_user_tags <username> <tag1,tag2>
刪除使用者所有角色：rabbitmqctl set_user_tags <username>
為使用者新增資源許可權：set_permissions [-p <vhostpath>] <user> <conf> <write> <read>

使用：輸入 rabbitmqctl ，則會提示可能使用的命令，然後使用 rabbitmqctl hepl <命令> 可以檢視具體命令的使用方法和引數。

2.1.3 簡單介紹 Web 介面管理

Connections（連線）：此處用來管理與 RabbitMQ 建立連線後的生產者和消費者
Channels（通道）：連線建立後，會形成通道，訊息的投遞獲取依賴通道。
Exchanges（交換機）：用來實現訊息的路由
Queues（佇列）：存放訊息的佇列，訊息等待被消費，消費後被移除佇列。
Admin（管理）：用於對管理使用者，以及對應許可權進行設定，如下圖所示

Tags 就是用來指定使用者的角色

administrator（超級管理員）：登入控制檯、檢視所有資訊、操作使用者、操作策略
monitoring（監控者）：登入控制檯、檢視所有資訊
policymaker（策略制定者）：登入控制檯、指定策略
managment（普通管理員）：登入控制檯

2.2 Docker 安裝

在 Docker 中安裝 RabbitMQ 不需要自己去考慮版本，環境等的各種衝突不相容問題，是非常便捷的，我演示的這臺虛擬機器是一個 CentOS 7.9 裸機，所以我們從更新 yum，到安裝 Docker 和安裝 RabbitMQ 按步驟都講一下

2.2.1 配置 yum

更新 yum 到最新版

# 更新 yum
yum update

# 檢查yum依賴的幾個包 yum-utils 提供 yum-config-manager 功能， 後面兩個是 devicemapper 用到的
yum install -y yum-utils device-mapper-persistent-data lvm2

設定 yum 源為阿里雲

yum-config-manager --add-repo http://mirrors.aliyun.com/docker-ce/linux/centos/docker-ce.repo

2.2.2 安裝 docker

2.2.2.1 步驟

使用 yum 安裝 docker
- docker-ce 是社群版的意思，ee為企業版

yum install docker-ce -y

通過檢視版本，檢查安裝是否成功

docker -v

Docker 映象加速（這裡 <你的ID >要換成自己的哈）

sudo mkdir -p /etc/docker
sudo tee /etc/docker/daemon.json <<-'EOF'
{
  "registry-mirrors": ["https://<你的ID>.mirror.aliyuncs.com"]
}
EOF
sudo systemctl daemon-reload
sudo systemctl restart docker

國內從 DockerHub 拉取映象有時會遇到困難，此時可以配置映象加速器。Docker 官方和國內很多雲服務商都提供了國內加速器服務，例如：

科大映象：https://docker.mirrors.ustc.edu.cn/

網易：https://hub-mirror.c.163.com/

阿里雲：https://<你的ID>.mirror.aliyuncs.com

七牛雲加速器：https://reg-mirror.qiniu.com

當配置某一個加速器地址之後，若發現拉取不到映象，請切換到另一個加速器地址。國內各大雲服務商均提供了 Docker 映象加速服務，建議根據執行 Docker 的雲平臺選擇對應的映象加速服務。

阿里雲映象獲取地址：https://cr.console.aliyun.com/cn-hangzhou/instances/mirrors，登陸後，左側選單選中映象加速器就可以看到你的專屬地址了

2.2.2.2 Docker 常見命令

2.2.2.2.1 管理命令

就啟動，停止，重啟這些簡單的命令使用 service 也是可以的，systemctl 功能稍微強大一些

# 啟動 docker
systemctl docker start
# 停止 docker
systemctl docker stop
# 重啟 docker
systemctl docker restart
# 檢視 docker 狀態
systemctl status docker
# 開機自啟
systemctl enable docker
systemctl unenable docker

2.2.2.2.2 映象命令

# 匯入映象檔案
docker load < xxx.tar.gz
# 檢視安裝的映象
docker images
# 刪除映象
docker rmi 映象名

2.2.3 安裝 RabbitMQ （任選其一）

注：直接用 2.2.3.2 一句話安裝會更好一些

2.2.3.1 一步一步安裝

獲取 RabbitMQ 的映象

docker pull rabbitmq:management

建立並執行容器（具體引數在 3 中介紹）

docker run -id --name 容器名 -p 15672:15672 -p 5672:5672 rabbitmq:management

2.2.3.2 一句話安裝

上面的安裝方式，就是先獲取到 RabbitMQ 映象後再開始安裝，這裡是沒有問題的，建立時會有一個問題，因為我們要安裝 management 也就是它的 web 管理，如果不做一些處理，預設裝好的是沒有使用者的，所以還需要像前面一樣自己進去配置，而 Docker Hub 已經給出了我們配置的示例，即使用 -e 代表配置，使用 RABBITMQ_DEFAULT_USER 和 RABBITMQ_DEFAULT_PASS 配置使用者名稱和密碼

更多請檢視 Docker Hub 官方給予例子中的 Setting default user and password 章節

https://registry.hub.docker.com/_/rabbitmq/

執行安裝

docker run -di --name myrabbitmq -e RABBITMQ_DEFAULT_USER=admin -e RABBITMQ_DEFAULT_PASS=admin -p 15672:15672 -p 5672:5672 -p 25672:25672 -p 61613:61613 -p 1883:1883 rabbitmq:management

通過容器狀態，檢視是否執行成功

# 檢視容器執行狀態
docker ps -a
# 啟動
docker start 容器名
# 停止
docker stop 容器名
# 退出命令列，不停止
exit
# 進入到node容器（如果開啟了 -t 的情況）
docker exec -it 容器名 bash

2.2.3.2.1 引數介紹

下面分別講解一下這些引數的說明：

-i：表示執行容器。
-t：表示為容器保留互動的方式（命令列），即分配一個偽終端。所以常常會見到 -it 這樣的搭配。
--name ：為容器起個名字。
-v：表示目錄對映關係（前者是宿主機目錄，後者是對映到宿主機上的目錄），可以使用多個 -v 做多個目錄或檔案對映。注意：推薦做目錄對映，在宿主機上做修改，然後共享到容器上。
-d：表示建立一個守護式容器在後臺執行（這樣建立容器後不會自動登入容器，如果只加 -i -t 兩個引數，建立後就會自動進去容器），即後端掛起執行。
-p：表示埠對映，前者是宿主機埠，後者是容器內的對映埠。可以使用多個 -p 做多個埠對映，只有做了埠對映，才能被外界訪問。

給大家舉個例子：

# 建立容器，把容器 3000 埠對映到宿主機 3000 埠，把/demo對映到宿主機的/demo  face是我下載好的一個現成的映象
docker run -d -it -p 3000:3000 -v /demo:/demo --name node face

# 例如，名為 node 的映象中有一個需要執行的 python 程式，就可以通過如下命令進入剛才分配到的命令列中去執行這個程式
docker exec -it node bash

因為使用了 -t 這個引數，所以可以分配到一個偽終端，通過 docker exec -it 容器名 bash 進入命令列
-v 目錄對映後，進入容器後，也會有一個一模一樣的 demo 資料夾，例如在其中可以執行 python 程式

2.2.3.2.1 埠介紹

4369 ：erlang發現埠

5672：client端通訊埠

15672：管理介面ui埠

25672：server間內部通訊埠

61613：不帶TLS和帶TLS的STOMP客戶端

1883：不啟用和啟用TLS的MQTT客戶端

比較關鍵的就是 5672 和 15672

更多埠詳情可以訪問官網文件

https://www.rabbitmq.com/networking.html

注：如果要通過遠端連線，例如訪問 web 管理頁面的 15672 埠，Java 客戶端連線的 5672 埠，一定要進行一個開放操作，否則都連線不到。

以下為基於 CentOS 7.9 開放 15672 埠的例子

# 查詢 15672 是否開放，一般預設都是 no
firewall-cmd --query-port=15672/tcp
# 開放指定埠 15672 
firewall-cmd --add-port=15672/tcp --permanent
# 重新載入
firewall-cmd --reload
# 再次查詢，結果就是 yes 了
firewall-cmd --query-port=15672/tcp

以下是關閉防火牆的命令

systemctl disable firewalld
systemctl stop firewalld

3. RabbitMQ 協議和模型

安裝結束後，就要進入主題，即用 Java 或者 Springboot 程式碼來實現 RabbitMQ的幾種方式，但是想要很好的理解這幾種路由交換方式，就需要對它的協議和架構模型有所瞭解。

3.1 協議

3.1.1 什麼是協議？

協議，網路協議的簡稱，網路協議是通訊計算機雙方必須共同遵從的一組約定。如怎麼樣建立連線、怎麼樣互相識別等。只有遵守這個約定，計算機之間才能相互通訊交流。它的三要素是：語法、語義、時序。

為了使資料在網路上從源到達目的，網路通訊的參與方必須遵循相同的規則，這套規則稱為協議（protocol），它最終體現為在網路上傳輸的資料包的格式。

3.1.1.1 網路協議的三要素

語法：資料與控制資訊的結構和格式，以及資料出現的順序。
語義：解釋控制資訊每個部分的意義，以及規定了需要發出何種控制資訊以及完成的動作做出何種響應。
時序：對事件發生順序的詳細說明。

人們形象地把這三個要素描述為：做什麼，怎麼做，做的順序。

舉個例子 HTTP 協議

語法：HTTP 規定了請求報文和響應報文的格式
語義：客戶端主動發起請求稱為請求，服務端隨之返回資料，稱為響應
時序：一個請求對應一個響應，而且先有請求後有響應

3.1.1.1.1 面試題：為什麼訊息中介軟體不直接使用 HTTP 協議

對於一個訊息中介軟體來說，其主要責任就是負責資料傳遞，儲存，分發，高效能和簡潔才是我們所追求的，而 HTTP 請求報文頭和響應報文頭是比較複雜的，包含了Cookie，資料的加密解密，窗臺嗎，響應碼等附加的功能，我們並不需要這麼複雜的功能。

同時大部分情況下 HTTP 大部分都是短連結，在實際的互動過程中，一個請求到響應都很有可能會中斷，中斷以後就不會執行持久化，就會造成請求的丟失。這樣就不利於訊息中介軟體的業務場景，因為訊息中介軟體可能是一個長期的獲取資訊的過程，出現問題和故障要對資料或訊息執行持久化等，目的是為了保證訊息和資料的高可靠和穩健的執行

3.1.2 RabbitMQ 的 AMQP 協議

RabbitMQ 的使用的協議是 AMQP（advanced message queuing protocol），它在2003年時被提出，最早用於解決金融領不同平臺之間的訊息傳遞互動問題。

AMQP 更準確的說是一種 binary wire-level protocol（連結協議）。這是其和 JMS 的本質差別，AMQP 不從 API 層進行限定，而是直接定義網路交換的資料格式。這使得實現了AMQP的 Provider（Producer）天然性就是跨平臺的。

相比較其它訊息協議，其特性為：

分散式事務支援
訊息的持久化支援
高效能和高可靠的訊息處理優勢

3.1.3 架構模型

想要學習後面的幾種訊息具體的傳送模式，這個模型圖就必須理解清楚，因為這幾種方式就是對這個模型不同程度的選擇和縮減

Producer：訊息的生產者（傳送訊息的程式）。
Connection：應用程式與Broker之間的網路連線。
Channel：通道，即資訊傳輸的通道，可以建立多個 Channel，每個 Channel 代表一個會話任務。
- 通道是建立在 TCP 連線內的虛擬連線，資訊的讀寫都通過通道傳輸，因為對於操縱系統而言，建立和銷燬 TCP 是非常昂貴的，所以引入了通道的概念，以複用一條 TCP 連線。
Broker(Server) ：標識訊息佇列伺服器實體，例如這裡就是 RabbitMQ Server。
Virtual Host：虛擬主機，一個 Broker 中可以設定多個 Virtual Host，用作不同使用者的許可權隔離。
- Broker 可以理解為整個資料庫服務，而 Virtual Host 就是其中每個資料庫的感覺，不同專案可以對應不同的資料庫，其中有著專案所屬的業務表等等。
- 每個 Virtual Host 中，可以有若干個 Exchange 和 Queue。
Exchange：交換機，用來接收生產者傳送的訊息，然後將這些訊息根據路由鍵傳送到佇列。
Binding：Exchange 和 Queue 之間的虛擬連線，Binding 中可以包括多個 Routing key。
Routing key：路由規則，虛擬機器用它來確認如何路由一個特定訊息。
Queue：訊息佇列，它是訊息的容器，用來儲存訊息，每一條訊息都能傳入一個或者多個佇列中，等待消費者消費，即取出這個訊息。
Consumer：訊息的消費者（接收訊息的程式）。

4. Java 實現 RabbitMQ

4.1 環境搭建

官網介紹幾種模型：https://www.rabbitmq.com/getstarted.html

截止目前為止，官網一共提供了 7 中模型的介紹，我們主要介紹前五種基本的模式，也有人將 Direct 和 Topic模式都歸入 Routing 模式，也可以看做四大種。

4.1.1 建立 Java 專案

首先建立好一個不使用骨架的 Maven 專案，然後引入 RabbitMQ 依賴，還有單元測試依賴即可

<dependency>
   <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.10.0</version>
</dependency>
<dependency>
    <groupId>junit</groupId>
    <artifactId>junit</artifactId>
    <version>4.11</version>
</dependency>

4.1.2 建立虛擬主機（可選）

在這裡，我們建立了一個新的 Virtual Hosts，用來為這個Java專案服務，大家還可以建立一個新的使用者，然後對其開啟這個 Virtual Hosts 的訪問許可權（即將虛擬主機與使用者繫結）。我們這裡還是用 admin（我之前建立的一個管理員許可權使用者）來演示。

注：這部分不去做也可以，直接用 / 和 admin 使用者也行

4.1.3 建立連線工具類

由於我們後面要演示多種例子，而每一次獲取連線和釋放連線、關閉資源等操作程式碼都是一致的，為了防止程式碼冗餘，優化程式碼，更易理解，提取出一個工具類，這樣大家將重心放在不同實現方式的對比上就行了。

RabbitMqUtil 工具類

public class RabbitMqUtil {
    /**
     * 主機名 即 Linux IP地址
     */
    private static String host = "";
    /**
     *  埠號 客戶端訪問預設都是 5672
     */
    private static int port = 0;
    /**
     * 虛擬主機 可以設定為預設的 / 或者自己建立出指定的虛擬主機
     */
    private static String virtualHost = "";
    /**
     * 使用者名稱
     */
    private static String username = "";
    /**
     * 密碼
     */
    private static String password = "";

    // 使用靜態程式碼塊為Properties物件賦值
    static {
        try {
            //例項化物件
            Properties properties = new Properties();
            //獲取properties檔案的流物件
            InputStream in = RabbitMqUtil.class.getClassLoader().getResourceAsStream("rabbitmq.properties");
            properties.load(in);
            // 分別獲取 value
            host = properties.getProperty("host");
            port = Integer.parseInt(properties.getProperty("port"));
            virtualHost = properties.getProperty("virtualHost");
            username = properties.getProperty("username");
            password = properties.getProperty("password");

        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 獲取連線
     *
     * @return 連線
     */
    public static Connection getConnection() {
        try {
            // 建立連線工廠
            ConnectionFactory connectionFactory = new ConnectionFactory();
            // 設定連線 rabbitmq 主機
            connectionFactory.setHost(host);
            // 設定埠號
            connectionFactory.setPort(port);
            // 設定連線的虛擬主機（資料庫的感覺）
            connectionFactory.setVirtualHost(virtualHost);
            // 設定訪問虛擬主機的使用者名稱和密碼
            connectionFactory.setUsername(username);
            connectionFactory.setPassword(password);
            // 返回一個新連線
            return connectionFactory.newConnection();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return null;
    }

    /**
     * 關閉通道和釋放連線
     *
     * @param channel    channel
     * @param connection connection
     */
    public static void close(Channel channel, Connection connection) {
        try {
            if (channel != null) {
                channel.close();
            }
            if (connection != null) {
                connection.close();
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

properties

host=192.168.122.1
port=5672
virtualHost=/rabbitmq_maven_01
username=admin
password=admin

4.2 五種實現方式

說明：

佇列名，訊息等等字串內容，更推薦定義成變數傳入，我文中都是直接寫在引數中的，這種魔法值的寫法，並不是很優美。
生產者中使用了 Junit 單元測試，但是消費者中卻在 main 函式中編寫，這是因為，我們希望消費者處於一個持續執行等待的狀態，如果使用 Junit 會導致，程式在執行一次後結束掉。
- 除了在 main 函式中編寫，還可以考慮使用 sleep 等待或者 while(true) 讓程式不要直接終止掉。

4.2.1 簡單佇列模式（Hello Word）

Producer：訊息的生產者（傳送訊息的程式）。
Queue：訊息佇列，理解為一個容器，生產者向它傳送訊息，它把訊息儲存，等待消費者消費。
Consumer：訊息的消費者（接收訊息的程式）。

4.2.1.1 如何理解

由圖所示，簡單佇列模式，一個生產者，經過一個佇列，對應一個消費者。可以看做是點對點的一種傳輸方式，相較與 3.1.3 中的模型圖，最主要的特點就是看不到 Exchange（交換機）和 routekey（路由鍵），正是因為這種模式簡單，所以並不會涉及到複雜的條件分發等等，因此也不需要使用者去顯式的考慮交換機和路由鍵的問題。

但是要注意，這種模式並不是生產者直接對接佇列，而是用了預設的交換機，預設的交換機會把訊息傳送到和 routekey 名稱相同的佇列中去，這也是我們在後面程式碼中在 routekey 位置填寫了佇列名稱的原因

4.2.1.2 程式碼實現

4.2.1.2.1 生產者程式碼

public class Producer {
    @Test
    public void sendMessage() throws IOException, TimeoutException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 通道繫結訊息佇列
        channel.queueDeclare("queue1",false,false,false,null);
        // 釋出訊息
        channel.basicPublish("","queue1",null,"This is rabbitmq message 001 !".getBytes());
        // 通過工具關閉channel和釋放連線
        RabbitMqUtil.close(channel,connection);
    }
}

通過工具類獲取連線
獲取連線通道：根據 3.1.3 的模型圖可知，生產者需要在獲取到連線後，再獲取通道，才能去訪問後面的交換機佇列等。
通道繫結訊息佇列：繫結佇列前，應該繫結交換機，但是此模式中隱蔽了交換機的概念，背後使用了預設的交換機，所以直接繫結佇列。
- queueDeclare 方法解釋
  - 引數1：queue（佇列名稱），如果佇列不存在，則自動建立。
  - 引數2：durable（佇列是否持久化），持久化可以保證伺服器重啟後此佇列仍然存在。
  - 引數3：exclusive（排他佇列）即是否獨佔佇列，如果此項為 true，該佇列僅對首次申明它的連線可見，並在連線斷開時自動刪除。
  - 引數4：autoDelete（自動刪除），最後一個消費者將訊息消費完畢後，自動刪除佇列。
  - 引數5：arguments（攜帶附加屬性）。
釋出訊息：此處可以指定訊息佇列的傳送方法，以及內容等，因為此模式比較簡單，所以沒有涉及到全部引數，後面的模式會有詳細的講解
- basicPublish 方法解釋
  - 引數1：exchange（交換機名稱）。
  - 引數2：routingKey（路由key），此處填寫佇列名，可理解為把訊息傳送到和 routekey 名稱相同的佇列中去。
  - 引數3：props（訊息的控制狀態），可以在此處控制訊息的持久化。
    - 引數為：MessageProperties.PERSISTENT_TEXT_PLAIN
  - 引數4：body（訊息主體），型別是一個位元組陣列，要轉一下型別。
通過工具關閉channel和釋放連線：先關閉通道，再釋放連線。

4.2.1.2.2 消費者程式碼

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException{
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 通道繫結訊息佇列
        channel.queueDeclare("queue1", false, false, false, null);
        // 消費訊息
        channel.basicConsume("queue1", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("new String(body): " + new String(body));
            }
        });
    }
}

通過工具類獲取連線
獲取連線通道
通道繫結訊息佇列
消費訊息：此處用來指定消費哪個佇列的訊息，以及一些機制和回撥
- basicConsume 方法解釋
  - 引數1：queue（佇列名稱），即消費哪個佇列的訊息。
  - 引數2：autoAck（自動應答）開始訊息的自動確認機制，只要消費了就從佇列刪除訊息。
  - 引數3：callback（消費時的回撥介面），callback 的型別是 Consumer 這裡使用了 DefaultConsumer 就是 Consumer 的一個實現類。其中重寫 handleDelivery 方法，就可以獲取到消費的資料內容了，這裡主要使用了其中的 body，即檢視訊息主體，其他三個引數暫時還沒用到，有興趣可以先列印輸出一下，能先有個大概的瞭解。

4.2.2 工作佇列模式（Work Queue）

Producer：訊息的生產者（傳送訊息的程式）。
Queue：訊息佇列，理解為一個容器，生產者向它傳送訊息，它把訊息儲存，等待消費者消費。
Consumer：訊息的消費者（接收訊息的程式）。
- 此處我們假設 Consumer1、Consumer2、Consumer3 分別為完成任務速度不一樣快的消費者，這會引出此模式的一個重點問題。

4.2.2.1 如何理解

工作模式由圖可以看出，就是在簡單佇列模式的基礎上，增加了多個消費者，也就是讓多個消費者繫結同一個佇列，共同去消費，這樣能解決簡單佇列模式中，如果生產速速遠大於消費速度，而導致的訊息堆積現象。

因為訊息被消費後就會消失，所以不必擔心任務會重複執行。

4.2.2.2 程式碼實現

注：工作佇列模式有兩種

輪詢模式：每個消費者均分訊息
公平分發模式（能者多勞）：按能力分發，處理速度快的分發的多，處理速度慢的分發的少

我們首先演示的是輪詢模式，根據它的缺點，又能引出公平分發模式

下面只描述與上面有差異的部分，在簡單模式中，這些基本的方法都有介紹過

4.2.2.2.1 輪詢模式-生產者程式碼

public class Producer {
    @Test
    public void sendMessage() throws IOException, TimeoutException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 通道繫結訊息佇列
        channel.queueDeclare("work", true, false, false, null);
        for (int i = 1; i <= 20; i++) {
            // 釋出訊息
            channel.basicPublish("", "work", null, (i + "號訊息").getBytes());
        }
        // 通過工具關閉channel和釋放連線
        RabbitMqUtil.close(channel, connection);
    }
}

流程和簡單佇列模式基本一致，有一些小小的改動，生產者中主要就是加了層迴圈，因為有多個消費者，所以多傳送一些訊息，可以看出一些特點和問題。

4.2.2.2.2 輪詢模式-消費者程式碼

消費者 1

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        final Channel channel = connection.createChannel();
        // 通道繫結訊息佇列
        channel.queueDeclare("work", true, false, false, null);
        // 消費訊息
        channel.basicConsume("work", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消費者1號：消費-" + new String(body));
            }
        });
    }
}

消費者 2

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        final Channel channel = connection.createChannel();
        // 通道繫結訊息佇列
        channel.queueDeclare("work", true, false, false, null);
        // 消費訊息
        channel.basicConsume("work", true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者2號：消費-" + new String(body));
            }
        });
    }

上述兩個消費者都在 basicConsume中開啟了自動 Ack 應答，這一點下面會詳述，同時在消費者 1 中，增加了 sleep 2s 的語句，模擬消費者1處理訊息速度慢，而消費者2處理訊息速度快的場景。

執行結果：

Consumer1

消費者1號：消費-1號訊息
消費者1號：消費-3號訊息
消費者1號：消費-5號訊息
消費者1號：消費-7號訊息
消費者1號：消費-9號訊息
消費者1號：消費-11號訊息
消費者1號：消費-13號訊息
消費者1號：消費-15號訊息
消費者1號：消費-17號訊息
消費者1號：消費-19號訊息

Consumer2

消費者2號：消費-2號訊息
消費者2號：消費-4號訊息
消費者2號：消費-6號訊息
消費者2號：消費-8號訊息
消費者2號：消費-10號訊息
消費者2號：消費-12號訊息
消費者2號：消費-14號訊息
消費者2號：消費-16號訊息
消費者2號：消費-18號訊息
消費者2號：消費-20號訊息

觀察執行過程：發現兩個消費者雖然每個人最後都各自處理了一半的訊息，而且是按照一人一條分配的，但是消費者2號處理速度快，一下子就全部處理完了，但是消費者1號，每一次處理都需要 2s 所以，只能緩慢的處理，而消費者2號就處於一個空閒浪費的情況了。

如何切換為公平分發模式呢？

這就和 basicConsume 中的第二個引數，開啟自動確認消費有關了，它預設是 true，也就代表只要一旦拿到佇列中分發給這個消費者的訊息，我就會自動返回一個確認消費的標識，佇列收到後就會自動刪除掉佇列中的訊息。

但是這其中有一個很重要的問題，這種方式就是將風險交給了消費者，例如消費者收到了自己需要處理的 10 條訊息，剛消費了 4 個，消費者當機，掛掉了，後面的 6 個訊息就丟失了。

如果想要修改為按能力分配的方式，有兩個要點

設定通道一次只能消費一個訊息
關閉訊息的自動確認，手動確認訊息

4.2.2.2.3 公平分發模式-生產者程式碼

public class Producer {
    @Test
    public void sendMessage() throws IOException, TimeoutException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 一次只傳送一條訊息
        channel.basicQos(1);
        // 通道繫結訊息佇列
        channel.queueDeclare("work", true, false, false, null);
        for (int i = 1; i <= 20; i++) {
            // 釋出訊息
            channel.basicPublish("", "work", null, (i + "號訊息").getBytes());
        }
        // 通過工具關閉channel和釋放連線
        RabbitMqUtil.close(channel, connection);
    }

4.2.2.2.4 公平分發模式-消費者程式碼

消費者1

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        final Channel channel = connection.createChannel();
        // 一次只接受一條未確認的訊息
        channel.basicQos(1);
        // 通道繫結訊息佇列
        channel.queueDeclare("work", true, false, false, null);
        // 消費訊息
        channel.basicConsume("work", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    Thread.sleep(2000);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
                System.out.println("消費者1號：消費-" + new String(body));
                // 返回 deliveryTag 代表佇列可以刪除此訊息了
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }
}

消費者2

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        final Channel channel = connection.createChannel();
        //步驟一:一次只接受一條未確認的訊息
        channel.basicQos(1);
        // 通道繫結訊息佇列
        channel.queueDeclare("work", true, false, false, null);
        // 消費訊息
        channel.basicConsume("work", false, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者2號：消費-" + new String(body));
                channel.basicAck(envelope.getDeliveryTag(), false);
            }
        });
    }

執行結果：

Consumer1

消費者1號：消費-1號訊息

Consumer2

消費者2號：消費-2號訊息
消費者2號：消費-3號訊息
消費者2號：消費-4號訊息
消費者2號：消費-5號訊息
消費者2號：消費-6號訊息
消費者2號：消費-7號訊息
消費者2號：消費-8號訊息
消費者2號：消費-9號訊息
消費者2號：消費-10號訊息
消費者2號：消費-11號訊息
消費者2號：消費-12號訊息
消費者2號：消費-13號訊息
消費者2號：消費-14號訊息
消費者2號：消費-15號訊息
消費者2號：消費-16號訊息
消費者2號：消費-17號訊息
消費者2號：消費-18號訊息
消費者2號：消費-19號訊息
消費者2號：消費-20號訊息

4.2.3 釋出與訂閱模式（Fanout 廣播）

Producer：訊息的生產者（傳送訊息的程式）。
Exchange ：交換機，負責傳送訊息給指定佇列。
Queue：訊息佇列，理解為一個容器，生產者向它傳送訊息，它把訊息儲存，等待消費者消費。
Consumer：訊息的消費者（接收訊息的程式）。

4.2.3.1 如何理解

Fanout 直譯為 “扇出” 但是大家更多的會把它叫做廣播或者釋出與訂閱，它是一種沒有路由key的模式，生產者將訊息傳送給交換機，交換機會把所有訊息複製同步到所有與它繫結過的佇列上，而每個佇列只能有一個消費者拿到這條訊息，如果在一個消費者連線中，建立多個通道，則會出現爭搶訊息的結果。

4.2.3.2 程式碼實現

注：下面只描述與上面有差異的部分，在簡單模式中，這些基本的方法都有介紹過

4.2.3.2.1 生產者程式碼

public class Producer {
    @Test
    public void sendMessage() throws IOException, TimeoutException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        final Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order", "fanout");
        for (int i = 1; i <= 20; i++) {
            // 釋出訊息
            channel.basicPublish("order", "", null, "fanout!".getBytes());
        }
        // 通過工具關閉channel和釋放連線
        RabbitMqUtil.close(channel, connection);
    }
}

宣告交換機
- exchangeDeclare 方法解釋
  - 引數1：exchange（交換機名稱），如果交換機不存在，則自動建立
  - 引數2：type（型別），此處選擇 fanout 模式
釋出訊息：在 basicPublish 方法的第一個引數中輸入上述定義好的交換機的名字，第二個引數，路由鍵為空
- 迴圈 20 條是為了演示消費者

4.2.3.2.2 消費者程式碼

消費者1

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order", "fanout");
        // 建立臨時佇列
        String queue = channel.queueDeclare().getQueue();
        // 繫結臨時佇列和交換機
        channel.queueBind(queue, "order", "");
        // 消費訊息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者1號：消費-" + new String(body));
            }
        });
    }
}

宣告交換機
建立臨時佇列
繫結臨時佇列和交換機
- queueBind 方法解釋
  - 引數1：queue（臨時佇列）
  - 引數2：exchange（交換機）
  - 引數3：routingKey（路由key）

消費者2：演示了一個連線中，多個通道的情況

public class Consumer2 {
    public static void main(String[] args) throws IOException {
       // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        
        // 獲取連線通道
        Channel channel = connection.createChannel();
        Channel channel2 = connection.createChannel();
        
        // 宣告交換機
        channel.exchangeDeclare("order", "fanout");
        channel2.exchangeDeclare("order", "fanout");
        
        // 建立臨時佇列
        String queue = channel.queueDeclare().getQueue();
        System.out.println(queue);
        
        // 繫結臨時佇列和交換機
        channel.queueBind(queue, "order", "");
        channel2.queueBind(queue, "order", "");
        
        // 消費訊息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者2號：消費-" + new String(body));
            }
        });
        
        // 消費訊息
        channel2.basicConsume(queue, true, new DefaultConsumer(channel2) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者2-2號：消費-" + new String(body));
            }
        });
    }
}

執行結果：

消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!
消費者2-2號：消費-fanout!

4.2.3.2.3 為什麼消費者中也宣告交換機？

從上面的程式碼中可以看出，在 Producer 和 Conusmer 中我們都分別宣告瞭交換機，但是消費者由圖可知，並不會與交換機有直接的接觸，為什麼消費者中也宣告交換機呢？

這是為了保證 Producer 或者 Producer 執行的時候，永遠不會因為交換機還沒被宣告而出錯，例如你只在 Producer 宣告瞭交換機，那麼你就必須先啟動 Producer ，如果直接執行 Conusmer 此時交換機就還不存在，就會報錯。而全部寫入宣告，則可以保證不論先啟動誰，都會宣告到交換機。

4.2.4 路由模式（ Routing / Direct）

Producer：訊息的生產者（傳送訊息的程式）。
Exchange ：交換機，負責傳送訊息給指定佇列。
routingKey：路由key，即上圖的 key1，key2 等，相當於在交換機和佇列之間又加了一層限制
Queue：訊息佇列，理解為一個容器，生產者向它傳送訊息，它把訊息儲存，等待消費者消費。
Consumer：訊息的消費者（接收訊息的程式）。

4.2.4.1 如何理解

路由模式的交換機型別是 direct，與 fanout 模式相比，多了路由 key 這個概念。生產者傳送攜帶指定 routingKey（路由key）的訊息到交換機，交換機拿著此 routingKey 去找到繫結了這個 routingKey 的佇列，然後傳送到此佇列，一個佇列可以繫結多個 routingKey 。

4.2.4.2 程式碼實現

4.2.4.2.1 生產者程式碼

public class Producer {
    @Test
    public void sendMessage() throws IOException, TimeoutException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order_direct", "direct");
        // 指定 routingKey 
        String key = "info";
        // 釋出訊息
        channel.basicPublish("order_direct", key, null, ("傳送給指定路由" + key + "的訊息").getBytes());
        // 通過工具關閉channel和釋放連線
        RabbitMqUtil.close(channel, connection);
    }
}

指定 routingKey ，即在 basicPublish 方法的第二個引數中，指定 key 的值

4.2.4.2.2 消費者程式碼

消費者 1

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order_direct", "direct");
        // 獲取臨時佇列
        String queue = channel.queueDeclare().getQueue();
        // 繫結臨時佇列和交換機
        channel.queueBind(queue, "order_direct", "info");
        channel.queueBind(queue, "order_direct", "error");
        channel.queueBind(queue, "order_direct", "warn");
        // 消費訊息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者1：消費-" + new String(body));
            }
        });
    }
}

只是在繫結佇列和交換機的時候，增加了 key 這個值

消費者2

public class Consumer2 {
    public static void main(String[] args) throws IOException {
         // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order_direct", "direct");
        // 獲取臨時佇列
        String queue = channel.queueDeclare().getQueue();
        // 繫結臨時佇列和交換機
        channel.queueBind(queue, "order_direct", "error");
        // 消費訊息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者2：消費-" + new String(body));
            }
        });
    }
}

執行結果：只有消費者 1 收到了訊息

消費者1：消費-傳送給指定路由info的訊息

4.2.5 萬用字元匹配模式（Topic）

Producer：訊息的生產者（傳送訊息的程式）。
Exchange ：交換機，負責傳送訊息給指定佇列。
routingKey：路由key，即上圖的 key1，key2 等，相當於在交換機和佇列之間又加了一層限制
- 但是 Topic 中的 key 為萬用字元的形式，這樣可以大大的提高效率
Queue：訊息佇列，理解為一個容器，生產者向它傳送訊息，它把訊息儲存，等待消費者消費。
Consumer：訊息的消費者（接收訊息的程式）。

4.2.5.1 如何理解

萬用字元匹配模式的交換機型別為 topic，因為它與 Direct 模式很相似，所以大家有時候也會把 Direct 模式和 Topic 共同歸入路由模式下，它們的區別就是，Direct 模式的 routingKey 是一個指定的值，而 Topic 模式的 routingKey 可以使用萬用字元，而且一般都是由一個或多個單片語成，多個單詞之間以”.”分割，例如： ideal.insert。

* ：匹配正好一個詞，例如： order.* 可以匹配到 order.insert
#：匹配一個或者多個詞，例如：order.# 可以匹配到 order.insert.common
- # 就像一個多層的概念，而 * 只是一個單層的概念

4.2.5.2 程式碼實現

4.2.5.2.1 生產者程式碼

public class Producer {
    @Test
    public void sendMessage() throws IOException, TimeoutException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        channel.exchangeDeclare("order_topic", "topic");
        // 宣告交換機
        String key = "user.query.all";
        // 釋出訊息
        channel.basicPublish("order_topic", key, null, ("傳送給指定路由" + key + "的訊息").getBytes());
        RabbitMqUtil.close(channel, connection);
    }
}

4.2.5.2.2 消費者程式碼

消費者1

public class Consumer1 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order_topic", "topic");
        // 獲取臨時佇列
        String queue = channel.queueDeclare().getQueue();
        // 指定路由key
        String key = "user.*";
        channel.queueBind(queue, "order_topic", key);
        // 釋出訊息
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者1：消費-" + new String(body));
            }
        });
    }
}

消費者2

public class Consumer2 {
    public static void main(String[] args) throws IOException {
        // 通過工具類獲取連線
        Connection connection = RabbitMqUtil.getConnection();
        // 獲取連線通道
        Channel channel = connection.createChannel();
        // 宣告交換機
        channel.exchangeDeclare("order_topic", "topic");
        // 獲取臨時佇列
        String queue = channel.queueDeclare().getQueue();
        // 指定路由key
        String key = "user.#";
        channel.queueBind(queue, "order_topic", key);
        channel.basicConsume(queue, true, new DefaultConsumer(channel) {
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                System.out.println("消費者2：消費-" + new String(body));
            }
        });
    }
}

執行結果：只有消費者 2 收到了訊息，因為訊息是一個多層的結構，只有 user.# 能匹配到

消費者2：消費-傳送給指定路由user.query.all的訊息

5. Springboot 實現 RabbitMQ

SpringBoot 提供 Spring For RabbitMQ 的啟動器，同時提供了一系列註解以及 RabbitTemplate 供我們使用，能夠極大的簡化開發 RabbitMQ 的步驟，下面分別演示了【5.1 基於純註解】以及【 5.2 基於註解 + 配置類】的寫法，其使用方式大同小異，只是宣告和繫結佇列交換機等的位置不同。一般認為後者更好維護管理，任選其一即可。

環境準備：

首先建立 SprinBoot 專案，然後選擇 RabbitMQ 的啟動器，以及單元測試等基本啟動器
編寫 yml 配置檔案，編寫連線 RabbitMQ 需要的資料

RabbitMQ 依賴

<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-amqp</artifactId>
</dependency>

yml 配置檔案

spring:
  rabbitmq:
    host: 192.168.122.1 # 伺服器地址
    port: 5672 # tcp埠
    username: admin # 使用者名稱
    password: admin # 使用者密碼
    virtual-host: /rabbitmq_springboot_01 # 虛擬主機

5.1 基於純註解

注：此方式沒有建立配置類來管理佇列以及交換機的宣告和繫結等，而是全部通過註解的方式直接在消費者中寫入

5.1.1 簡單佇列模式

所有生產訊息的程式碼，我們都放到 Test 中去做

生產者

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    /**
     * 注入 RabbitTemplate
     */
    @Autowired
    private RabbitTemplate rabbitTemplate;

    @Test
    public void testSimpleSendMessage() {
        rabbitTemplate.convertAndSend("simple_queue", "This is a message !");
    }
}

第一步就是注入 SpringBoot 提供給我們的 RabbitTemplate
通過 RabbitTemplate 的 convertAndSend 方法用來傳送訊息，他有多種過載方式，今天分別會用到 2 個和 3 個引數的
- convertAndSend 方法詳解（兩個引數）
  - 引數1：routingKey（路由key）
  - 引數2：object（傳送的訊息正文）
- convertAndSend 方法詳解（三個引數）
  - 引數1：exchange（交換機）
  - 引數2：routingKey（路由key）
  - 引數3：object（傳送的訊息正文）

消費者

// 注入容器
@Component
// 監聽 RabbitMQ
@RabbitListener(queuesToDeclare = @Queue(value = "simple_queue", durable = "true", exclusive = "false", autoDelete = "false"))
public class SimpleConsumer {
    // 自動回撥
    @RabbitHandler
    public void receiveMessage(String message) {
        System.out.println("消費者：" + message);
    }
}

注入容器
監聽 RabbitMQ，在 @RabbitListener 註解中，可以實現，佇列的宣告，以及後面交換機與佇列的繫結等
- @Queue 可以有四個引數，因為其各有預設值，所以只給定 value 值，就會按照持久化，非獨佔，非自動刪除的方式預設建立
  - 引數1：value（佇列名）
  - 引數2：durable （持久化訊息佇列）RabbitMQ 重啟後，佇列仍存在，預設 true
  - 引數3：exclusive（是否獨佔）表示該訊息佇列是否只在當前 Connection 生效，預設是 false
  - 引數4：auto-delete（自動刪除）表示訊息佇列沒有在使用時將被自動刪除，預設是 false
在方法上新增 @RabbitHandler 註解，就能夠實現自動回撥，這樣我們就能拿到生產者中的訊息了
- 注：receiveMessage 這個方法的引數型別，取決於你在生產者有傳送了什麼型別的資料

5.1.2 工作佇列模式

5.1.2.1 輪詢模式

生產者：沒什麼好說的，因為工作模式有多個消費者，所以多傳送幾條訊息

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    /**
     * 注入 RabbitTemplate
     */
    @Autowired

    @Test
    public void testWorkSendMessage() {
        for (int i = 0; i < 20; i++) {
            rabbitTemplate.convertAndSend("work_queue", "This is a message !, 序號：" + i);
        }
    }
}

消費者

@Component
public class WorkConsumer {  
    // 監聽 RabbitMQ
    @RabbitListener(queuesToDeclare = @Queue("work_queue"))
    // 消費者1
    public void receiveMessage1(String message) {
        System.out.println("消費者1：" + message);
   
    // 監聽 RabbitMQ
    @RabbitListener(queuesToDeclare = @Queue("work_queue")
    // 消費者2
    public void receiveMessage2(String message) {
        System.out.println("消費者2：" + message);
    }    
}

@RabbitListener 註解，既可以放在類上，也可以放在方法上，例如上述程式碼，我們就分別放在了兩個方法上，用來指代不同的消費者。
- 但是如果在類上加入 @RabbitListener 註解，而在下面兩個方法中，新增 @RabbitHandler 註解則會報錯，需要分別為每個消費者都建立一個類

5.1.2.2 公平模式（按能力分配）

5.1.2.2.1 修改配置檔案的方式

生產者不變
修改配置檔案 yml / properties

spring:
  rabbitmq:
    host: 192.168.122.1 # 伺服器地址
    port: 5672 # tcp埠
    username: admin # 使用者名稱
    password: admin # 使用者密碼
    virtual-host: /rabbitmq_springboot_01 # 虛擬主機
	# 新增部分
    listener:
      simple:
        acknowledge-mode: manual # 開啟 ack 手動應答
        prefetch: 1 # 每次只能消費 1 條訊息

acknowledge-mode 選項介紹
- auto：自動確認，為預設選項
- manual：手動確認（按能力分配就需要設定為手動確認）
- none：不確認，傳送後自動丟棄

消費者

@Component
public class WorkConsumer {
	// 監聽 RabbitMQ
    @RabbitListener(queuesToDeclare = @Queue("work_queue"))
    // 消費者 1
    public void receiveMessage(String body, Message message, Channel channel) throws IOException {
        try {
            // 列印輸出訊息主題
            System.out.println("消費者1：" + body);
            // 返回 deliveryTag 代表佇列可以刪除此訊息了
            channel.basicAck(message.getMessageProperties().getDeliveryTag(),false);
        } catch (IOException e) {
            e.printStackTrace();
            // 消費者告訴佇列資訊消費失敗
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
        }
    }
	
   // 監聽 RabbitMQ
    @RabbitListener(queuesToDeclare = @Queue("work_queue"))
    // 消費者 2
    public void receiveMessage2(String body, Message message, Channel channel) throws IOException{
        try {
            // 延遲 2s 代表處理業務慢
            Thread.sleep(2000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }

        try {
			// 列印輸出訊息主題
            System.out.println("消費者2：" + body);
            // 返回 deliveryTag 代表佇列可以刪除此訊息了
            channel.basicAck(message.getMessageProperties().getDeliveryTag(), false);
        } catch (IOException e) {
            e.printStackTrace();
            // 消費者告訴佇列資訊消費失敗
            channel.basicNack(message.getMessageProperties().getDeliveryTag(), false, true);
        }
    }
}

因為在 yml 配置中開啟了手動確認，所以，需要在成功和失敗後分別返回確認訊息
basicAck 方法解釋
- 引數1：deliveryTag（交付標誌，即該訊息的index），返回即代表確認收到訊息，佇列可以刪除此訊息了
- 引數2：mutiple（是否批量）選擇 true 將一次性拒絕所有小於 deliveryTag 的訊息
basicNack 方法解釋
- 引數 1 | 引數 2 同上
- 引數3：requeue（被拒絕的是否重新進入佇列）

執行結果：

消費者1：This is a message !, 序號：2
消費者1：This is a message !, 序號：3
消費者1：This is a message !, 序號：4
消費者1：This is a message !, 序號：5
消費者1：This is a message !, 序號：6
消費者1：This is a message !, 序號：7
消費者1：This is a message !, 序號：8
消費者1：This is a message !, 序號：9
消費者1：This is a message !, 序號：10
消費者1：This is a message !, 序號：11
消費者1：This is a message !, 序號：12
消費者1：This is a message !, 序號：13
消費者1：This is a message !, 序號：14
消費者1：This is a message !, 序號：15
消費者1：This is a message !, 序號：16
消費者1：This is a message !, 序號：17
消費者1：This is a message !, 序號：18
消費者1：This is a message !, 序號：19
消費者1：This is a message !, 序號：20
    
消費者2：This is a message !, 序號：1

到現在已經實現了修改配置檔案的方式實現按能力分配，補充幾個配置的內容，我們上面只用了一部分，其他的方便大家參考，yml 和 properties 大家自己選擇即可

# 傳送確認
spring.rabbitmq.publisher-confirm-type=correlated
# spring.rabbitmq.publisher-confirms=true(舊版)
# 傳送回撥
spring.rabbitmq.publisher-returns=true
# 消費手動確認
spring.rabbitmq.listener.direct.acknowledge-mode=manual
spring.rabbitmq.listener.simple.acknowledge-mode=manual
# 併發消費者初始化值
spring.rabbitmq.listener.simple.concurrency=1
# 併發消費者的最大值
spring.rabbitmq.listener.simple.max-concurrency=10
# 每個消費者每次監聽時可拉取處理的訊息數量
# 在單個請求中處理的訊息個數，他應該大於等於事務數量(unack的最大數量)
spring.rabbitmq.listener.simple.prefetch=1
# 是否支援重試
spring.rabbitmq.listener.simple.retry.enabled=true

5.1.2.2.1 配置工廠的方式

/**
 * 設定消費者的確認機制，並達到能者多勞的效果
 *
 * @param connectionFactory 連線工廠
 * @return
 */
@Bean("workListenerFactory")
public RabbitListenerContainerFactory myFactory(ConnectionFactory connectionFactory) {
    SimpleRabbitListenerContainerFactory containerFactory =
        new SimpleRabbitListenerContainerFactory();
    containerFactory.setConnectionFactory(connectionFactory);
    // 修改為手動確認
    containerFactory.setAcknowledgeMode(AcknowledgeMode.MANUAL);
    // 拒絕策略,true 回到佇列 false丟棄，預設是true
    containerFactory.setDefaultRequeueRejected(true);
    // 預設的PrefetchCount是250 修改為 1
    containerFactory.setPrefetchCount(1);

    return containerFactory;
}

消費者修改

@RabbitListener(queuesToDeclare = @Queue("work_queue"))
// 將上面的監聽，增加 containerFactory 屬性，然後將配置好的工廠傳入
@RabbitListener(queuesToDeclare = @Queue("work_queue"), containerFactory = "workListenerFactory")

5.1.3 釋出與訂閱模式

生產者

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    /**
     * 注入 RabbitTemplate
     */
    @Autowired

    @Test
    public void testFanoutSendMessage() {
        rabbitTemplate.convertAndSend("order_exchange", "", "This is a message !");
    }
}

因為從這個模式開始，就涉及到交換機了，所以用的是三個引數的方法

消費者

@Component
public class FanoutConsumer {
    // 繫結臨時佇列和交換機
    @RabbitListener(bindings = {
            @QueueBinding(
                value = @Queue(), // 臨時佇列
                exchange = @Exchange(name = "order_exchange", type = "fanout") // 交換機與型別
            )
    })
    public void receiveMessage1(String message) {
        System.out.println("消費者1：" + message);
    }

    // 繫結臨時佇列和交換機
    @RabbitListener(bindings = {
            @QueueBinding(
                value = @Queue(), // 臨時佇列
                exchange = @Exchange(name = "order_exchange", type = "fanout") // 交換機與型別
            )
    })
    public void receiveMessage2(String message) {
        System.out.println("消費者2：" + message);
    }
}

5.1.4 路由模式（Direct）

生產者

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    /**
     * 注入 RabbitTemplate
     */
    @Autowired

    @Test
    public void testDirectSendMessage() {
        rabbitTemplate.convertAndSend("direct_exchange", "info", "This is a message !");
    }
}

消費者

@Component
public class DirectConsumer {
    // 繫結臨時佇列和交換機
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue(), // 臨時佇列
                    exchange = @Exchange(name = "direct_exchange", type = "direct"), // 交換機和型別
                    key = {"info", "warn", "error"} // 路由key
            )

    })
    public void receiveMessage1(String message) {
        System.out.println("消費者1：" + message);
    }

     // 繫結臨時佇列和交換機
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue(), // 臨時佇列
                    exchange = @Exchange(name = "direct_exchange", type = "direct"), // 交換機和型別
                    key = {"info", "warn", "error"} // 路由key
            )

    })
    public void receiveMessage2(String message) {
        System.out.println("消費者2：" + message);
    }
}

5.1.5 主題模式

生產者

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    /**
     * 注入 RabbitTemplate
     */
    @Autowired

    @Test
    public void testTopicSendMessage() {
        rabbitTemplate.convertAndSend("topic_exchange", "order.insert.common", "This is a message !");
    }
}

消費者

@Component
public class TopicConsumer {
    // 繫結臨時佇列和交換機
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue(), // 臨時佇列
                    exchange = @Exchange(name = "topic_exchange", type = "topic"), // 交換機和型別
                    key = {"order.*"} // 萬用字元路由key
            )

    })
    public void receiveMessage1(String message) {
        System.out.println("消費者1：" + message);
    }

    // 繫結臨時佇列和交換機
    @RabbitListener(bindings = {
            @QueueBinding(
                    value = @Queue(), // 臨時佇列
                    exchange = @Exchange(name = "topic_exchange", type = "topic"), // 交換機和型別
                    key = {"order.*"} // 萬用字元路由key
            )
    })
    public void receiveMessage2(String message) {
        System.out.println("消費者2：" + message);
    }
}

5.2 基於註解 + 配置類

其實這種方式，就是將交換機，佇列的宣告和繫結都在配置類中進行，一個是消費者中的註解變的簡潔了，再有就是統一管理，更加條理，而且生產者和消費者引用的時候也更加方便，日後修改的時候，也不需要對每一處都修改。

由於篇幅過長了，這裡演示最複雜的 Topic 方式，其他的也是信手拈來。

配置類

@Configuration
public class RabbitMqConfiguration {
    
    public static final String TOPIC_EXCHANGE = "topic_order_exchange";
    public static final String TOPIC_QUEUE_NAME_1 = "test_topic_queue_1";
    public static final String TOPIC_QUEUE_NAME_2 = "test_topic_queue_2";
    public static final String TOPIC_ROUTINGKEY_1 = "test.*";
    public static final String TOPIC_ROUTINGKEY_2 = "test.#";

    @Bean
    public TopicExchange topicExchange() {
        return new TopicExchange(TOPIC_EXCHANGE);
    }

    @Bean
    public Queue topicQueue1() {
        return new Queue(TOPIC_QUEUE_NAME_1);
    }

    @Bean
    public Queue topicQueue2() {
        return new Queue(TOPIC_QUEUE_NAME_2);
    }

    @Bean
    public Binding bindingTopic1(){
        return BindingBuilder.bind(topicQueue1())
                .to(topicExchange())
                .with(TOPIC_ROUTINGKEY_1);
    }
    @Bean
    public Binding bindingTopic2(){
        return BindingBuilder.bind(topicQueue2())
                .to(topicExchange())
                .with(TOPIC_ROUTINGKEY_2);
    }

}

新增 @Configuration 註解：表明這是一個配置類
定義常量：將交換機名，佇列名，路由key 等都可以建立為常量，呼叫，管理和修改都非常方便，還可以建立出一個專門的 RabbitMQ 的常量類。
定義交換機：因為這個例子是 Topic 所以選擇 TopicExchange 型別
定義佇列：傳入佇列名常量即可，因為持久化等存在預設值，也可以自己自定持久化，是否獨佔等引數
繫結交換機和佇列：利用 BindingBuilder 的 bind 方法繫結佇列，to 繫結到指定交換機，with 傳入路由key

生產者

@SpringBootTest(classes = RabbitmqSpringbootApplication.class)
@RunWith(SpringRunner.class)
public class RabbitMqTest {
    /**
     * 注入 RabbitTemplate
     */
    @Autowired

    @Test
    public void testTopicSendMessage() {
        rabbitTemplate.convertAndSend(RabbitMqConfiguration.TOPIC_EXCHANGE, "test.order.insert", "This is a message !");
    }
}

消費者

@Component
public class TopicConsumer {
	// 繫結佇列即可
    @RabbitListener(queues = {RabbitMqConfiguration.TOPIC_QUEUE_NAME_1})
    public void receiveMessage1(String message) {
        System.out.println("消費者1：" + message);
    }
	
    // 繫結佇列即可
    @RabbitListener(queues = {RabbitMqConfiguration.TOPIC_QUEUE_NAME_2})
    public void receiveMessage2(String message) {
        System.out.println("消費者2：" + message);
    }
}

RabbitMQ由淺入深入門全總結（二）
2021-06-17
MQ
由淺到淺入門批量渲染（一）
2020-11-16
由淺到淺入門批量渲染（二）
2020-11-17
由淺到淺入門批量渲染（完）
2021-01-07
由淺到淺入門批量渲染（四）
2021-01-06
深入淺出 RabbitMQ
2021-09-09
MQ
RabbitMQ（一）：RabbitMQ快速入門
2019-07-20
MQ
深入淺出Mybatis原始碼系列（一）---Mybatis入門
2018-09-18
MyBatis原始碼
全網最全RabbitMQ總結，別再說你不會RabbitMQ
2020-01-21
MQ
rabbitmq（一）-基礎入門
2020-11-08
MQ
RabbitMQ入門
2020-08-24
MQ
RabbitMQ 從入門到精通（一）
2019-06-06
MQ
SpringBoot整合RabbitMQ(一)快速入門
2019-01-08
Spring BootMQ
promise由淺入深
2018-03-19
Promise
[轉帖]由淺入深瞭解GC入門篇（一）：什麼是垃圾回收？
2024-05-22
GC
pyFlink 入門總結
2024-05-13
vue 入門總結
2018-11-21
Vue
React入門總結
2019-01-31
React
Nuxt入門總結
2018-09-18
UX
RabbitMQ入門指南
2020-09-01
MQ
RabbitMQ入門案例
2021-08-13
MQ
RabbitMQ快速入門
2019-02-14
MQ
RabbitMQ入門教程
2018-05-09
MQ
RabbitMQ 入門 - 路由
2018-03-28
MQ路由
MySQL索引由淺入深
2021-03-03
MySql索引
JavaScript Promise由淺入深
2019-03-05
JavaScriptPromise
測試入門總結
2020-12-15
HTTPS入門級總結
2018-09-22
HTTP
RabbitMQ 入門(二)基本結構和訊息模型
2024-10-13
MQ模型
RabbitMQ基礎入門
2020-08-23
MQ
RabbitMQ各功能入門
2018-05-31
MQ
RabbitMQ 入門 - 話題
2018-03-28
MQ
RabbitMQ 入門 - Hello World
2018-03-26
MQ
物件導向-由淺入深
2018-12-03
物件
lua淺淺入門瞭解一下
2021-09-09
JavaScript入門⑧-事件總結大全
2022-12-08
JavaScript事件
docker入門知識總結
2020-11-01
Docker
ElasticSearch極簡入門總結
2021-01-23
Elasticsearch

RabbitMQ由淺入深入門全總結（一）

寫在最前面

1. 淺淺道來

1.1 什麼是中介軟體？

1.1.1 分散式的概念（補充）

1.1.1.1 什麼是集中式系統

1.1.12 什麼是分散式系統

1.2 什麼是訊息中介軟體/訊息佇列（MQ）

1.2.1 訊息佇列應用場景

1.2.1.1 業務解耦

1.2.1.2 削峰填谷

1.3 什麼是 RabbitMQ

2. 下載與安裝

2.1 手動安裝

2.1.1 下載安裝過程

2.1.2 配置 Web 介面管理

2.1.2.1 命令小結

2.1.3 簡單介紹 Web 介面管理

2.2 Docker 安裝

2.2.1 配置 yum

2.2.2 安裝 docker

2.2.2.1 步驟

2.2.2.2 Docker 常見命令

2.2.3 安裝 RabbitMQ （任選其一）

2.2.3.1 一步一步安裝

2.2.3.2 一句話安裝

3. RabbitMQ 協議和模型

3.1 協議

3.1.1 什麼是協議？

3.1.1.1 網路協議的三要素

3.1.2 RabbitMQ 的 AMQP 協議

3.1.3 架構模型

4. Java 實現 RabbitMQ

4.1 環境搭建

4.1.1 建立 Java 專案

4.1.2 建立虛擬主機（可選）

4.1.3 建立連線工具類

4.2 五種實現方式

4.2.1 簡單佇列模式（Hello Word）

4.2.1.1 如何理解

4.2.1.2 程式碼實現

4.2.2 工作佇列模式（Work Queue）

4.2.2.1 如何理解

4.2.2.2 程式碼實現

4.2.3 釋出與訂閱模式（Fanout 廣播）

4.2.3.1 如何理解

4.2.3.2 程式碼實現

4.2.4 路由模式（ Routing / Direct）

4.2.4.1 如何理解

4.2.4.2 程式碼實現

4.2.5 萬用字元匹配模式（Topic）

4.2.5.1 如何理解

4.2.5.2 程式碼實現

5. Springboot 實現 RabbitMQ

5.1 基於純註解

5.1.1 簡單佇列模式

5.1.2 工作佇列模式

5.1.2.1 輪詢模式

5.1.2.2 公平模式（按能力分配）

5.1.3 釋出與訂閱模式

5.1.4 路由模式（Direct）

5.1.5 主題模式

5.2 基於註解 + 配置類

相關文章