RabbitMq java操作總結

消息隊列解決了什麼問題?

異步處理
應用解耦
流量削鋒
日誌處理

JAVA操作rabbitmq

Simple 簡單隊列
work queues工作隊列公平分發輪詢分發
publish/subscribe發佈訂閱
Routing 路由選擇通配符模式
Topics 主題
手動和自動確認消息
隊列的持久化和非持久化

RabbitMq安裝步驟：

https://blog.csdn.net/qq_41950069/article/details/81346675

https://www.cnblogs.com/sam-uncle/p/9050242.html

先安裝erlong
再安裝rabbitmq

Rabbit mq 教程：

https://blog.csdn.net/hellozpc/article/details/81436980

安裝好後rabbitmq後臺登錄地址：http://localhost:15672/

賬號密碼：都是guest

Spring boot整合RabbitMq:

https://blog.csdn.net/zhuzhezhuzhe1/article/details/80454956

https://blog.csdn.net/qq_38455201/article/details/80308771

SpringBoot整合RabbitMQ之典型應用場景實戰一:

https://blog.csdn.net/u013871100/article/details/82982235

springboot+rabbitMq整合開發實戰二：模擬用戶下單的過程:

https://blog.csdn.net/u013871100/article/details/78776390

1、添加用戶

用戶界面

Virtual hosts 管理

Virtual hosts 相當於mysql 的 db ，添加的路徑一般以“/”開頭

添加路徑後在上面的表格中就會顯示你添加的路徑，點擊添加的路徑就會進入到下面的界面

給用戶進行授權，選擇添加的用戶進行授權，這樣用戶才能訪問這個地址

2、java操作隊列

2.1簡單隊列

2.1.1 模型

p：消息的生產者

紅色區域：隊列（Queue）

C：消費者

3個對象：生產者隊列消費者

RabbitMQ中的消息都只能存儲在Queue中，生產者（圖中的P）生產消息並最終投遞到Queue中，消費者（圖中的C）可以從Queue中獲取消息並消費。

2.1.2 獲取MQ連接

Java代碼演示：

1、引入maven依賴

<dependency>
<groupId>com.rabbitmq</groupId>
<artifactId>amqp-client</artifactId>
<version>5.7.3</version>
</dependency>

2、編寫連接工具類

public class RabbitConnectionUtil {
//在rabbitmq頁面自己創建的VirtualHost地址
public final static String vHost = "/test_rabbit";
/**
* 創建連接方法
* @return 連接
*/
public static Connection getConnection() throws Exception {
//創建連接工廠
ConnectionFactory connectionFactory = new ConnectionFactory();
//設置服務器地址
connectionFactory.setHost("127.0.0.1");
//設置AHQP 連接端口
connectionFactory.setPort(5672);
//設置VirtualHost 地址
connectionFactory.setVirtualHost(vHost);
//設置用戶名
connectionFactory.setUsername("guest");
//設置密碼
connectionFactory.setPassword("guest");
return connectionFactory.newConnection();
}
}

2.1.3 生產者生產消息

1、首先需要定義隊列的名稱，這裏我將隊列名稱定義提取出來作爲常量，生產者和消費者都是在這個隊列中發送和接收消息

public class RabbitConstant {
public final static String QUEUE_NAME = "test_simple_queue";
}

2、發送隊列消息

public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME,false,false,false,null);
//向隊列中推送消息
String msg = "hello simple !";
channel.basicPublish("",RabbitConstant.QUEUE_NAME,null,msg.getBytes());
System.out.println("send simple success："+msg);
//關閉通道和連接
channel.close();
connection.close();
}

2.1.4 消費者接收消息

1、老版本支持的方法，親測3.x之類的版本支持這種方式，在5.版本已經不支持這種方式

public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列消費者
QueueingConsumer queueingConsumer = new QueueingConsumer(channel);
//監聽隊列
channel.basicConsume(RabbitConstant.QUEUE_NAME,true,queueingConsumer);
while (true){
Delivery delivery = queueingConsumer.nextDelivery();
String msg = new String(delivery.getBody());
System.out.println("Recv success:"+msg);
}
}

2、新版本支持方式

public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME,false,false,false,null);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("Recv success："+msg);
}
};
//監聽隊列
channel.basicConsume(RabbitConstant.QUEUE_NAME,true,consumer);
}

2.1.5 簡單隊列的不足

耦合性高,生產者--對應消費者(如果我想有多個消費者去消費隊列中消息,這時候就不行了)隊列名稱變更這時候得同時變更

2.2 工作隊列（輪詢分發 round-robin）

2.2.1 模型

多個消費者可以訂閱同一個Queue，這時Queue中的消息會被平均分攤給多個消費者進行處理，而不是每個消費者都收到所有的消息並處理。

爲什麼會出現工作隊列？

Simple隊列是一一對應的,而且我們實際開發,生產者發送消息是毫不費力的,而消費者一般是要跟業務相結合的，消費者接收到消息之後就需要處理，處理需要花費時間,這時候隊列就會積壓了很多消息。

2.2.2 生產者

1、首先需要定義隊列的名稱，這裏我將隊列名稱定義提取出來作爲常量，生產者和消費者都是在這個隊列中發送和接收消息

public class RabbitConstant {
public final static String QUEUE_NAME_SIMPLE = "test_simple_queue";
public final static String QUEUE_NAME_WORK = "test_work_queue";
}

2、創建生產者

public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_WORK,false,false,false,null);
//向隊列中推送消息
for(int i = 0; i<50;i++){
String msg = "hello work["+i+"] !";
channel.basicPublish("",RabbitConstant.QUEUE_NAME_WORK,null,msg.getBytes());
System.out.println("send work success："+msg);
Thread.sleep(20);
}
//關閉通道和連接
channel.close();
connection.close();
}

2.2.3 消費者

消費者1：

public class Recv1 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE,false,false,false,null);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【1】Recv success："+msg);
try {
Thread.sleep(600);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【1】 done ！");
}
}
};
//監聽隊列
Boolean autoAck = true;
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE,autoAck,consumer);
}
}

消費者2：

public class Recv2 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE,false,false,false,null);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【2】Recv success："+msg);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【2】 done ！");
}
}
};
//監聽隊列
Boolean autoAck = true;
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE,autoAck,consumer);
}
}

2.2.4 現象

消費者1休眠時間在600ms和消費者2休眠時間在200ms的情況下，消費者1和消費者2處理的消息是一樣多的
消費者1:偶數
消費者2:奇數
這種方式叫做輪詢分發(round-robin)結果就是不管誰忙活誰清閒，都不會多給一個消息，任務總是你一個我一個

2.3 工作隊列（公平分發fail dipatch）

2.3.1 生產者

public class send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_WORK,false,false,false,null);
//在每個消費者發送確認消息之前，消息隊列不發送下一個消息到消費者，1次只處理1個消息
//限制發送給同一個消費者不得超過一次
int prefethCount = 1;
channel.basicQos(prefethCount);
//向隊列中推送消息
for(int i = 0; i<50;i++){
String msg = "hello work["+i+"] !";
channel.basicPublish("",RabbitConstant.QUEUE_NAME_WORK,null,msg.getBytes());
System.out.println("send work success："+msg);
Thread.sleep(20);
}
//關閉通道和連接
channel.close();
connection.close();
}
}

2.3.2 消費者

消費者1：

public class Recv1 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE,false,false,false,null);
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【1】Recv success："+msg);
try {
Thread.sleep(600);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【1】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE,autoAck,consumer);
}
}

消費者2：

public class Recv2 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE,false,false,false,null);
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【2】Recv success："+msg);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【2】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE,autoAck,consumer);
}
}

2.3.3 現象

消費者2處理的消息比消費者1多，能者多勞。因爲在消費者1中設置的是每次處理完一個消息休眠600ms，而消費者2是休眠200毫秒，所以消費者2比消費者1多。

2.4 消息應答與消息持久化

2.4.1 消息應答

//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE,autoAck,consumer);

Boolean autoAck = true;(自動確認模式)，一旦rabbitmq將消息分發給消費者，就會從內存中刪除

這種情況下，如果殺死正在執行的消費者，就會丟失正在處理的消息

Boolean autoAck = false;(手動模式)，如果有1個消費者掛掉，就會交付給其他消費者，rabbitmq支持消息應答,消費者發送一個消息應答,告訴rabbitmq這個消息我已經處理完成你可以刪了,然後rabbitmq就會刪除內存中的消息

消息應答默認是打開的，false

Message acknowledgment:(消息應答)

大家想，如果我們的rabbitmq掛了，我們的消息依然會丟失

2.4.2 消息的持久化

//創建隊列聲明
boolean durale = false;
channel.queueDeclare(RabbitConstant.QUEUE_NAME_WORK,durale,false,false,null);

durale:表示是否持久化，false表示不進行持久化，true表示持久化

我們將程序中的boolean durale = false;改成true是不可以的，儘管代碼是正確的，它也不會執行成功，因爲我們已經定義了一個叫做“test_work_queue”的隊列，這個queue (隊列) 是未持久化的，rabbitmq不允許重新定義（不同參數）一個已經存在的隊列。如果需要重新定義這個隊列的參數，唯一的做法就是進入rabbitmq將這個隊列刪除，再重新啓動java程序，這時就可以重新創建一個修改後參數的隊列。

2.4.3 queueDeclare方法（隊列聲明）

Queue.DeclareOk queueDeclare (String queue , boolean durable , boolean exclusive , boolean autoDelete , Map arguments) throws IOException;

該方法有5各參數：

queue 隊列的名稱

durable: 設置是否持久化。爲 true 則設置隊列爲持久化。持久化的隊列會存盤，在服務器重啓的時候可以保證不丟失相關信息。

exclusive 設置是否排他。爲 true 則設置隊列爲排他的。如果一個隊列被聲明爲排他隊列，該隊列僅對首次聲明它的連接可見，並在連接斷開時自動刪除。這裏需要注意三點:排他隊列是基於連接( Connection) 可見的，同個連接的不同信道 (Channel) 是可以同時訪問同一連接創建的排他隊列; "首次"是指如果個連接己經聲明瞭排他隊列，其他連接是不允許建立同名的排他隊列的，這個與普通隊列不同:即使該隊列是持久化的，一旦連接關閉或者客戶端退出，該排他隊列都會被自動刪除，這種隊列適用於一個客戶端同時發送和讀取消息的應用場景。

autoDelete: 設置是否自動刪除。爲 true 則設置隊列爲自動刪除。自動刪除的前提是: 至少有一個消費者連接到這個隊列，之後所有與這個隊列連接的消費者都斷開時，纔會自動刪除。不能把這個參數錯誤地理解爲: "當連接到此隊列的所有客戶端斷開時，這個隊列自動刪除"，因爲生產者客戶端創建這個隊列，或者沒有消費者客戶端與這個隊列連接時，都不會自動刪除這個隊列。

argurnents: 設置隊列的其他一些參數，如 x-rnessage-ttl 、x-expires 、x-rnax-length 、x-rnax-length-bytes、 x-dead-letter-exchange、 x-deadletter-routing-key 、 x-rnax-priorit

2.5 訂閱模式（publish_subscribe）

2.5.1 模型

解讀：

1,一個生產者,多個消費者

2,每一個消費者都有自己的隊列

3.生產者沒有直接把消息發送到隊列而是發到了交換機轉發器exchange

4,每個對列都要綁定到交換機上

5.生產者發送的消息經過交換機到達隊列，就能實現一個消息被多個消費者消費

註冊 --> 郵件 --> 短信

2.5.2 生產者

首先定義交換機名稱

public class RabbitConstant {
public final static String QUEUE_NAME_SIMPLE = "test_simple_queue";
public final static String QUEUE_NAME_WORK = "test_work_queue";
public final static String EXCHANGE_NAME_FANOUT = "test_fanout_exchange";//交換機名稱
}

2.創建生產者

public class send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//聲明交換機
channel.exchangeDeclare(RabbitConstant.EXCHANGE_NAME_FANOUT,"fanout");//分發
//向交換機中推送消息
String msg = "hello publish subscribe !";
channel.basicPublish(RabbitConstant.EXCHANGE_NAME_FANOUT,"", null, msg.getBytes());
System.out.println("send publish subscribe success：" + msg);
//關閉通道和連接
channel.close();
connection.close();
}
}

通過控制檯可以看到，並沒有我們發送的消息，消息哪去了?

丟失了，因爲交換機沒有存儲的能力,在rabbitmq裏面只有隊列有存儲能力，因爲這時候還沒有隊列綁定到這個交換機所以數據丟失了。

2.5.3 消費者

首先定義綁定到交換機的隊列的名稱

public class RabbitConstant {
public final static String QUEUE_NAME_SIMPLE = "test_simple_queue";
public final static String QUEUE_NAME_WORK = "test_work_queue";
public final static String EXCHANGE_NAME_FANOUT = "test_fanout_exchange";//交換機名稱
public final static String QUEUE_NAME_EXCHANGE_BIND_EMIL = "test_queue_fanout_emil";//綁定到交換機的隊列
public final static String QUEUE_NAME_EXCHANGE_BIND_SMS = "test_queue_fanout_sms";//綁定到交換機的隊列
}

2、創建消費者

消費者1：

public class Recv1 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_EMIL,false,false,false,null);
//綁定隊列到交換機
channel.queueBind(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_EMIL,RabbitConstant.EXCHANGE_NAME_FANOUT,"");
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【1】Recv success："+msg);
try {
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【1】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_EMIL,autoAck,consumer);
}
}

消費者2：

public class Recv2 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_SMS,false,false,false,null);
//綁定隊列到交換機
channel.queueBind(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_SMS,RabbitConstant.EXCHANGE_NAME_FANOUT,"");
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【2】Recv success："+msg);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【2】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_SMS,autoAck,consumer);
}
}

2.5.4 總結

在控制界面可以看到有兩個隊列已經綁定到了轉換器上

測試結果：同一個消息被多個消費者獲取。一個消費者隊列可以有多個消費者實例，只有其中一個消費者實例會消費到消息。這個怎麼說呢，在同一個隊列中呢，只能有一個消費者可以獲得消息，因爲這是點對點，是隊列的特性，誰把這個機會搶走了，這個機會就沒有了。

發佈訂閱類似廣播，發送方只管向外發送消息，接收方呢只要去聽這個廣播就能得到廣播的消息，但是如果你剛好不在，那麼廣播裏的內容也就錯過了。在rabbitmq中就是綁定到交換機的隊列的消費者可以接收到這個消息。

2.6 exchange (交換機轉換器)

2.6.1 說明

作用：一方面是接收生產者的消息,另一方面是向隊列推送消息

2.6.1.1 匿名轉發

//發送消息
String exchange = "";
channel.basicPublish(exchange,RabbitConstant.QUEUE_NAME_WORK,null,msg.getBytes());

匿名轉發：”” （exchange爲空串表示匿名轉發）也就是不指定轉化器，也就是在普通的隊列模式中使用

2.6.1.2 不處理路由（Fanout）

//聲明交換機
channel.exchangeDeclare(RabbitConstant.EXCHANGE_NAME_FANOUT,"fanout");//分發

Fanout (不處理路由鍵)

只要綁定到交換機的隊列都能獲取到消息

//向交換機中推送消息
String routingKey= "";
channel.basicPublish(RabbitConstant.EXCHANGE_NAME_FANOUT,routingKey, null, msg.getBytes());

不處理路由：”” （routingKey爲空串表示不處理路由）

2.6.1.3 處理路由（Direct）

Direct (處理路由鍵)

通過模型我們可以看到，在發送方推送消息時指定路由鍵的名稱，在接收方的隊列必須指定對應的路由鍵才能獲得相應的消息，這就可以讓我們選擇性的訂閱指定消息

發送方：

//聲明交換機
channel.exchangeDeclare(RabbitConstant.EXCHANGE_NAME_FANOUT,"direct");//分發
//向交換機中推送消息
String msg = "hello publish subscribe !";
String routingKey= "text_routing_key";
channel.basicPublish(RabbitConstant.EXCHANGE_NAME_FANOUT,routingKey, null, msg.getBytes());

接收方：

//綁定隊列到交換機
String routingKey= "text_routing_key";
channel.queueBind(RabbitConstant.QUEUE_NAME_EXCHANGE_BIND_EMIL,RabbitConstant.EXCHANGE_NAME_FANOUT,routingKey);

2.6.1.4 主題（Topic）

將路由鍵和某模式進行匹配

#匹配一個或多個單詞

*匹配一個單詞

比如：goods.*只能匹配到 goods.add , goods.# 則可以匹配到goods.add.chongqing

指定爲主題模式時，可以通過#、*通配符來匹配不同的路由鍵

生產者：

/聲明交換機
channel.exchangeDeclare(RabbitConstant.EXCHANGE_NAME_TOPIC,"topic");//分發
//向交換機中推送消息
String msg = "hello publish subscribe !";
String routingKey = "goods.add";//指定路由鍵
channel.basicPublish(RabbitConstant.EXCHANGE_NAME_TOPIC,routingKey, null, msg.getBytes());

接收方：

//綁定隊列到交換機
String routingKey = "goods.#";//指定路由鍵
channel.queueBind(RabbitConstant.QUEUE_NAME_TOPIC_TWO,RabbitConstant.EXCHANGE_NAME_TOPIC,routingKey);

2.6.2 basicPublish 方法（發送消息）

void basicPublish(String exchange, String routingKey, boolean mandatory, boolean immediate, BasicProperties props, byte[] body) throws IOException;

exchange：交換機的名稱

routingKey：路由鍵，#匹配0個或多個單詞，*匹配一個單詞，在topic exchange做消息轉發用

mandatory：true：如果exchange根據自身類型和消息routeKey無法找到一個符合條件的queue，那麼會調用basic.return方法將消息返還給生產者。false：出現上述情形broker會直接將消息扔掉

immediate：true：如果exchange在將消息route到queue(s)時發現對應的queue上沒有消費者，那麼這條消息不會放入隊列中。當與消息routeKey關聯的所有queue(一個或多個)都沒有消費者時，該消息會通過basic.return方法返還給生產者。
BasicProperties ：需要注意的是BasicProperties.deliveryMode，0:不持久化 1：持久化這裏指的是消息的持久化，配合channel(durable=true),queue(durable)可以實現，即使服務器宕機，消息仍然保留

body：推送的消息內容

簡單來說：mandatory標誌告訴服務器至少將該消息route到一個隊列中，否則將消息返還給生產者；immediate標誌告訴服務器如果該消息關聯的queue上有消費者，則馬上將消息投遞給它，如果所有queue都沒有消費者，直接把消息返還給生產者，不用將消息入隊列等待消費者了。

2.7路由模式

2.7.1 模型

2.7.2 生產者

1、定義路由模式下交換機名稱

public class RabbitConstant {
/**
* 簡單隊列使用
*/
public final static String QUEUE_NAME_SIMPLE = "test_simple_queue";
/**
* 工作隊列使用
*/
public final static String QUEUE_NAME_WORK = "test_work_queue";
/**
* 發佈訂閱使用（不路由)
*/
public final static String EXCHANGE_NAME_FANOUT = "test_fanout_exchange";//交換機名稱
public final static String QUEUE_NAME_EXCHANGE_BIND_EMIL = "test_queue_fanout_emil";//綁定到交換機的隊列
public final static String QUEUE_NAME_EXCHANGE_BIND_SMS = "test_queue_fanout_sms";//綁定到交換機的隊列
/**
* 發佈訂閱使用（路由）
*/
public final static String EXCHANGE_NAME_DIRECT = "test_direct_exchange";//交換機名稱
public final static String QUEUE_NAME_DIRECT_ONE = "test_queue_direct_one";//綁定到交換機隊列
public final static String QUEUE_NAME_DIRECT_TWO = "test_queue_direct_two";//綁定到交換機對列
}

2. 創建生產者

public class send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//聲明交換機
channel.exchangeDeclare(RabbitConstant.EXCHANGE_NAME_DIRECT,"direct");//分發
//向交換機中推送消息
String msg = "hello publish subscribe !";
String routingKey = "error";//指定路由鍵
// routingKey = "warning";
// routingKey = "info";
channel.basicPublish(RabbitConstant.EXCHANGE_NAME_DIRECT,routingKey, null, msg.getBytes());
System.out.println("send publish subscribe success：" + msg);
//關閉通道和連接
channel.close();
connection.close();
}
}

2.7.3 消費者

隊列名稱的定義在上面生產者那裏已經給出

消費者1：

public class Recv1 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_DIRECT_ONE,false,false,false,null);
//綁定隊列到交換機
String routingKey = "error";//指定路由鍵
channel.queueBind(RabbitConstant.QUEUE_NAME_DIRECT_ONE,RabbitConstant.EXCHANGE_NAME_DIRECT,routingKey);
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【1】Recv success："+msg);
try {
Thread.sleep(600);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【1】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_DIRECT_ONE,autoAck,consumer);
}
}

消費者2：

public class Recv2 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_DIRECT_TWO,false,false,false,null);
//綁定隊列到交換機
String routingKey = "error";//指定路由鍵
channel.queueBind(RabbitConstant.QUEUE_NAME_DIRECT_TWO,RabbitConstant.EXCHANGE_NAME_DIRECT,routingKey);
routingKey = "info";
channel.queueBind(RabbitConstant.QUEUE_NAME_DIRECT_TWO,RabbitConstant.EXCHANGE_NAME_DIRECT,routingKey);
routingKey = "warning";
channel.queueBind(RabbitConstant.QUEUE_NAME_DIRECT_TWO,RabbitConstant.EXCHANGE_NAME_DIRECT,routingKey);
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【2】Recv success："+msg);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【2】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_DIRECT_TWO,autoAck,consumer);
}
}

2.7.4 總結

通過消費者代碼我們可以看到，消費者1只能接收到路由鍵是“error”的消息，消費者2可以接收到路由鍵是“error”、“info”、“warning”的消息。

我們通過改變生產者中的路由鍵名稱就能指定到哪些消費者可以接收消息了。

2.8 主題模式

2.8.1 模型

Topic Exchange-將路由鍵和某模式進行匹配。此時隊列需要綁定要一個模式上，符號"#"匹配一個或多個詞，符號匹配不多不少一個詞。因此" audit.# "能夠匹配到"audit.irs.corporate",但是" audit.* "只會匹配到"auditirs.irs"。

2.8.2 生產者

1、定義主題模式下轉換器名稱

public class RabbitConstant {
/**
* 簡單隊列使用
*/
public final static String QUEUE_NAME_SIMPLE = "test_simple_queue";
/**
* 工作隊列使用
*/
public final static String QUEUE_NAME_WORK = "test_work_queue";
/**
* 發佈訂閱使用（不處理路由模式【訂閱模式】 Fanout)
*/
public final static String EXCHANGE_NAME_FANOUT = "test_fanout_exchange";//交換機名稱
public final static String QUEUE_NAME_EXCHANGE_BIND_EMIL = "test_queue_fanout_emil";//綁定到交換機的隊列
public final static String QUEUE_NAME_EXCHANGE_BIND_SMS = "test_queue_fanout_sms";//綁定到交換機的隊列
/**
* 發佈訂閱使用（處理路由模式 Direct）
*/
public final static String EXCHANGE_NAME_DIRECT = "test_direct_exchange";//交換機名稱
public final static String QUEUE_NAME_DIRECT_ONE = "test_queue_direct_one";//綁定到交換機隊列
public final static String QUEUE_NAME_DIRECT_TWO = "test_queue_direct_two";//綁定到交換機對壘
/**
* 發佈訂閱使用（主題模式 Topic）
*/
public final static String EXCHANGE_NAME_TOPIC = "test_topic_exchange";//交換機名稱
public final static String QUEUE_NAME_TOPIC_ONE = "test_queue_topic_one";//綁定到交換機隊列
public final static String QUEUE_NAME_TOPIC_TWO = "test_queue_topic_two";//綁定到交換機對壘
}

2、創建生產者

public class send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//聲明交換機
channel.exchangeDeclare(RabbitConstant.EXCHANGE_NAME_TOPIC,"topic");//分發
//向交換機中推送消息
String msg = "hello publish subscribe !";
String routingKey = "goods.add";//指定路由鍵
// routingKey = "goods.update";
channel.basicPublish(RabbitConstant.EXCHANGE_NAME_TOPIC,routingKey, null, msg.getBytes());
System.out.println("send publish subscribe success：" + msg);
//關閉通道和連接
channel.close();
connection.close();
}
}

2.8.3 消費者

隊列名稱的定義在上面生產者那裏已經給出

消費者1：

public class Recv1 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_TOPIC_ONE,false,false,false,null);
//綁定隊列到交換機
String routingKey = "goods.add";//指定路由鍵
channel.queueBind(RabbitConstant.QUEUE_NAME_TOPIC_ONE,RabbitConstant.EXCHANGE_NAME_TOPIC,routingKey);
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【1】Recv success："+msg);
try {
Thread.sleep(600);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【1】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_TOPIC_ONE,autoAck,consumer);
}
}

消費者2：

public class Recv2 {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
final Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_TOPIC_TWO,false,false,false,null);
//綁定隊列到交換機
String routingKey = "goods.#";//指定路由鍵
channel.queueBind(RabbitConstant.QUEUE_NAME_TOPIC_TWO,RabbitConstant.EXCHANGE_NAME_TOPIC,routingKey);
//保證一次只分發一個
channel.basicQos(1);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("【2】Recv success："+msg);
try {
Thread.sleep(200);
} catch (InterruptedException e) {
e.printStackTrace();
}finally {
System.out.println("【2】 done ！");
//手動回執消息
channel.basicAck(envelope.getDeliveryTag(),false);
}
}
};
//監聽隊列
Boolean autoAck = false;//自動應答改爲false
channel.basicConsume(RabbitConstant.QUEUE_NAME_TOPIC_TWO,autoAck,consumer);
}
}

2.8.4 總結

通過消費者代碼我們可以看到，消費者1只能接收到路由鍵是“goods.add”的消息，消費者2路由鍵爲“goods.#”，可以接收到路由鍵是“goods.add”、“goods.update”、“goods.delete.tt”等含“goods.”前綴的1-n個單詞組成的鍵的消息。

如果路由鍵是“goods.*”的話，只能匹配到前綴爲“goods.”的一個單詞的路由鍵，比如可以匹配“goods.add”，但是不能匹配“goods.delete.tt”。

2.9 RabiitMq的消息確認機制（事務+confirm）

在rabbitmq中我們可以通過持久化數據解決rabbitmq服務器異常的數據丟失問題

問題：生產者將消息發送出去之後,消息到底有沒有到達rabbitmq服務器，默認的情況是不知道的

兩種方式：
AMOP實現了事務機制
Confirm模式

2.9.1 事務機制

txSelect txCommit txRollback
txSelect：用戶將當前channel設置成transation模式,
txCommit：用於提交事務
txRollback：回滾事務

2.9.1.1 生產者

public class send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE,false,false,false,null);
try {
//開啓事務
channel.txSelect();
//向隊列中推送消息
String msg = "hello tx message!";
channel.basicPublish("",RabbitConstant.QUEUE_NAME_SIMPLE,null,msg.getBytes());
//事務提交
channel.txCommit();
System.out.println("send tx success："+msg);
}catch (Exception e){
//事務回滾
channel.txRollback();
System.out.println("send tx message rollback !");
}
//關閉通道和連接
channel.close();
connection.close();
}
}

2.9.1.2 消費者

public class Recv {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE,false,false,false,null);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body,"utf-8");
System.out.println("Recv【tx】 success："+msg);
}
};
//監聽隊列
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE,true,consumer);
}
}

2.9.1.3 總結

在生產者處開啓事務處理，如果發生異常則消息將不會進行提交，而是會進行回滾，那麼消費者端是接收不到消息的。這個事務處理機制因爲連接增加了，降低了消息服務器mq的吞吐量。

2.9.2 confirm模式

2.9.2.1 實現原理

生產者將信道設置成confirm模式，一旦信道進入confirm模式，所有在該信道上面發的消息都會被指派一個唯一的ID(從1開始)，一旦消息被投遞到所有匹配的隊列之後，broker就會發送一個確認給生產者(包含消息的唯一ID)，這就使得生產者知道消息已經確到達目的隊列了，如果消息和隊列是可持久化的，那麼確認消息會將消息寫入磁盤之後發出，broker回傳給生產者的確認消息中deliver-tag域包含了確認消息的序列號,此外broker也可以設置basic.ack的multiple域，表示到這個序列號之前的所有消息都已經得到了處理。

Confirm最大的好處是異步處理的，不用等待信道返回確認消息，而繼續發送其他消息

如果mq崩潰異常導致數據丟失會返回一條Nack消息，生產者可以利用回調進行處理

開啓confirm：

channel.confirmSelect();

編程模式：

普通模式：

發一條：waitForConfirms()

批量發：waitForConfirms()

異步confirm模式：

提供一個回調方法

2.9.2.2 生產者（簡單模式）

定義隊列名稱：

public final static String QUEUE_NAME_SIMPLE_CONFIRM = "test_simple_confirm_queue";

1、Confirm 單條：

public class send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, false, false, false, null);
//開啓confirm模式
channel.confirmSelect();
//向隊列中推送消息
String msg = "hello confirm message!";
channel.basicPublish("", RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, null, msg.getBytes());
//確認
if(!channel.waitForConfirms()){
System.out.println("send confirm failed：" + msg);
}else {
System.out.println("send confirm success：" + msg);
}
//關閉通道和連接
channel.close();
connection.close();
}
}

2、批量

public class SendBatch {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, false, false, false, null);
//開啓confirm模式
channel.confirmSelect();
//批量向隊列中推送消息
String sendMsg = "";
for(int i = 0;i<20;i++){
sendMsg = "hello confirm message{"+i+"] !";
channel.basicPublish("", RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, null, sendMsg.getBytes());
}
//確認
if(!channel.waitForConfirms()){
System.out.println("Send confirm failed：");
}else {
System.out.println("Send confirm success：");
}
//關閉通道和連接
channel.close();
connection.close();
}
}

發完消息在進行確認

2.9.2.3 生產者（異步模式）

Channel對象提供的Confirmlistener()回調方法只包含deliveryTag (當前Chanel發出的消息序號)，我們需要自己爲每一個Channel維護一個unconfirm的消息序號集合，每 publish一條數據，集合中元素加1，每回調一次handleAck方法, unconfirm集合刪掉相應的一條(multiple=false)或多條(multiple=true)記錄。從程序運行效率上看，這個unconfirm集合最好採用有序集合SortedSet存儲結構。

生產者：

public class Send {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, false, false, false, null);
//開啓confirm模式
channel.confirmSelect();
//未確認的消息標識
final SortedSet<Long> confirmSet = Collections.synchronizedSortedSet(new TreeSet<Long>());
channel.addConfirmListener(new ConfirmListener(){
//沒有問題的handleAck
public void handleAck(long deliveryTag, boolean multiple) {
if(multiple){
System.out.println("----handleAck----multiple");
confirmSet.headSet(deliveryTag+1).clear();
}else {
System.out.println("----handleAck----multiple false");
confirmSet.remove(deliveryTag);
}
}
//handleNack
public void handleNack(long deliveryTag, boolean multiple) {
if(multiple){
System.out.println("----handleNack----multiple");
confirmSet.headSet(deliveryTag+1).clear();
}else {
System.out.println("----handleNack----multiple false");
confirmSet.remove(deliveryTag);
}
}
});
//向隊列中推送消息
for(int i = 0 ;i<50;i++){
long nextPublishSeqNo = channel.getNextPublishSeqNo();
String msg = "hello confirm message["+i+"] !";
channel.basicPublish("", RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, null, msg.getBytes());
confirmSet.add(nextPublishSeqNo);
}
//關閉通道和連接
channel.close();
connection.close();
}
}

2.9.2.4 消費者

public class Recv {
public static void main(String[] args) throws Exception {
//創建連接
Connection connection = RabbitConnectionUtil.getConnection();
//創建通道
Channel channel = connection.createChannel();
//創建隊列聲明
channel.queueDeclare(RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, false, false, false, null);
//重寫handleDelivery 方法，實現阻塞之後獲取消息的處理
Consumer consumer = new DefaultConsumer(channel) {
//獲取到達的消息
@Override
public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
super.handleDelivery(consumerTag, envelope, properties, body);
//打印接收到的內容
String msg = new String(body, "utf-8");
System.out.println("Recv【confirm】 success：" + msg);
}
};
//監聽隊列
channel.basicConsume(RabbitConstant.QUEUE_NAME_SIMPLE_CONFIRM, true, consumer);
}
}

3、Spring集成Rabbitmq

3.1 引入maven依賴

<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit</artifactId>
<version>2.1.8.RELEASE</version>
</dependency>

3.2 配置application.xml文件

<beans xmlns="http://www.springframework.org/schema/beans"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xmlns:rabbit="http://www.springframework.org/schema/rabbit"
xsi:schemaLocation="http://www.springframework.org/schema/rabbit
https://www.springframework.org/schema/rabbit/spring-rabbit.xsd
http://www.springframework.org/schema/beans
https://www.springframework.org/schema/beans/spring-beans.xsd">
<rabbit:connection-factory id="connectionFactory" host="127.0.0.1" port="5672" username="guest" password="guest" virtual-host="/test_rabbit"/>
<rabbit:template id="amqpTemplate" connection-factory="connectionFactory" exchange="fanoutExchange"/>
<rabbit:admin connection-factory="connectionFactory"/>
<rabbit:queue name="myqueue" auto-declare="true" durable="true"/>
<rabbit:fanout-exchange name="fanoutExchange" auto-declare="true">
<rabbit:bindings>
<rabbit:binding queue="myqueue"/>
</rabbit:bindings>
</rabbit:fanout-exchange>
<rabbit:listener-container connection-factory="connectionFactory">
<rabbit:listener ref="foo" method="listen" queue-names="myqueue"/>
</rabbit:listener-container>
<bean id="foo" class="com.rabbit.test.spring.MyConsumer"/>
</beans>

3.3 創建消費者監聽

public class MyConsumer {
//具體執行的業務方法
public void listen(String foo){
System.out.println("消費者："+foo);
}
}

3.4 創建生產者發送消息

public class SpringMain {
public static void main(String[] args) throws Exception {
//獲得配置上下文
AbstractApplicationContext ctx = new ClassPathXmlApplicationContext("classpath:application.xml");
//得到rabbitmq模板
RabbitTemplate rabbitTemplate = ctx.getBean(RabbitTemplate.class);
//發送消息
rabbitTemplate.convertAndSend("hello word !");
Thread.sleep(1000);
ctx.destroy();
}
}

RabbitMq 操作總結

RabbitMq java操作總結

1、添加用戶

用戶界面

Virtual hosts 管理

2、java操作隊列

2.1簡單隊列

2.1.1 模型

2.2 工作隊列（輪詢分發 round-robin）

2.3 工作隊列（公平分發fail dipatch）

2.3.1 生產者

2.4 消息應答與消息持久化

2.5 訂閱模式（publish_subscribe）

2.6 exchange (交換機轉換器)

2.7路由模式

2.8 主題模式

2.9 RabiitMq的消息確認機制（事務+confirm）

3、Spring集成Rabbitmq

3.1 引入maven依賴

3.2 配置application.xml文件

3.3 創建消費者監聽

3.4 創建生產者發送消息

對switch進行拆分重構，降低複雜度，5種方式

webpack4.x打包圖片文件遇到效果不顯示的問題（file-loader加載遇到的狗血問題）

feign調用文件上傳服務

Feign微服務調用文件上傳微服務

linux下安裝redis與配置

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結

RabbitMq 操作總結

RabbitMq java操作總結

1、添加用戶

用戶界面

Virtual hosts 管理

2、java操作隊列

2.1簡單隊列

2.1.1 模型

2.2 工作隊列（輪詢分發 round-robin）

2.3 工作隊列（公平分發fail dipatch）

2.3.1 生產者

2.4 消息應答與消息持久化

2.5 訂閱模式（publish_subscribe）

2.6 exchange (交換機 轉換器)

2.7路由模式

2.8 主題模式

2.9 RabiitMq的消息確認機制（事務+confirm）

3、Spring集成Rabbitmq

3.1 引入maven依賴

3.2 配置application.xml文件

3.3 創建消費者監聽

3.4 創建生產者發送消息

2.6 exchange (交換機轉換器)