關於RabbitMQ的簡單理解

　　說明：想要理解RabbitMQ，需要先理解MQ是什麼？能做什麼？然後根據基礎知識去理解RabbitMQ是什麼、提供了什麼功能。

一、MQ的簡單理解

1. 什麼是MQ?

• 訊息佇列（Message Queue），是基礎資料結構中 “先進先出” 的一種資料結構。
• 一般用來解決應用解耦、非同步訊息、流量削峰等問題，實現高效能、高可用、可伸縮和最終一致性架構。

2.MQ是怎麼實現訊息傳遞的？

1. 生產者產生訊息並把傳輸的資料（訊息）放在佇列中，用佇列機制來實現訊息傳遞。
2. 消費者可以到指定的佇列拉取訊息，或者訂閱相應的佇列，由MQ服務端給其推送訊息。

3.MQ的幾個主要特性

• 解耦：一個業務需要多個模組共同實現，或一條訊息有多個系統對應處理，只需要在主業務完成以後，傳送一條MQ，其餘模組消費MQ訊息，即可實現業務，降低模組之間的耦合。
• 非同步：主業務執行結束後，從屬業務通過MQ非同步處理，減少業務的響應時間，提高使用者體驗。
• 削峰：高併發情況下，業務非同步處理，提供高峰期業務處理能力，避免系統癱瘓。

4.MQ的缺點

• 系統可用性降低。依賴服務越多，服務越容易掛掉。需要考慮MQ癱瘓的情況。
• 系統的複雜性提高。需要考慮訊息丟失、訊息重複消費、訊息傳遞的順序性。
• 業務一致性。主業務和從屬業務一致性的處理。

二、RabbitMQ的簡單介紹

1. 什麼是RabbitMQ?

　　RabbitMQ是訊息代理，它接受並轉發訊息。

• RabbitMQ可以理解為一個郵箱，或者一個郵局，或者是一個郵遞員，保證 “張三” 的信件最終傳遞給 “李四”。
• RabbitMQ與上述所描述的郵局（郵箱、郵遞員）的主要區別在於它不處理紙張，而是接受、儲存和轉發二進位制資料塊訊息。

2.RabbitMQ和訊息傳遞的三個術語

• 生產：生產只意味著傳送。傳送訊息的程式是生產者（production）。
• 佇列：佇列是位於RabbitMQ中的“郵箱”的名稱。儘管訊息流經RabbitMQ和應用程式，但他們只能存在於佇列中。佇列只受主機的記憶體和磁碟限制，它的本質上是一個打的訊息緩衝區。許多生產者可以向一個佇列傳送訊息，許多消費者可以嘗試從一個佇列接收資料。
• 消費（接收）：消費與接收具有相似的含義。一個消費者（consumer）是一個程式，主要是等待接收資訊。

注意：生產者、消費者、代理不必部署在同一主機上，應用程式既可以是生產者，又可以是消費者。

         

三、RabbitMQ安裝

3.1環境說明（本文以RabbitMQ3.8.11為例）

RabbitMQ對Erlang版本要求（Rabbit是基於Erlang編寫的）

     

 RabbitMQ對JDK版本要求

  

 

3.2 安裝Erlang步驟（本文以windows版安裝為例）

3.2.1 下載Erlang，或訪問如下連結進行下載：

　　http://erlang.org/download/otp_win64_23.2.exe

3.2.2 雙擊執行 otp_win64_23.2.exe ，點選下一步完成安裝。

3.2.3 安裝完成後配置環境變數，如下圖所示

 

 

 

 

 

 3.2.4 執行視窗輸入cmd，在dos視窗輸入 erl ，返回如圖中所示，則代表erlang安裝完成。

3.2 安裝RibbitMQ步驟（本文以windows版安裝為例）

3.2.1 點選下載RibbitMQ，或訪問如下連結進行下載：

　　https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.8.11/rabbitmq-server-3.8.11.exe

3.2.2 雙擊執行 rabbitmq-server-3.8.11.exe，點選下一步完成安裝。

3.2.3 雙擊RabbitMQ Service - start 執行RabbitMQ

　　

 

 

 出現如下提示，則代表服務啟動成功：

　　

3.2.4 訪問RabbitMQ控制檯

　　控制檯地址：　　　　http://localhost:15672/   

　　控制檯使用者名稱/密碼 :    guest/guest

四、RabbitMQ傳遞訊息的方式（Java客戶端）

• Work queues（工作佇列）
• Publish/Subscribe（釋出/訂閱）
• Routing（路由）
• Topics（主題）
• RPC（遠端過程呼叫）
• Publisher Confirms（釋出者確認）

環境要求：

• JDK版本為15（1.8+即可）
• amqp-client 5.10.0

新增依賴：

<!--ribbitMq-->
<dependency>
    <groupId>com.rabbitmq</groupId>
    <artifactId>amqp-client</artifactId>
    <version>5.10.0</version>
</dependency>

4.1 Work queues（工作佇列）

官方描述：

　　工作佇列（又名：任務佇列）背後的主要思想是避免立即執行資源密集型任務，並且必須等待它完成。相反，我們把任務安排在以後完成。我們將任務封裝為訊息並將其傳送到佇列。後臺執行的工作程式將彈出任務並最終執行作業。當您執行多個worker時，任務將在它們之間共享。

程式碼示例：

生產者：

public class NewTask {

    private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] args) throws Exception{

        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()){
            channel.queueDeclare(TASK_QUEUE_NAME, true, false, false, null);

            String message = String.join(" ", "four");

            channel.basicPublish("", TASK_QUEUE_NAME,
                    MessageProperties.PERSISTENT_TEXT_PLAIN,
                    message.getBytes(StandardCharsets.UTF_8));

            System.out.println(" [x] Sent '" + message + "'");
        }
    }
}

消費者：

public class Worker {

    private static final String TASK_QUEUE_NAME = "task_queue";

    public static void main(String[] args )throws Exception {

        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        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 = (comsumerTag, delivery) ->{
            String message = new String(delivery.getBody(), StandardCharsets.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, comsumerTag -> {});
    }

    private static void doWork(String task){
        for (char ch : task.toCharArray()){
            if(ch == '.'){
                try {
                    Thread.sleep(1000);
                } catch (InterruptedException e) {
                    Thread.currentThread().interrupt();
                }
            }
        }
    }
}

4.3 Publish/Subscribe（釋出/訂閱）

官方描述：

　　RabbitMQ訊息傳遞模型中的核心思想是生產者從不將任何訊息直接傳送到佇列。實際上，生產者經常甚至根本不知道是否將訊息傳遞到任何佇列。相反，生產者只能將訊息傳送到交換機。交流是一件非常簡單的事情。一方面，它接收來自生產者的訊息，另一方面，將它們推入佇列。交易所必須確切知道如何處理收到的訊息。是否應將其附加到特定佇列？是否應該將其附加到許多佇列中？還是應該丟棄它。規則由交換型別定義 。

簡而言之：

　　相當於我們關注了一個微信公眾號，公眾號每次推文我們都能及時的收到。我們就相當於消費者，公眾號相當於訊息中轉站，文章作者相當於生產者。

程式碼示例：

生產者：

public class EmitLog {

    private static final String ExCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception{

        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()){
            channel.exchangeDeclare(ExCHANGE_NAME, "fanout");

            String message = args.length < 1 ? "info: Hello World!" : String.join(" ", args);

            channel.basicPublish(ExCHANGE_NAME, "", null, message.getBytes(StandardCharsets.UTF_8));

            System.out.println(" [x] Sent '" + message + "'");

        }

    }

}

消費者：

public class ReceiveLogs {

    private static final String ExCHANGE_NAME = "logs";

    public static void main(String[] args) throws Exception{
        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(ExCHANGE_NAME, "fanout");
        String queueName = channel.queueDeclare().getQueue();
        channel.queueBind(queueName, ExCHANGE_NAME, "");

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

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

4.4 Routing（路由）

官方描述：

　　接上例，我們可能希望將日誌訊息寫入磁碟的程式僅接收嚴重錯誤，而不會在警告或資訊日誌訊息上浪費磁碟空間。

簡而言之：

　　如果我們只想接收某些資訊，比如日誌級別有INFO、ERROR、DEBUG等，我們只願接收INFO日誌。可以使用Routing進行過濾。

程式碼示例：

生產者：

public class EmitLogDirect {

    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception{

        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()){
            channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

            String severity = getServerity(args);
            String message = getMessage(args);

            channel.basicPublish(EXCHANGE_NAME, severity, null, message.getBytes(StandardCharsets.UTF_8));
            System.out.println(" [x] Sent '" + severity + "':'" + message + "'");

        }

    }

    private static String getServerity(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();

    }
}

消費者：

public class ReceiveLogsDirect {

    private static final String EXCHANGE_NAME = "direct_logs";

    public static void main(String[] args) throws Exception{

        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        Connection connection = factory.newConnection();

        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, BuiltinExchangeType.DIRECT);

        String queueName = channel.queueDeclare().getQueue();

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

        for (String severity : args){
            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(), StandardCharsets.UTF_8);
            System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };

        channel.basicConsume(queueName, true, deliverCallback, comsumerTag ->{});
    }
}

4.5 Topics（主題）

官方描述：

　　傳送到主題交換機的訊息不能具有任意的 routing_key-它必須是單詞列表，以點分隔。這些詞可以是任何東西，但通常它們指定與訊息相關的某些功能。一些有效的路由關鍵示例：“ stock.usd.nyse ”，“ nyse.vmw ”，“ quick.orange.rabbit ”。路由關鍵字中可以包含任意多個單詞，最多255個位元組。

　　繫結金鑰也必須採用相同的形式。主題交換背後的邏輯 類似於直接交換-用特定路由鍵傳送的訊息將傳遞到所有用匹配繫結鍵繫結的佇列。但是，繫結鍵有兩個重要的特殊情況：

• • *（星）只能代替一個單詞。
  • #（雜湊）可以代替零個或多個單詞。

簡而言之：

 　　Topic會根據訊息自身所攜帶的路由鍵(Routing Key)在所有的繫結關係中尋找，與訊息相匹配的佇列推送該訊息。

注意：

　　當在繫結中不使用特殊字元“ * ”（星號）和“ ＃ ”（雜湊）時，主題交換的行為就像直接的一樣。

程式碼示例：

生產者：

public class EmitLogTopic {

    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception{

        ConnectionFactory factory = new ConnectionFactory();
        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        try(Connection connection = factory.newConnection();
            Channel channel = connection.createChannel()){

            channel.exchangeDeclare(EXCHANGE_NAME, "topic");

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

            channel.basicPublish(EXCHANGE_NAME, routingKey, null, message.getBytes(StandardCharsets.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();
    }
}

消費者：

public class ReceiveLogTopic {

    private static final String EXCHANGE_NAME = "topic_logs";

    public static void main(String[] args) throws Exception{

        ConnectionFactory factory = new ConnectionFactory();
        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        Connection connection = factory.newConnection();
        Channel channel = connection.createChannel();

        channel.exchangeDeclare(EXCHANGE_NAME, "topic");

        String queueName = channel.queueDeclare().getQueue();

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

        for (String bindingKey : args){
            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(), StandardCharsets.UTF_8);
            System.out.println(" [x] Received '" + delivery.getEnvelope().getRoutingKey() + "':'" + message + "'");
        };
        channel.basicConsume(queueName, true, deliverCallback, consumerTag -> {});
    }
}

4.6 RPC（遠端過程呼叫）

官方描述：

　　儘管RPC是計算中非常普遍的模式，但它經常受到批評。當程式設計師不知道函式呼叫是本地的還是緩慢的RPC時，就會出現問題。這樣的混亂會導致系統變幻莫測，並給除錯增加了不必要的複雜性。濫用RPC可能會導致無法維護的義大利麵條程式碼，而不是簡化軟體。

程式碼示例：

生產者

public class RPCServer {

    private static final String RPC_QUEUE_NAME = "rpc_queue";

    private static int fib(int n){
        if(n == 0){
            return 0;
        }
        if(n == 1){
            return 1;
        }
        return fib(n - 1) + fib(n - 2);
    }

    public static void main(String[] args) throws Exception{

        // 建立伺服器的連線
        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        try (Connection connection = factory.newConnection();
             Channel channel = connection.createChannel()) {
            channel.queueDeclare(RPC_QUEUE_NAME, false, false, false, null);
            channel.queuePurge(RPC_QUEUE_NAME);

            channel.basicQos(1);

            System.out.println(" [x] Awaiting RPC requests");

            Object monitor = new Object();
            DeliverCallback deliverCallback = (consumerTag, delivery) ->{
                AMQP.BasicProperties replyProps = new AMQP.BasicProperties
                        .Builder()
                        .correlationId(delivery.getProperties().getCorrelationId())
                        .build();

                String response = "";

                try{
                    String message = new String(delivery.getBody(), StandardCharsets.UTF_8);
                    int n = Integer.parseInt(message);

                    System.out.println(" [.] fib(" + message + ")");
                    response += fib(n);
                }catch (RuntimeException e){
                    System.out.println(" [.] " + e.toString());
                }finally {
                    channel.basicPublish("", delivery.getProperties().getReplyTo(), replyProps, response.getBytes(StandardCharsets.UTF_8));
                    channel.basicAck(delivery.getEnvelope().getDeliveryTag(), false);

                    // RabbitMq consumer worker thread notifies the RPC server owner thread
                    // RabbitMq使用者工作執行緒通知RPC伺服器所有者執行緒
                    synchronized (monitor){
                        monitor.notify();
                    }
                }
            };
            channel.basicConsume(RPC_QUEUE_NAME, false, deliverCallback, (consumerTag -> {}));
            // Wait and be prepared to consume the message from RPC client.
            // 等待並準備使用來自RPC客戶端的訊息。
            while(true){
                synchronized (monitor){
                    try {
                        monitor.wait();
                    }catch (InterruptedException e){
                        e.printStackTrace();
                    }
                }
            }
        }
    }
}

消費者：

public class RPCClient {

    private Connection connection;
    private Channel channel;
    private String requestQueueName = "rpc_queue";

    public RPCClient() throws IOException, TimeoutException {
        // 建立伺服器的連線
        ConnectionFactory factory = new ConnectionFactory();

        // 設定IP
        factory.setHost("127.0.0.1");

        // 設定埠號
        factory.setPort(5672);

        connection = factory.newConnection();
        channel = connection.createChannel();
    }

    public static void main(String[] args) throws Exception{
        RPCClient fibonacciRpc = new RPCClient();
            for (int i = 0; i < 32; i++) {
                String i_str = Integer.toString(i);
                System.out.println(" [x] Requesting fib(" + i_str + ")");
                String response = fibonacciRpc.call(i_str);
                System.out.println(" [.] Got '" + response + "'");
            }

    }

    public String call(String message) throws IOException, InterruptedException {
        final String corrId = UUID.randomUUID().toString();

        String replyQueueName = channel.queueDeclare().getQueue();
        AMQP.BasicProperties props = new AMQP.BasicProperties
                .Builder()
                .correlationId(corrId)
                .replyTo(replyQueueName)
                .build();

        channel.basicPublish("", requestQueueName, props, message.getBytes("UTF-8"));

        final BlockingQueue<String> response = new ArrayBlockingQueue<>(1);

        String ctag = channel.basicConsume(replyQueueName, true, (consumerTag, delivery) -> {
            if (delivery.getProperties().getCorrelationId().equals(corrId)) {
                response.offer(new String(delivery.getBody(), "UTF-8"));
            }
        }, consumerTag -> {
        });

        String result = response.take();
        channel.basicCancel(ctag);
        return result;
    }

    public void close() throws IOException {
        connection.close();
    }
}

4.7 Publisher Confirms（釋出者確認）

官方描述：

　　在某些應用程式中，確保將釋出的訊息傳送到代理非常重要。釋出者確認是RabbitMQ功能，可以幫助滿足此要求。釋出者確認本質上是非同步的，但也可以同步處理它們。沒有確定的方法可以實現釋出者確認，這通常歸結為應用程式和整個系統中的約束。典型的技術有：

• 單獨釋出訊息，同步等待確認：簡單，但吞吐量非常有限。
• 批量釋出訊息，同步等待批量確認：簡單，合理的吞吐量，但是很難推斷出什麼時候出了問題。
• 非同步處理：最佳效能和資源使用，在出現錯誤的情況下可以很好地控制，但是可以正確實施。

 程式碼示例：

public class PublisherConfirms {

    static final int MESSAGE_COUNT = 50_000;

    static Connection createConnection() throws Exception{

        ConnectionFactory cf = new ConnectionFactory();

        // 設定IP
        cf.setHost("127.0.0.1");

        // 設定埠號
        cf.setPort(5672);

        // 設定使用者名稱
        cf.setUsername("guest");

        // 設定密碼
        cf.setPassword("guest");

        return cf.newConnection();
    }

    public static void main(String[] args) throws Exception{
        publishMessagesIndividually();
        publishMessagesInBatch();
        handlePublishConfirmsAsynchronously();
    }

    static void publishMessagesIndividually() throws Exception{
        try(Connection connection = createConnection()){
            Channel ch = connection.createChannel();

            String queue = UUID.randomUUID().toString();
            ch.queueDeclare(queue, false, false, true, null);

            ch.confirmSelect();

            long start = System.nanoTime();
            for (int i = 0; i < MESSAGE_COUNT; i++){
                String body = String.valueOf(i);
                ch.basicPublish("", queue, null, body.getBytes(StandardCharsets.UTF_8));
                ch.waitForConfirmsOrDie(5_000);
            }
            long end = System.nanoTime();
            System.out.format("Published %,d messages individually in %,d ms%n", MESSAGE_COUNT, Duration.ofNanos(end - start).toMillis());
        }
    }

    static void publishMessagesInBatch() throws Exception {
        try (Connection connection = createConnection()) {
            Channel ch = connection.createChannel();

            String queue = UUID.randomUUID().toString();
            ch.queueDeclare(queue, false, false, true, null);

            ch.confirmSelect();

            int batchSize = 100;
            int outstandingMessageCount = 0;
            long start = System.nanoTime();
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String body = String.valueOf(i);
                ch.basicPublish("", queue, null, body.getBytes());
                outstandingMessageCount++;

                if (outstandingMessageCount == batchSize) {
                    ch.waitForConfirmsOrDie(5_000);
                    outstandingMessageCount = 0;
                }
            }

            if (outstandingMessageCount > 0) {
                ch.waitForConfirmsOrDie(5_000);
            }
            long end = System.nanoTime();
            System.out.format("Published %,d messages in batch in %,d ms%n", MESSAGE_COUNT, Duration.ofNanos(end - start).toMillis());

        }

    }

    static void handlePublishConfirmsAsynchronously() throws Exception {
        try (Connection connection = createConnection()) {
            Channel ch = connection.createChannel();

            String queue = UUID.randomUUID().toString();
            ch.queueDeclare(queue, false, false, true, null);

            ch.confirmSelect();

            ConcurrentNavigableMap<Long, String> outstandingConfirms = new ConcurrentSkipListMap<>();

            ConfirmCallback cleanOutstandingConfirms = (sequenceNumber, multiple) -> {
                if (multiple) {
                    ConcurrentNavigableMap<Long, String> confirmed = outstandingConfirms.headMap(
                            sequenceNumber, true
                    );
                    confirmed.clear();
                } else {
                    outstandingConfirms.remove(sequenceNumber);
                }
            };

            ch.addConfirmListener(cleanOutstandingConfirms, (sequenceNumber, multiple) -> {
                String body = outstandingConfirms.get(sequenceNumber);
                System.err.format(
                        "Message with body %s has been nack-ed. Sequence number: %d, multiple: %b%n",
                        body, sequenceNumber, multiple
                );
                cleanOutstandingConfirms.handle(sequenceNumber, multiple);
            });

            long start = System.nanoTime();
            for (int i = 0; i < MESSAGE_COUNT; i++) {
                String body = String.valueOf(i);
                outstandingConfirms.put(ch.getNextPublishSeqNo(), body);
                ch.basicPublish("", queue, null, body.getBytes());
            }

            if (!waitUntil(Duration.ofSeconds(60), () -> outstandingConfirms.isEmpty())) {
                throw new IllegalStateException("All messages could not be confirmed in 60 seconds");
            }

            long end = System.nanoTime();
            System.out.format("Published %,d messages and handled confirms asynchronously in %,d ms%n", MESSAGE_COUNT, Duration.ofNanos(end - start).toMillis());
        }
    }

    static boolean waitUntil(Duration timeout, BooleanSupplier condition) throws InterruptedException {
        int waited = 0;
        while (!condition.getAsBoolean() && waited < timeout.toMillis()) {
            Thread.sleep(100L);
            waited = +100;
        }
        return condition.getAsBoolean();
    }
}

五、總結

　　總的來說，RabbitMQ還是比較簡單的。目前文章只是簡單記錄一下，後期會更深入學習。