RabbitMQ速通入門

一.RabbitMQ快速入門

1.MQ全稱為Message Queue，訊息佇列是應用程式和應用程式之間的通信方法，RabbitMQ是實作了高級訊息佇列協議（AMQP）的開源訊息代理軟體（亦稱面向訊息的中間件），RabbitMQ服務器是用Erlang語言撰寫的，而群集和故障轉移是構建在開放電信平臺框架上的，

2.訊息佇列示意圖

大致流程就是消費者(consumer)訂閱某個佇列，生產者(product)創建訊息，然后發布到佇列中(queue)，最終將訊息發送到監聽的消費者，

上圖中(組成):

.Broker：標識訊息佇列服務器物體

.Virtual Host：虛擬主機，標識一批交換機、訊息佇列和相關物件

.Exchange：交換器，用來接收生產者發送的訊息并將這些訊息路由給服務器中的佇列，

.Queue：訊息佇列，用來保存訊息直到發送給消費者，它是訊息的容器，也是訊息的終點，一個訊息可投入一個或多個佇列，訊息一直在佇列里面，等待消費者連接到這個佇列將其取走，

.Banding：系結，用于訊息佇列和交換機之間的關聯，

.Channel：信道，多路復用連接中的一條獨立的雙向資料流通道，信道是建立在真實的TCP連接內的虛擬鏈接，AMQP命令都是通過信道發出去的，不管是發布訊息、訂閱佇列還是接收訊息，這些動作都是通過信道完成，因為對于作業系統來說，建立和銷毀TCP都是非常昂貴的開銷，所以引入了信道的概念，以復用一條TCP連接，

.Connection：網路連接，比如一個TCP連接，

.Publisher：訊息的生產者，也是一個向交換器發布訊息的客戶端應用程式，

.Consumer：訊息的消費者，表示一個從一個訊息佇列中取得訊息的客戶端應用程式，

二.RabbitMQ下載安裝

RabbitMQ分為windows版本的安裝和linux版本的安裝,舉例windows的下載和安裝，要先安裝erlang并且配置環境變數再安裝,環境搭建程序詳情見下文

RabbitMQ的下載與安裝以及Erlang環境的搭建 - 簡書：簡書

三.為什么要使用RabbitMQ

3.1.使用RabbitMQ的好處

在專案中，可將一些無需即時回傳且耗時的操作提取出來，進行異步處理，而這種異步處理的方式大大的節省了服務器的請求回應時間，從而提高了系統的吞吐量，

3.2.RabbitMQ使用場景

開發中訊息佇列通常有如下應用場景：

任務異步處理

將不需要同步處理的并且耗時長的操作由訊息佇列通知訊息接收方進行異步處理，提高了應用程式的回應時間，

應用程式解耦合

MQ相當于一個中介，生產方通過MQ與消費方互動，它將應用程式進行解耦合，

削峰填谷

如訂單系統，在下單的時候就會往資料庫寫資料，但是資料庫只能支撐每秒1000左右的并發寫入，并發量再高就容易宕機，低峰期的時候并發也就100多個，但是在高峰期時候，并發量會突然激增到5000以上，這個時候資料庫肯定卡死了，

訊息被MQ保存起來了，然后系統就可以按照自己的消費能力來消費，比如每秒1000個資料，這樣慢慢寫入資料庫，這樣就不會卡死資料庫了，

但是使用了MQ之后，限制消費訊息的速度為1000，但是這樣一來，高峰期產生的資料勢必會被積壓在MQ中，高峰就被“削”掉了，但是因為訊息積壓，在高峰期過后的一段時間內，消費訊息的速度還是會維持在1000QPS，直到消費完積壓的訊息,這就叫做“填谷”

3.3.RabbitMQ埠號

3.4.AMQP 和 JMS

3.4.1.AMQP

AMQP是一種協議，更準確來說是一種binary wire-level protocol（鏈接協議），這是其和JMS的本質區別，AMQP不從API層進行限定，而是直接定義網路交換的資料格式，

AMQP是一個二進制協議，擁有一些現代化特點：多信道、協商式，異步，安全，擴平臺，中立，高效，

3.4.2.JMS

JMS即Java訊息服務（JavaMessage Service）應用程式介面，是一個Java平臺中關于面向訊息中間件（MOM）的API，用于在兩個應用程式之間，或分布式系統中發送訊息，進行異步通信，

3.4.3.AMQP和JMS的區別

3.5.訊息佇列產品

市面上常見的訊息佇列有如下:

■ActiveMQ：基于JMS

■ZeroMQ：基于C語言開發

■RabbitMQ：基于AMQP協議，erlang語言開發，穩定性好

■RocketMQ：基于JMS，阿里巴巴產品

■Kafka：類似MQ的產品；分布式訊息系統，高吞吐量

各自的特點(看圖自行感受，總結，分析):

注： - 表示尚未查找到準確資料

3.6/RabbitMQ(是AMQP協議的Erlang的實作)

RabbitMQ是由erlang語言開發，基于AMQP（Advanced Message Queue 高級訊息佇列協議）協議實作的訊息佇列，它是一種應用程式之間的通信方法，訊息佇列在分布式系統開發中應用非常廣泛，

RabbitMQ官方地址：http://www.rabbitmq.com/

RabbitMQ提供了6種模式：簡單模式，work模式，Publish/Subscribe發布與訂閱模式，Routing路由模式，Topics主題模式，RPC遠程呼叫模式（遠程呼叫，不太算MQ；暫不作介紹）；

官網對應模式介紹：https://www.rabbitmq.com/getstarted.html

四.入門案例(小白玩家擼碼前記得先把服務打開)

4.1.簡單模式

4.1.1.運行環境創建工程

4.1.2.添加依賴

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

4.1.3.撰寫生產者

public class Producer {
    static final String QUEUE_NAME = "simple_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //創建連接工廠
        Connection connection = ConnectionUtil.getConnection();

        //創建信道
        Channel channel = connection.createChannel();

        // 宣告（創建）佇列      
        channel.queueDeclare(QUEUE_NAME,true,false,false,null);

        //要發送的資訊
        String message = "Hello World";
       
        channel.basicPublish("",QUEUE_NAME,null,message.getBytes());
        System.out.println("已發送訊息:"+message);

        //關閉資源
        channel.close();
        connection.close();
    }

}

注:在執行上述的訊息發送之后；可以登錄rabbitMQ的管理控制臺，可以發現佇列和其訊息,在這里不再演示

4.1.4.撰寫消費者

public class Consumer {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        //創建頻道
        Channel channel = connection.createChannel();

        // 宣告（創建）佇列
        channel.queueDeclare(Producer.QUEUE_NAME,true,false,false,null);

        //創建消費者:并設定訊息處理
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key為:"+envelope.getRoutingKey());
                //交換機
                System.out.println("交換機為:"+envelope.getExchange());
                //訊息id
                System.out.println("訊息id為:"+envelope.getDeliveryTag());
                //收到的訊息
                System.out.println("接收到的訊息為:"+new String(body));
            }
        };
        //監聽訊息
        channel.basicConsume(Producer.QUEUE_NAME,true,consumer);
        //不關閉資源，一直監聽
    }
}

4.1.5.小結

上述的入門案例中中其實使用的是如下的簡單模式：

在上圖的模型中，有以下概念：

• P：生產者，也就是要發送訊息的程式

• C：消費者：訊息的接受者，會一直等待訊息到來，

• queue：訊息佇列，圖中紅色部分，類似一個郵箱，可以快取訊息；生產者向其中投遞訊息，消費者從其中取出訊息，

4.2.RabbitQM運轉流程(以4.1簡單模式案例分析)

■ 生產者發送訊息

1. 生產者創建連接（Connection），開啟一個信道（Channel），連接到RabbitMQ Broker；

2. 宣告佇列并設定屬性；如是否排它，是否持久化，是否自動洗掉；

3. 將路由鍵（空字串）與佇列系結起來；

4. 發送訊息至RabbitMQ Broker；

5. 關閉信道；

6. 關閉連接；

■消費者接收資訊

1. 消費者創建連接（Connection），開啟一個信道（Channel），連接到RabbitMQ Broker

2. 向Broker 請求消費相應佇列中的訊息，設定相應的回呼函式；

3. 等待Broker回應閉關投遞回應佇列中的訊息，消費者接收訊息；

4. 確認（ack，自動確認）接收到的訊息；

5. RabbitMQ從佇列中洗掉相應已經被確認的訊息；

6. 關閉信道；

7. 關閉連接；

4.3.生產者流轉程序說明

1. 客戶端與代理服務器Broker建立連接，會呼叫newConnection() 方法,這個方法會進一步封裝Protocol Header 0-9-1 的報文頭發送給Broker ，以此通知Broker 本次互動采用的是AMQPO-9-1 協議，緊接著Broker 回傳Connection.Start 來建立連接，在連接的程序中涉及Connection.Start/.Start-OK 、Connection.Tune/.Tune-Ok ，Connection.Open/ .Open-Ok 這6 個命令的互動，

2. 客戶端呼叫connection.createChannel方法，此方法開啟信道，其包裝的channel.open命令發送給Broker,等待channel.basicPublish方法，對應的AMQP命令為Basic.Publish,這個命令包含了content Header 和content Body()，content Header 包含了訊息體的屬性，例如:投遞模式，優先級等，content Body 包含了訊息體本身，

3. 客戶端發送完訊息需要關閉資源時，涉及到Channel.Close和Channl.Close-Ok 與Connetion.Close和Connection.Close-Ok的命令互動，

4.4.消費者流轉程序說明

1. 消費者客戶端與代理服務器Broker建立連接，會呼叫newConnection() 方法,這個方法會進一步封裝Protocol Header 0-9-1 的報文頭發送給Broker ，以此通知Broker 本次互動采用的是AMQPO-9-1 協議，緊接著Broker 回傳Connection.Start 來建立連接，在連接的程序中涉及Connection.Start/.Start-OK 、Connection.Tune/.Tune-Ok ，Connection.Open/ .Open-Ok 這6 個命令的互動，

2. 消費者客戶端呼叫connection.createChannel方法，和生產者客戶端一樣，協議涉及Channel . Open/Open-Ok命令，

3. 在真正消費之前，消費者客戶端需要向Broker 發送Basic.Consume 命令(即呼叫channel.basicConsume 方法〉將Channel 置為接收模式，之后Broker 回執Basic . Consume - Ok 以告訴消費者客戶端準備好消費訊息，

4. Broker 向消費者客戶端推送(Push) 訊息，即Basic.Deliver 命令，這個命令和Basic.Publish 命令一樣會攜帶Content Header 和Content Body，

5. 消費者接收到訊息并正確消費之后，向Broker 發送確認，即Basic.Ack 命令，

6. 客戶端發送完訊息需要關閉資源時，涉及到Channel.Close和Channl.Close-Ok 與Connetion.Close和Connection.Close-Ok的命令互動，

五.RabbitMQ作業模式

5.1.簡單模式見入門案例

5.2.Work queues作業佇列模式

5.2.1.模式說明

Work Queues與入門程式的簡單模式相比，多了一個或一些消費端，多個消費端共同消費同一個佇列中的訊息，

應用場景：對于 任務過重或任務較多情況使用作業佇列可以提高任務處理的速度，

5.2.2.碼來

■生產者

public class Producer {

    static final String QUEUE_NAME = "work_queue";

    public static void main(String[] args) throws IOException, TimeoutException {
        //本人將獲取連接封裝成工具類，你們可以把入門案例的連接代碼復制過來
        Connection connection = ConnectionUtil.getConnection();
        Channel channel = connection.createChannel();
        // 宣告（創建）佇列
        channel.queueDeclare(QUEUE_NAME, true, false, false, null);
        for (int i = 1; i <= 30; i++) {
            // 發送資訊
            String message = "work模式--" + i;
            channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
            System.out.println("已發送訊息：" + message);
        }
        // 關閉資源
        channel.close();
        connection.close();

    }
}

■消費者(這里用兩個消費者演示，你們可以把消費者代碼復制成兩份)

public class Consumer1 {

    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();
        // 創建頻道
        final Channel channel = connection.createChannel();

        // 宣告（創建）佇列
        channel.queueDeclare(Producer.QUEUE_NAME, true, false, false, null);

        //一次只能接收并處理一個訊息
        channel.basicQos(1);
        //創建消費者:并設定訊息處理
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                try {
                    //路由key
                    System.out.println("路由key為：" + envelope.getRoutingKey());
                    //交換機
                    System.out.println("交換機為：" + envelope.getExchange());
                    //訊息id
                    System.out.println("訊息id為：" + envelope.getDeliveryTag());
                    //收到的訊息
                    System.out.println("消費者1-接收到的訊息為：" + new String(body, "utf-8"));
                    Thread.sleep(1000);//單純增強實驗效果
                    //確認資訊
                    channel.basicAck(envelope.getDeliveryTag(),false);
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        };

        //監聽訊息
        channel.basicConsume(Producer.QUEUE_NAME,false,defaultConsumer);

    }
}

5.2.3.測驗

■消費者1

■消費者2

小結:可以看出，在一個佇列中如果有多個消費者，那么消費者之間對于同一個訊息的關系是競爭的關系，

5.3.Publish/Subscribe 發布訂閱模式

5.3.1.模式介紹

■每個消費者監聽自己的佇列

■生產者將訊息發給broker，由交換機將訊息轉發到系結此交換機的佇列，每個系結交換機的佇列都將接收到訊息

相較于作業佇列模式，訂閱模式在原來的結構上稍加不同，多了交換機角色，而且程序也略有變化:

P:生產者，這里發送資訊到交換機(X)中，而不再直接發送到佇列

C1(C2):消費者，等待并接受訊息

Queue(紅色方塊):訊息佇列,接收、快取訊息

X(Exchange): 交換機，接收并處理訊息，不具備儲存訊息的功能，如果沒有佇列與其系結，或者沒有符合路由規則的佇列，訊息就會丟失(gg)...

常見的交換機有如下3種:

■Fanout:廣播型,將訊息發送給所有系結交換機的佇列

■Direct :定向型,把訊息發送給指定路由key的佇列

■Topic :通配符，個人理解就是在路由模式(下面會講到)的佇列

5.3.2.碼來

■生產者

/**
 * 發布與訂閱使用的交換機型別為：fanout
 */
public class Producer {

    //交換機名稱
    static final String FANOUT_EXCHAGE = "fanout_exchange";
    //佇列名稱
    static final String FANOUT_QUEUE_1 = "fanout_queue_1";
    //佇列名稱
    static final String FANOUT_QUEUE_2 = "fanout_queue_2";

    public static void main(String[] args) throws IOException, TimeoutException {
        //創建連接
        Connection connection = ConnectionUtil.getConnection();

        // 創建信道
        Channel channel = connection.createChannel();
        
        channel.exchangeDeclare(FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);
        //創建佇列
        channel.queueDeclare(FANOUT_QUEUE_1,true,false,false,null);
        channel.queueDeclare(FANOUT_QUEUE_2,true,false,false,null);

        //佇列系結交換機
        channel.queueBind(FANOUT_QUEUE_1,FANOUT_EXCHAGE,"");
        channel.queueBind(FANOUT_QUEUE_2,FANOUT_EXCHAGE,"");

        for (int i = 1; i <= 10; i++) {
            // 發送資訊
            String message = "岳某人 發布訂閱模式--" + i;
            channel.basicPublish(FANOUT_EXCHAGE,"",null,message.getBytes());
            System.out.println("已發送資訊:"+message);
        }
        // 關閉資源
        channel.close();
        connection.close();
    }
}

■消費者(累了，自行復制一份)

public class Consumer1 {

    public static void main(String[] args) throws Exception {
        Connection connection = ConnectionUtil.getConnection();

        // 創建頻道
        Channel channel = connection.createChannel();

        //宣告交換機
        channel.exchangeDeclare(Producer.FANOUT_EXCHAGE, BuiltinExchangeType.FANOUT);

        // 宣告（創建）佇列
        channel.queueDeclare(Producer.FANOUT_QUEUE_1, true, false, false, null);

        //佇列系結交換機
        channel.queueBind(Producer.FANOUT_QUEUE_1, Producer.FANOUT_EXCHAGE, "");

        //創建消費者；并設定訊息處理
        DefaultConsumer consumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope,         AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key為：" + envelope.getRoutingKey());
                //交換機
                System.out.println("交換機為：" + envelope.getExchange());
                //訊息id
                System.out.println("訊息id為：" + envelope.getDeliveryTag());
                //收到的訊息
                System.out.println("消費者1-接收到的訊息為：" + new String(body, "utf-8"));
            }
        };
        //監聽訊息
        channel.basicConsume(Producer.FANOUT_QUEUE_1, true, consumer);
    }
}

5.3.3.測驗

■消費者1

■消費者2

小結:與交換機系結的佇列，發布的訊息佇列都能收到

5.4.Routing路由模式

5.4.1.模式介紹

• 發送方向交換機發送訊息時，必須指定訊息的RoutingKey
• 交換機不再把訊息交給每一個系結的佇列，而是根據訊息的RoutingKey判斷篩選，只有佇列的RoutingKey與訊息的RoutingKey一致，才會接收到訊息

由上圖也可看出，基本機構與發布訂閱模式基本一致，只是多了種規則(個人理解)，

5.4.2.碼來

■生產者

/**
 * 路由模式的交換機型別為：direct
 */
public class Producer {
    //交換機名稱
    static final String DIRECT_EXCHAGE = "direct_exchange";
    //佇列名稱
    static final String DIRECT_QUEUE_INSERT = "direct_queue_insert";
    //佇列名稱
    static final String DIRECT_QUEUE_UPDATE = "direct_queue_update";

    public static void main(String[] args) throws IOException, TimeoutException {
        //創建連接
        Connection connection = ConnectionUtil.getConnection();

        // 創建頻道
        Channel channel = connection.createChannel();

        //宣告交換機
        channel.exchangeDeclare(DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);

        //宣告佇列
        channel.queueDeclare(DIRECT_QUEUE_INSERT, true, false, false, null);
        channel.queueDeclare(DIRECT_QUEUE_UPDATE, true, false, false, null);

        //與佇列系結交換機
        channel.queueBind(DIRECT_QUEUE_INSERT,DIRECT_EXCHAGE,"insert");
        channel.queueBind(DIRECT_QUEUE_UPDATE,DIRECT_EXCHAGE,"update");
        //發送資訊
        String message = "cxk 路由模式；routing key 為 insert";
        channel.basicPublish(DIRECT_EXCHAGE, "insert", null, message.getBytes());
        System.out.println("已發送資訊:" + message);

        //發送資訊
        message = "Chicken you are too beautiful 路由模式；routing key 為 update";
        channel.basicPublish(DIRECT_EXCHAGE,"update",null,message.getBytes());
        System.out.println("已發送資訊:" + message);
        // 關閉資源
        channel.close();
        connection.close();
    }
}

■消費者

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        // 創建頻道
        Channel channel = connection.createChannel();

        //宣告交換機
        channel.exchangeDeclare(Producer.DIRECT_EXCHAGE, BuiltinExchangeType.DIRECT);

        //宣告佇列
        channel.queueDeclare(Producer.DIRECT_QUEUE_INSERT, true, false, false, null);

        //佇列系結交換機
        channel.queueBind(Producer.DIRECT_QUEUE_INSERT,Producer.DIRECT_EXCHAGE,"insert");

        //創建消費者，并設定訊息處理
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key為：" + envelope.getRoutingKey());
                //交換機
                System.out.println("交換機為：" + envelope.getExchange());
                //訊息id
                System.out.println("訊息id為：" + envelope.getDeliveryTag());
                //收到的訊息
                System.out.println("消費者1-接收到的訊息為：" + new String(body, "utf-8"));
            }
        };

        //監聽訊息
        channel.basicConsume(Producer.DIRECT_QUEUE_INSERT,true,defaultConsumer);
    }
}

5.4.3.測驗

■消費者1

■消費者2

小結:Routing模式要求佇列在系結交換機時要指定routing key,訊息會轉發到符合routing key的佇列，

5.5. Topics通配符模式

5.5.1.模式介紹

個人理解：和Routing模式很類似，只不過Routing模式的路由鍵是固定的，Topic型別的交換機可以模糊匹配路由鍵(非固定)

開發中路由鍵一般都是多個單詞拼湊的，中間用.連接，例如:ys.add

通配符規則:

'#':匹配一個或多個詞

'*':只能匹配一個詞

5.5.2.碼來

■生產者

public class Producer {
    //交換機名稱
    static final String TOPIC_EXCHAGE = "topic_exchange";
    //佇列名稱
    static final String TOPIC_QUEUE_1 = "topic_queue_1";
    //佇列名稱
    static final String TOPIC_QUEUE_2 = "topic_queue_2";

    public static void main(String[] args) throws IOException, TimeoutException {
        //創建連接
        Connection connection = ConnectionUtil.getConnection();

        // 創建頻道
        Channel channel = connection.createChannel();
        //宣告交換機
        channel.exchangeDeclare(TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);

        //發送訊息
        String message = "新增了商品，Topic模式；routing key 為 item.insert " ;
        channel.basicPublish(TOPIC_EXCHAGE,"item.insert",null,message.getBytes());
        // 發送資訊
        message = "修改了商品，Topic模式；routing key 為 item.update" ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.update", null, message.getBytes());
        System.out.println("已發送訊息：" + message);

        // 發送資訊
        message = "洗掉了商品，Topic模式；routing key 為 item.delete" ;
        channel.basicPublish(TOPIC_EXCHAGE, "item.delete", null, message.getBytes());
        System.out.println("已發送訊息：" + message);

        // 關閉資源
        channel.close();
        connection.close();
    }
}

■消費者

public class Consumer1 {
    public static void main(String[] args) throws IOException, TimeoutException {
        Connection connection = ConnectionUtil.getConnection();

        // 創建頻道
        Channel channel = connection.createChannel();
        //宣告交換機
        channel.exchangeDeclare(Producer.TOPIC_EXCHAGE, BuiltinExchangeType.TOPIC);

        //宣告佇列
        channel.queueDeclare(Producer.TOPIC_QUEUE_1,true,false,false,null);

        //佇列系結交換機
        channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHAGE,"item.update");
        channel.queueBind(Producer.TOPIC_QUEUE_1,Producer.TOPIC_EXCHAGE,"item.delete");

        //創建消費者
        DefaultConsumer defaultConsumer = new DefaultConsumer(channel){
            @Override
            public void handleDelivery(String consumerTag, Envelope envelope, AMQP.BasicProperties properties, byte[] body) throws IOException {
                //路由key
                System.out.println("路由key為：" + envelope.getRoutingKey());
                //交換機
                System.out.println("交換機為：" + envelope.getExchange());
                //訊息id
                System.out.println("訊息id為：" + envelope.getDeliveryTag());
                //收到的訊息
                System.out.println("消費者1-接收到的訊息為：" + new String(body, "utf-8"));
            }
        };
        //監聽訊息
        channel.basicConsume(Producer.TOPIC_QUEUE_1,true,defaultConsumer);
    }
}

5.5.3. 測驗

小結:topic 通配符模式又叫主題模式，可以實作發布訂閱模式和路由模式的功能，只是topic在配置routingkey時更加靈活

六.模式總結

RabbitMQ作業模式：

1、簡單模式 HelloWorld 一個生產者、一個消費者，不需要設定交換機（使用默認的交換機）

2、作業佇列模式 Work Queue 一個生產者、多個消費者（競爭關系），不需要設定交換機（使用默認的交換機）

3、發布訂閱模式 Publish/subscribe 需要設定型別為fanout的交換機，并且交換機和佇列進行系結，當發送訊息到交換機后，交換機會將訊息發送到系結的佇列

4、路由模式 Routing 需要設定型別為direct的交換機，交換機和佇列進行系結，并且指定routing key，當發送訊息到交換機后，交換機會根據routing key將訊息發送到對應的佇列

5、通配符模式 Topic 需要設定型別為topic的交換機，交換機和佇列進行系結，并且指定通配符方式的routing key，當發送訊息到交換機后，交換機會根據routing key將訊息發送到對應的佇列

6.RPC模式 RPC即客戶端遠程呼叫服務端的方法 ，使用MQ可以實作RPC的異步呼叫，基于Direct交換機實作

希望對你們有所幫助