>來源：[恆生LIGHT雲社群](https://developer.hs.net/thread/984)

## **RabbitMQ是什麼**

RabbitMQ是部署最廣泛的開源訊息代理。RabbitMQ有輕量級且易部署的特點。支援多種訊息協議。

## **為什麼使用RabbitMQ**

常見的使用場景有解耦、非同步、削峰填谷。下面我們透過例子來感受下各自場景下使用MQ帶來的效益。

****解耦****

假設有系統A，依賴系統B、系統C、系統D，依賴關係在程式碼中已經寫死，結構如下圖。

![1621939617(1).png](https://developer.hs.net/storage/attachments/2021/05/28/q6RXvU7XSk8h1g2bCcHjyjvXnnjQTxj7QZ5wg3jC_thumb.png "1154")

假設此時又來了一個新需求，系統A需要呼叫系統E進行一些新的業務操作，那麼系統A的程式設計師又免不了一頓操作，處理接入系統E的需求。同理如果要去掉某個系統的依賴比如系統C，也需要系統A負責的開發進行處理。

那麼此時我們如果引入了MQ來看看會帶來什麼樣的變化。

![image-20210525185231787.png](https://developer.hs.net/storage/attachments/2021/05/28/fRvGOedkN2nXMJC4NOrB6fzhb9ZbPu62DvXub4XJ_thumb.png "1155")

系統A傳送訊息到MQ，系統B、C、D訂閱對應的訊息進行業務處理。那麼我們再來看看之前的場景，假設需要增加一個依賴系統E,只需要系統E的開發人員進行對應的訂閱消費即可，同理如果要取消系統C的依賴，只需要系統C取消訂閱對應的訊息。

****非同步****

假設系統A操作耗時30ms，系統A還將同步呼叫系統B(300ms)、系統C(600ms)、系統D(200ms)那麼這個請求的響應時間將會達到1130ms。過長的響應時間會給客戶帶來不好的使用者體驗。

![1621940629(1).png](https://developer.hs.net/storage/attachments/2021/05/28/CeDxkDZ5e2kBaYdEk2Qd4gzQZIcztrqnz9b1flZc_thumb.png "1156")

引入MQ之後我們看看會發生什麼變化

![image-20210525190839346.png](https://developer.hs.net/storage/attachments/2021/05/28/rv0HGHpVp9KtK8mWb5YMGQTfPCxHF59ytfHZbAiA_thumb.png "1157")

系統A將訊息傳送給MQ（7ms）之後就返回，系統B、C、D分別監聽MQ進行業務處理。那麼我們看到針對剛才長耗時的同步依賴，引入MQ進行非同步處理後，總體的響應時間從1130ms降到了37ms。

****削峰填谷****

假設我們有個業務高峰期的請求量能夠到達7000 /s而業務低谷流量只有100/s,但是我們的mysql資料庫只能承受2000/s的請求。

![1621941575(1).png](https://developer.hs.net/storage/attachments/2021/05/28/jdRvaN9m7yvAOJN64m06zDhu0iNFXI7qTszoAPCW_thumb.png "1158")

在這種情況下會導致在高峰期超過了mqsql最高的負載能力而直接打掛，而低峰期沒有將mqsql的資源合理利用起來。

引入MQ之後我們看看會發生什麼變化

![image-20210525192439287.png](https://developer.hs.net/storage/attachments/2021/05/28/4qOoull0hv0gnJIElkdTrGtgG4QLt207GcyVsaep_thumb.png "1159")

此時系統可以按照自己最大的消費能力2000/s去拉取訊息，可以平穩度過業務高峰期，同時將一部分訊息延遲到業務低谷時期進行處理。不至於出現由於高流量導致資料庫被打掛，出現整體服務不可用的現象。

## **怎樣使用RabbitMQ**

本小節主要針對RabbitMQ的java客戶端編寫的幾個常用的例子，如果您對使用RabbitMQ已熟練掌握，可跳過本小節。檢視完整的RabbitMQ使用說明，請訪問[**官方文件**](https://www.rabbitmq.com/tutorials/tutorial-one-java.html)**。**

****Hello world****

我們透過一個Hello world 的例子來感受下RabbitMQ。首先介紹下本例中使用到的術語

* Producer：生產者，用來傳送訊息。
* Queue：訊息佇列，用於儲存訊息，訊息經由生產者投遞到訊息佇列，最終被投遞到消費者進行消費，訊息佇列收到機器記憶體和硬碟資源的限制。
* Consumer：消費者，用於接收並處理訊息。

本例中我們我們將生產Hello World的訊息，透過消費者接受並列印出訊息。

![1621942986(1).png](https://developer.hs.net/storage/attachments/2021/05/28/bmHrdiHjQ2ACeTsBTH7QGgJ91e6PzpivaunespTh_thumb.png "1160")

生產者Send 關鍵步驟見註釋說明

```java
public class Send {
	//佇列名稱
    private final static String QUEUE_NAME = "hello";

public static void main(String[] argv) throws Exception {
        //建立和server之間的連線 connection、channel
        ConnectionFactory factory = new ConnectionFactory();
        //請設定實際部署節點ip
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            //宣告一個queue去傳送訊息
            channel.queueDeclare(QUEUE_NAME, false, false, false, null);
            String message = "Hello World!";
            //釋出訊息
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}
```

[**完整Send程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/Send.java)

消費者Recv  關鍵步驟見註釋說明

```java
public class Recv {
	//佇列名稱
    private final static String QUEUE_NAME = "hello";

public static void main(String[] argv) throws Exception {
        //建立和server之間的連線 connection、channel
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
		//宣告要去消費的佇列
        channel.queueDeclare(QUEUE_NAME, false, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
		//透過該類來處理訊息
        DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        channel.basicConsume(QUEUE_NAME, true, deliverCallback, consumerTag -> { });
    }
}
```

[**完整Recv程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/Recv.java)

****Work Queues****

在本例中我們將介紹透過RabbitMQ分發耗時任務給多個工作者。RabbitMQ會透過輪詢(round-robin)的方式將訊息投遞給消費者，這是的我們能夠很容易的擴充套件消費能力。

![1621944984(1).png](https://developer.hs.net/storage/attachments/2021/05/28/6zwCu00KCai6EpzR9yUfJWvbTxOAT7MldYpmLVhd_thumb.png "1161")

生產者NewTask  關鍵步驟見註釋說明

```java
public class NewTask {

private static final String TASK_QUEUE_NAME = "task_queue";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            //將佇列設定成持久化
            channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

String message = String.join(" ", argv);
			//將訊息設定成持久化
            channel.basicPublish("", TASK_QUEUE_NAME,
                    MessageProperties.PERSISTENT_TEXT_PLAIN,
                    message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }

}
```

[**完整NewTask程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/NewTask.java)

消費者Woker 關鍵步驟見註釋說明

```java
public class Worker {

private static final String TASK_QUEUE_NAME = "task_queue";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        final Connection connection = factory.newConnection();
        final Channel channel = connection.createChannel();
		//將佇列設定成持久化
        channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");
		//一個消費者最多同時處理一個未確認的訊息
        channel.basicQos(1);

DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");

System.out.println(" [x] Received '" + message + "'");
            try {
                doWork(message);
            } finally {
                System.out.println(" [x] Done");
                channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);
            }
        };
        channel.basicConsume(TASK_QUEUE_NAME, false, deliverCallback, consumerTag -> { });
    }
	//模擬耗時任務，一個.代表耗時1S
    private static void doWork(String task) {
        for (char ch : task.toCharArray()) {
            if (ch == '.') {
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException _ignored) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}
```

[**完整Worker程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/Worker.java)

****Publish/Subscribe****

上面我們已經介紹過RabbitMQ的核心訊息模型，生產者、消費者、佇列，在本小節我們將接觸到另一個訊息模型*exchange*** ，它負責從生產者中接收訊息，並把訊息投遞到佇列中。exchage主要有以下幾種型別**

* direct
* topic
* headers
* fanout

本例中我們將已fanout型別作為講解，透過名稱我們大概也能猜到此型別exchange會廣播接收到的訊息到其繫結的佇列中。

![1622082071(1).jpg](https://developer.hs.net/storage/attachments/2021/05/28/gprVkmjuROtoj3CjtGkTHaOGCVoHYQ9pVY622r82_thumb.jpg "1162")

生產者EmitLog  關鍵步驟見註釋說明

```java
public class EmitLog {

private static final String EXCHANGE_NAME = "logs";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            //建立一個exchange 並指定型別
            channel.exchangeDeclare(EXCHANGE_NAME, "fanout");

String message = argv.length < 1 ? "info: Hello World!" :
                    String.join(" ", argv);
			//此處和之前發訊息不一樣，指定具體的exchange沒有指定具體的queue
            channel.basicPublish(EXCHANGE_NAME, "", null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + message + "'");
        }
    }

}
```

[**EmitLog完整程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/EmitLog.java)

消費者ReceiveLogs  關鍵步驟見註釋說明

```java
public class ReceiveLogs {
    private static final String EXCHANGE_NAME = "logs";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();
		//建立fanout型別的exchange
        channel.exchangeDeclare(EXCHANGE_NAME, "fanout");
        //獲取一個獨有的，非持久化的，自動刪除的佇列
        String queueName = channel.queueDeclare().getQueue();
        //透過繫結方法將exchage和queue之間簡歷關係
        channel.queueBind(queueName, EXCHANGE_NAME, "");

System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + message + "'");
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}
```

[**ReceiveLogs完整程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/ReceiveLogs.java)

****Routing****

上一個例子中exchange將接收到的資訊廣播給了繫結的佇列中，本例中我們將增加繫結的一些特定，使exchange有能力透過routingKey（全匹配）來投遞不同的訊息到不同的佇列中。例如日常日誌區分error日誌進單獨的佇列。

![image-20210526095222998.png](https://developer.hs.net/storage/attachments/2021/05/28/Nq1PrLQflAUNtFla4WVLaPL8F78Js5imaBNgnTQd_thumb.png "1163")

生產者EmitLogDirect 關鍵步驟見註釋說明

```java
public class EmitLogDirect {

private static final String EXCHANGE_NAME = "direct_logs";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            //宣告一個direct型別的exchange
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

String severity = getSeverity(argv);
            String message = getMessage(argv);

channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + severity + "':'" + message + "'");
        }
    }

private static String getSeverity(String[] strings) {
        if (strings.length < 1)
            return "info";
        return strings[0];
    }

private static String getMessage(String[] strings) {
        if (strings.length < 2)
            return "Hello World!";
        return joinStrings(strings, " ", 1);
    }

private static String joinStrings(String[] strings, String delimiter, int startIndex) {
        int length = strings.length;
        if (length == 0) return "";
        if (length <= startIndex) return "";
        StringBuilder words = new StringBuilder(strings[startIndex]);
        for (int i = startIndex + 1; i < length; i++) {
            words.append(delimiter).append(strings[i]);
        }
        return words.toString();
    }
}
```

[**EmitLogDirect完整程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/EmitLogDirect.java)

消費者ReceiveLogsDirect 關鍵步驟見註釋說明

```java
public class ReceiveLogsDirect {

private static final String EXCHANGE_NAME = "direct_logs";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);
        String queueName = channel.queueDeclare().getQueue();

if (argv.length < 1) {
            System.err.println("Usage: ReceiveLogsDirect [info] [warning] [error]");
            System.exit(1);
        }

for (String severity : argv) {
            //建立exchange和queue之間關係並設定routingKey
            channel.queueBind(queueName, EXCHANGE_NAME, severity);
        }
        System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {
        });
    }
}
```

[**ReceiveLogsDirect完整程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/ReceiveLogsDirect.java)

****Topics****

提供更豐富的exchange到queue之間的路由規則。規則透過.分隔的routingKey，最高限制 255bytes。跟之前的全匹配routingKey不同，topic型別的exchange的routingKey主要增加了兩個特性。

* \*代表一個單詞**。**
* \**#** 代表0個或一個單詞。

![image-20210526101017541.png](https://developer.hs.net/storage/attachments/2021/05/28/XU10TzoxnVGUIIgw6d06x6IZmWBtxDy2ByJHJiHj_thumb.png "1164")

生產者EmitLogTopic 關鍵步驟見註釋說明

```java
public class EmitLogTopic {

private static final String EXCHANGE_NAME = "topic_logs";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {

channel.exchangeDeclare(EXCHANGE_NAME, "topic");

String routingKey = getRouting(argv);
            String message = getMessage(argv);

channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes("UTF-8"));
            System.out.println(" [x] Sent '" + routingKey + "':'" + message + "'");
        }
    }

private static String getRouting(String[] strings) {
        if (strings.length < 1)
            return "anonymous.info";
        return strings[0];
    }

private static String getMessage(String[] strings) {
        if (strings.length < 2)
            return "Hello World!";
        return joinStrings(strings, " ", 1);
    }

private static String joinStrings(String[] strings, String delimiter, int startIndex) {
        int length = strings.length;
        if (length == 0) return "";
        if (length < startIndex) return "";
        StringBuilder words = new StringBuilder(strings[startIndex]);
        for (int i = startIndex + 1; i < length; i++) {
            words.append(delimiter).append(strings[i]);
        }
        return words.toString();
    }
}
```

[**EmitLogTopic完整程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/EmitLogTopic.java)

消費者ReceiveLogsTopic 關鍵步驟見註釋說明

```java
public class ReceiveLogsTopic {

private static final String EXCHANGE_NAME = "topic_logs";

public static void main(String[] argv) throws Exception {
        ConnectionFactory factory = new ConnectionFactory();
        factory.setHost("localhost");
        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

channel.exchangeDeclare(EXCHANGE_NAME, "topic");
        String queueName = channel.queueDeclare().getQueue();

if (argv.length < 1) {
            System.err.println("Usage: ReceiveLogsTopic [binding_key]...");
            System.exit(1);
        }

for (String bindingKey : argv) {
            channel.queueBind(queueName, EXCHANGE_NAME, bindingKey);
        }

System.out.println(" [*] Waiting for messages. To exit press CTRL+C");

DeliverCallback deliverCallback = (consumerTag, delivery) -> {
            String message = new String(delivery.getBody(), "UTF-8");
            System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> { });
    }
}
```

[**ReceiveLogsTopic完整程式碼查閱**](https://github.com/rabbitmq/rabbitmq-tutorials/blob/master/java/ReceiveLogsTopic.java)

## **引入RabbitMQ帶來什麼挑戰**

看到這，各位看官是不是越越欲試想在專案中引入RabbitMQ去最佳化現在的使用場景，那麼是不是我們部署一個RabbitMQ服務，然後傳送訊息就高枕無憂了呢？其實在引入一箇中介軟體時，同時伴隨著一些問題，如果我們對這些問題了解不夠深入或者全面，那恭喜你將進入挖坑選手序列。為了成為一個靠譜的程式設計師，我們要充分了解引入中介軟體給我們 專案帶來的挑戰，才能在之後的應用上從容應對。下面列了下訊息中介軟體中常見的幾類問題

* 訊息丟失
* 訊息重複
* 訊息堆積
* RabbitMQ的可用性保證

之後的文章，我們將逐個去講解上述問題的解決方案。

參考文件

`https://www.rabbitmq.com/ RabbitMQ官方文件`

tips：作者個人經驗有限，不足之處煩請指正。

解析訊息中介軟體之RabbitMQ

相關文章