SpringBoot中使用 RabbitMQ -測試

本章主要建立在已經安裝好Erlang以及RabbitMQ的基礎上，接下來，簡單介紹一下使用

1、首先到RabbitMQ的管理界面新建一個隊列（Direct模式）

2、測試項目的基礎結構如下：

這里為了方便測試，直接在父項目中建立兩個子模塊（生產者和消費者）

3、pom.xml文件的依賴如下：

父項目：

<parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.0.1.RELEASE</version>
</parent>

引入SpringBoot的父依賴

子項目：

　　兩個模塊都是同樣的依賴

    <dependencies>
        <!--1、amqp高級消息隊列的依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-amqp</artifactId>
        </dependency>
        <!--2、測試的依賴-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-test</artifactId>
        </dependency>
    </dependencies>

2、准備發送的數據

回到IDEA中，打開子模塊的生產者模塊，我這邊是rab_producer，在resource下建立springboot的配置文件：application.yml文件，內容如下：

spring:
  rabbitmq:
    host: localhost
# host 為RabbitMQ主機的地址

之后新建一個SpringBoot的啟動類：

@SpringBootApplication
public class RabbitMQApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitMQApplication.class);
    }
}

然后新建測試類：

@RunWith(SpringRunner.class)    // 固定寫法
@SpringBootTest(classes = RabbitMQApplication.class)    // SpringBoot啟動類（自定義的）
public class RabTest {
    @Autowired
    private RabbitTemplate rabbitTemplate;  // 注入一個RabbitMQ的模板對象，操作消息隊列的對象

    // 發送一條點對點（Direct）的消息，又稱為直連
    @Test
    public void sendQueue(){
        System.out.println("開始向隊列中發送一條消息！");
        // 參數1：管理中的隊列名  參數2：發送的消息
        rabbitTemplate.convertAndSend("weiku","message:這是一條消息！");
        System.out.println("消息發送完畢！");
    }
}

運行測試方法即可把消息發送到隊列（weiku）中。

如果消息未被消費，可在管理界面查看到：

 

 

3、准備消費者接收消息

回到IDEA中，打開子模塊的消費者模塊，我這邊是rab_consumer，在子模塊中創建一個啟動類，內容如下：

 

 

@SpringBootApplication
public class RabbitMQApplication {
    public static void main(String[] args) {
        SpringApplication.run(RabbitMQApplication.class);
    }
}

完成之后，定義一個接收消息的監聽器，並且注入到Spring容器中，代碼如下：

@Component  // 需要注入到Spring容器中
@RabbitListener(queues = "weiku")   // 指定監聽的隊列名
public class Consumer1 {
    @RabbitHandler  // 消息接收處理
    public void showMSG(String message){    // 得到我們producer中發送的Object數據，此處可根據傳過來的類型來選擇接收，否則拋出異常
        System.out.println("weiku收到的消息內容為：" + message);
    }
}

准備完成之后，運行啟動類可接收到我們剛剛發送的Direct點對點的消息，這種模式的消息只能被一個消費者所消費到，運行結果如下：

 

 

4、測試使用 發布/訂閱 來發送消息

首先需要到RabbitMQ的管理界面新增一個路由交換機（Exchange）

 

 

 新建完路由之后，需要再新建幾個隊列，如圖：

 

 

之后，還沒完，需要把我們新建路由和我們新建的隊列綁定：

出現如圖界面： 

 

 

綁定完成之后，開始代碼測試。

5、進行 發布/訂閱 的代碼測試

生產者：

    // 廣播的形式發送，同一個路由下的所有隊列都能接收到消息
    @Test
    public void sendFanout(){
        System.out.println("開始向路由發送消息（路由下的所有Queue都能收到該消息）");
        // 參數1：路由名  參數2：可有可無    參數3：發送的消息內容
        rabbitTemplate.convertAndSend("weiku-work","","這是一條所有消費者都能收到的消息！");
        System.out.println("消息發送成功！");
    }

消費者：

消費者1：

@Component  // 需要注入到Spring容器中
@RabbitListener(queues = "weiku")   // 指定監聽的隊列名
public class Consumer1 {
    @RabbitHandler  // 消息接收處理
    public void showMSG(String message){    // 得到我們producer中發送的Object數據，此處可根據傳過來的類型來選擇接收，否則拋出異常
        System.out.println("weiku收到的消息內容為：" + message);
    }
}

消費者2：

@Component  // 需要注入到Spring容器中
@RabbitListener(queues = "weiku1")  // 指定監聽的隊列名
public class Consumer2 {
    @RabbitHandler  // 消息接收處理
    public void getMSG(String msg){
        System.out.println("weiku1收到的消息如下：" + msg);
    }
}

消費者3：

@Component  // 需要注入到Spring容器中
@RabbitListener(queues = "weiku2")  // 指定監聽的隊列名
public class Consumer3 {
    @RabbitHandler  // 消息接收處理
    public void getMSG(String msg){
        System.out.println("weiku2收到的消息如下：" + msg);
    }
}

先運行生產者的測試發送消息的方法，再運行消費者的SpringBoot啟動類。

運行結果如下：

6、最后，進行發送主題（Topic）的測試

新建一個用來發送主題的路由

 

路由新建完之后，新建3個隊列，用來接收發布的 topic，如圖：

之后還需把我們新建的隊列和路由進行綁定，如圖所示：

這里的 # 代表所有類型匹配。

以上的准備完成之后，開始代碼測試：

測試1：

生產者：

    @Test
    public void sendTopic1(){
        System.out.println("開始向路由中發送消息！參數2：routingKey");
        // 參數1：路由器名  參數2：類似於發送的規則名
        rabbitTemplate.convertAndSend("weiku-topic","good.log","這是一條good.log消息");
    }

此處三個隊列都能接收到數據，因為都匹配。

消費者：

消費者1：

@Component
@RabbitListener(queues = "wk0")
public class Con1 {
    @RabbitHandler
    public void getMSG(String msg){
        System.out.println("wk0收到的消息為：" + msg);
    }
}

消費者2：

@Component
@RabbitListener(queues = "wk1")
public class Con2 {
    @RabbitHandler
    public void getMSG(String msg){
        System.out.println("wk1收到的消息如下：" + msg);
    }
}

消費者3：

@Component
@RabbitListener(queues = "wk2")
public class Con3 {
    @RabbitHandler
    public void getMSG(String msg){
        System.out.println("wk2收到的消息如下：" + msg);
    }

    /**
     * 可以進行重載，會找到指定參數的queue上
     * @param map
     */
    @RabbitHandler
    public void getMSG(Map map){
        System.out.println("wk2收到的（map）消息如下：" + map);
    }
    @RabbitHandler
    public void getMSG(List list){
        System.out.println("wk2收到的（list）消息如下：" + list);
    }
}

啟動SpringBoot，運行結果如下：

因為這邊3個隊列都符合了規則，所以都能消費到消息

測試2：

生產者：

    @Test
    public void sendTopic2(){
        System.out.println("開始向路由中發送消息！參數2：routingKey");
        rabbitTemplate.convertAndSend("weiku-topic","維護.log","這是一條 維護.log消息");
        rabbitTemplate.convertAndSend("weiku-topic","日志.log","這是一條 日志.log消息");
    }

消費者運行結果：

 

 

此處這又 wk1 能接收到消息，因為 wk1 符合以 . log 結尾

測試3：

生產者：

    @Test
    public void sendTopic3(){
        // 1.准備發送的數據
        Map map = new HashMap();
        map.put(1,"a");
        map.put(2,"b");
        List list = new ArrayList();
        list.add("qq");
        list.add("ww");
        list.add("SS");
        System.out.println("開始向路由中發送消息！參數2為routingKey");
        // 2.開始發送消息（發送了2條）
        // 2.1 發送的數據為map類型
        rabbitTemplate.convertAndSend("weiku-topic","good.txt",map);
        // 2.2 發送的數據為list類型
        rabbitTemplate.convertAndSend("weiku-topic","good.txt",list);
    }

消費者運行效果如下：

    

 

此處只有 wk2 能夠收到消息，且被指定類型的監聽器所消費。

至此，我們的測試就結束了。