### 歡迎訪問我的GitHub
> 這裡分類和彙總了欣宸的全部原創(含配套原始碼)：[https://github.com/zq2599/blog_demos](https://github.com/zq2599/blog_demos)

- 本章是《Docker下RabbitMQ延時佇列實戰兩部曲》的終篇，上一章[《Docker下RabbitMQ延時佇列實戰兩部曲之一：極速體驗》](http://blog.itpub.net/70017844/viewspace-2898361/)我們快速體驗了延時佇列的生產和消費，今天來實戰整個開發過程；

### 本章涉及的指令碼和原始碼下載
- 本章會開發一個yml指令碼，三個基於SpringBoot的應用，功能如下：
1. docker-compose.yml：啟動所有容器的docker-compose指令碼；
2. delayrabbitmqconsumer：SpringBoot框架的應用，連線RabbitMQ的兩個佇列，消費訊息；
3. messagettlproducer：SpringBoot框架的應用，收到web請求後向RabbitMQ傳送訊息，訊息中帶有過期時間（TTL）；
4. queuettlproducer：SpringBoot框架的應用，收到web請求後向RabbitMQ傳送訊息，訊息中不帶過期時間（TTL），但是對應的訊息佇列已經設定了過期時間；

- 整體部署情況如下：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220602/1654184885148860090.png)

- 上述指令碼和工程的原始碼都可以在github下載，地址和連結資訊如下表所示：

| 名稱      |   連結 |   備註|
| :-------- | :----| :----|
| 專案主頁| https://github.com/zq2599/blog_demos | 該專案在GitHub上的主頁 |
| git倉庫地址(https)| https://github.com/zq2599/blog_demos.git | 該專案原始碼的倉庫地址，https協議 |
| git倉庫地址(ssh)| git@github.com:zq2599/blog_demos.git | 該專案原始碼的倉庫地址，ssh協議 |

- 這個git專案中有多個資料夾，三個SpringBoot工程分別在delayrabbitmqconsumer、messagettlproducer、queuettlproducer這三個資料夾下，如下圖的三個紅框所示：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220602/1654184913758976949.png)

- docker-compose.yml檔案在rabbitmq_docker_files資料夾下面的delaymq資料夾下，如下圖：
![image.png](https://bbs-img.huaweicloud.com/blogs/img/20220602/1654184934844270466.png)

### 環境資訊
- 作業系統：Ubuntu 16.04.3 LTS 
- Docker：1.12.6 
- RabbitMQ：3.7.5-rc.1 
- JDK：1.8.0_111 
- SpringBoot：1.4.1.RELEASE
- Maven：3.5.0

### 開發步驟
- 本次開發實戰的步驟如下：
1. 開發messagettlproducer應用，製作映象；
2. 開發queuettlproducer應用，製作映象；
3. 開發delayrabbitmqconsumer應用，製作映象；
4. 開發docker-compose.yml指令碼；

### messagettlproducer應用
- messagettlproducer是個基於SpringBoot的web工程，有一個Controller可以響應web請求，收到請求後傳送一條帶有過期時間的訊息到RabbitMQ的message.ttl.queue.source佇列；
- pom.xml內容如下：
```xml
<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemalocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
        <modelversion>4.0.0</modelversion>

<groupid>com.bolingcavalry</groupid>
        <artifactid>messagettlproducer</artifactid>
        <version>0.0.1-SNAPSHOT</version>
        <packaging>jar</packaging>

<name>messagettlproducer</name>
        <description>Demo project for Spring Boot</description>

<parent>
                <groupid>org.springframework.boot</groupid>
                <artifactid>spring-boot-starter-parent</artifactid>
                <version>1.4.1.RELEASE</version>
                <relativepath></relativepath> 
        </parent>

<dependencies>
                <dependency>
                        <groupid>org.springframework.boot</groupid>
                        <artifactid>spring-boot-starter-amqp</artifactid>
                </dependency>
                <dependency>
                        <groupid>org.springframework.boot</groupid>
                        <artifactid>spring-boot-starter-web</artifactid>
                </dependency>

<dependency>
                        <groupid>org.springframework.boot</groupid>
                        <artifactid>spring-boot-starter-test</artifactid>
                        <scope>test</scope>
                </dependency>
        </dependencies>

<build>
                <plugins>
                        <plugin>
                                <groupid>org.springframework.boot</groupid>
                                <artifactid>spring-boot-maven-plugin</artifactid>
                        </plugin>
                        <plugin>
                                <groupid>com.spotify</groupid>
                                <artifactid>docker-maven-plugin</artifactid>
                                <version>0.4.12</version>
                                
                                <configuration>
                                        
                                        <imagename>bolingcavalry/${project.artifactId}</imagename>
                                        
                                        <imagetags>
                                                <imagetag>${project.version}</imagetag>
                                        </imagetags>
                                        
                                        <baseimage>java:8u111-jdk</baseimage>
                                        
                                        <entrypoint>["java", "-jar", "/${project.build.finalName}.jar"]</entrypoint>
                                        
                                        <resources>
                                                <resource>
                                                        <targetpath>/</targetpath>
                                                        <directory>${project.build.directory}</directory>
                                                        <include>${project.build.finalName}.jar</include>
                                                </resource>
                                        </resources>
                                </configuration>
                        </plugin>
                </plugins>
        </build>
</project>
```
- 上面的內容中有以下兩點需要注意：
a. 新增對spring-boot-starter-amqp的依賴，這裡面是操作RabbitMQ所需的庫；
b. 新增docker-maven-plugin外掛，可以將當前工程直接製作成Docker映象；

- src/main/resources資料夾下面建立application.properties檔案，內容如下，只配置了應用名稱和RabbitMQ的virtualHost路徑：
```properties
spring.application.name=messagettlproducer
mq.rabbit.virtualHost=/
```
- RabbitTemplateConfig.java檔案中是應用連線RabbitMQ的配置資訊：
```java
@Configuration
public class RabbitTemplateConfig {

@Value("${mq.rabbit.address}")
    String address;

@Value("${mq.rabbit.username}")
    String username;

@Value("${mq.rabbit.password}")
    String password;

@Value("${mq.rabbit.virtualHost}")
    String mqRabbitVirtualHost;

//建立mq連線
    @Bean(name = "connectionFactory")
    public ConnectionFactory connectionFactory() {
        CachingConnectionFactory connectionFactory = new CachingConnectionFactory();

connectionFactory.setUsername(username);
        connectionFactory.setPassword(password);
        connectionFactory.setVirtualHost(mqRabbitVirtualHost);
        connectionFactory.setPublisherConfirms(true);

//該方法配置多個host，在當前連線host down掉的時候會自動去重連後面的host
        connectionFactory.setAddresses(address);

return connectionFactory;
    }

@Bean
    @Scope(ConfigurableBeanFactory.SCOPE_PROTOTYPE)
    //必須是prototype型別
    public RabbitTemplate rabbitTemplate() {
        RabbitTemplate template = new RabbitTemplate(connectionFactory());
        return template;
    }
}
```
- 上面的程式碼有以下幾點要注意：
a. address、username、password這些變數的值，是從作業系統的環境變數中獲取的，我們在啟動Docker容器的時候將這些值配置到容器的環境變數中，程式執行的時候就能取到了；
b. connectionFactory()方法根據上述配置引數和RabbitMQ建立連線；
c. rabbitTemplate()建立RabbitTemplate物件，我們可以在其他Bean中透過Autowire使用；

- MessageTtlRabbitConfig.java類中是和訊息佇列相關的配置：
```java
    /**
     * 成為死信後，重新傳送到的交換機的名稱
     */
    @Value("${message.ttl.exchange}")
    private String MESSAGE_TTL_EXCHANGE_NAME;

/**
     * 不會被消費的佇列，投遞到此佇列的訊息會成為死信
     */
    @Value("${message.ttl.queue.source}")
    private String MESSAGE_TTL_QUEUE_SOURCE;

/**
     * 該佇列被繫結到接收死信的交換機
     */
    @Value("${message.ttl.queue.process}")
    private String MESSAGE_TTL_QUEUE_PROCESS;

/**
     * 配置一個佇列，該佇列的訊息如果沒有被消費，就會投遞到死信交換機中，並且帶上指定的routekey
     * @return
     */
    @Bean
    Queue messageTtlQueueSource() {
        return QueueBuilder.durable(MESSAGE_TTL_QUEUE_SOURCE)
                .withArgument("x-dead-letter-exchange", MESSAGE_TTL_EXCHANGE_NAME)
                .withArgument("x-dead-letter-routing-key", MESSAGE_TTL_QUEUE_PROCESS)
                .build();
    }

@Bean("messageTtlQueueProcess")
    Queue messageTtlQueueProcess() {
        return QueueBuilder.durable(MESSAGE_TTL_QUEUE_PROCESS) .build();
    }

@Bean("messageTtlExchange")
    DirectExchange messageTtlExchange() {
        return new DirectExchange(MESSAGE_TTL_EXCHANGE_NAME);
    }

/**
     * 繫結指定的佇列到死信交換機上
     * @param messageTtlQueueProcess
     * @param messageTtlExchange
     * @return
     */
    @Bean
    Binding bindingExchangeMessage(@Qualifier("messageTtlQueueProcess") Queue messageTtlQueueProcess, @Qualifier("messageTtlExchange") DirectExchange messageTtlExchange) {
        System.out.println("11111111111111111111111111111111111111111111111111");
        System.out.println("11111111111111111111111111111111111111111111111111");
        System.out.println("11111111111111111111111111111111111111111111111111");
        System.out.println("11111111111111111111111111111111111111111111111111");
        return BindingBuilder.bind(messageTtlQueueProcess)
                .to(messageTtlExchange)
                .with(MESSAGE_TTL_QUEUE_PROCESS);
    }
```
- 上面的程式碼有以下幾點要注意：
a. MESSAGE_TTL_EXCHANGE_NAME、MESSAGE_TTL_QUEUE_SOURCE、MESSAGE_TTL_QUEUE_PROCESS這些變數的值，是從作業系統的環境變數中獲取的，我們在啟動Docker容器的時候將這些值配置到容器的環境變數中，程式執行的時候就能取到了；
b. connectionFactory()方法根據上述配置引數和RabbitMQ建立連線；
c. rabbitTemplate()建立RabbitTemplate物件，我們可以在其他Bean中透過Autowire使用；
d. messageTtlQueueSource()方法建立了一個佇列用於投遞訊息，透過**x-dead-letter-exchange**和**x-dead-letter-routing-key**這兩個引數，設定了佇列訊息過期後轉發的交換機名稱，以及攜帶的routing key；

- 為了設定訊息過期，我們還要定製一個ExpirationMessagePostProcessor類，作用是將給訊息類設定過期時間，後面傳送訊息時會用到這個類：
```java
package com.bolingcavalry.messagettlproducer;

import org.springframework.amqp.AmqpException;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.core.MessagePostProcessor;

/**
 * @Description :
 * @Author : zq2599@gmail.com
 * @Date : 2018-06-02 23:33
 */
public class ExpirationMessagePostProcessor implements MessagePostProcessor {
    private final Long ttl; // 毫秒

public ExpirationMessagePostProcessor(Long ttl) {
        this.ttl = ttl;
    }

@Override
    public Message postProcessMessage(Message message) throws AmqpException {
        message.getMessageProperties() .setExpiration(ttl.toString()); // 設定per-message的失效時間
        return message;
    }
}
```

- 用於處理web請求的SendMessageController 類，原始碼如下：
```java
/**
 * @Description : 用於生產訊息的web介面類
 * @Author : zq2599@gmail.com
 * @Date : 2018-06-02 23:00
 */
@RestController
public class SendMessageController {

@Autowired
    private RabbitTemplate rabbitTemplate;

@Value("${message.ttl.queue.source}")
    private String MESSAGE_TTL_QUEUE_SOURCE;

/**
     * 生產一條訊息，訊息中帶有過期時間
     * @param name
     * @param message
     * @param delaytime
     * @return
     */
    @RequestMapping(value = "/messagettl/{name}/{message}/{delaytime}", method = RequestMethod.GET)
    public @ResponseBody
    String messagettl(@PathVariable("name") final String name, @PathVariable("message") final String message, @PathVariable("delaytime") final int delaytime) {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String timeStr = simpleDateFormat.format(new Date());
        String queueName = MESSAGE_TTL_QUEUE_SOURCE;
        String  sendMessage = String.format("hello, %s , %s, from queue [%s], delay %d's, %s", name, message, MESSAGE_TTL_QUEUE_SOURCE, delaytime, timeStr);
        rabbitTemplate.convertAndSend(MESSAGE_TTL_QUEUE_SOURCE,
                                        (Object)sendMessage,
                                        new ExpirationMessagePostProcessor(delaytime*1000L));

return "send message to [" +  name + "] success , queue is : " + queueName + " (" + timeStr + ")";
    }
}
```
- 如上所示，傳送訊息的程式碼很簡單，呼叫rabbitTemplate的convertAndSend就能傳送訊息到message.ttl.queue.source佇列（指定路由鍵的Direct方式），再傳入ExpirationMessagePostProcessor作為處理訊息的工具；

- 以上就是messagettlproducer應用的主要程式碼介紹，編碼完畢後，在pom.xml檔案所在目錄執行**mvn clean package -U -DskipTests docker:build**，即可編譯、構建、製作Docker映象；

### queuettlproducer應用
- queuettlproducer和messagettlproducer極為相似，都是接受web請求後向RabbitMQ傳送訊息，不同之處有以下兩點：
1. queuettlproducer在繫結佇列的時候，會設定佇列上所有訊息的過期時間，messagettlproducer沒做這個設定；
2. queuettlproducer在傳送訊息的時候，沒有設定該訊息的過期時間，messagettlproducer會對每條訊息都設定過期時間；

- 因此，queuettlproducer和messagettlproducer這兩個應用的程式碼大部分是相同的，這裡只要關注不同的部分即可；

- 佇列和交換機的配置類，QueueTtlRabbitConfig：
```java
@Configuration
public class QueueTtlRabbitConfig {

/**
     * 成為死信後，重新傳送到的交換機的名稱
     */
    @Value("${queue.ttl.exchange}")
    private String QUEUE_TTL_EXCHANGE_NAME;

/**
     * 不會被消費的佇列，投遞到此佇列的訊息會成為死信
     */
    @Value("${queue.ttl.queue.source}")
    private String QUEUE_TTL_QUEUE_SOURCE;

/**
     * 該佇列被繫結到接收死信的交換機
     */
    @Value("${queue.ttl.queue.process}")
    private String QUEUE_TTL_QUEUE_PROCESS;

@Value("${queue.ttl.value}")
    private long QUEUE_TTL_VALUE;

/**
     * 配置一個佇列，該佇列有訊息過期時間，訊息如果沒有被消費，就會投遞到死信交換機中，並且帶上指定的routekey
     * @return
     */
    @Bean
    Queue queueTtlQueueSource() {
        return QueueBuilder.durable(QUEUE_TTL_QUEUE_SOURCE)
                .withArgument("x-dead-letter-exchange", QUEUE_TTL_EXCHANGE_NAME)
                .withArgument("x-dead-letter-routing-key", QUEUE_TTL_QUEUE_PROCESS)
                .withArgument("x-message-ttl", QUEUE_TTL_VALUE)
                .build();
    }

@Bean("queueTtlQueueProcess")
    Queue queueTtlQueueProcess() {
        return QueueBuilder.durable(QUEUE_TTL_QUEUE_PROCESS) .build();
    }

@Bean("queueTtlExchange")
    DirectExchange queueTtlExchange() {
        return new DirectExchange(QUEUE_TTL_EXCHANGE_NAME);
    }

/**
     * 繫結
     * @param queueTtlQueueProcess
     * @param queueTtlExchange
     * @return
     */
    @Bean
    Binding bindingExchangeMessage(@Qualifier("queueTtlQueueProcess") Queue queueTtlQueueProcess, @Qualifier("queueTtlExchange") DirectExchange queueTtlExchange) {
        System.out.println("22222222222222222222222222222222222222222222222222");
        System.out.println("22222222222222222222222222222222222222222222222222");
        System.out.println("22222222222222222222222222222222222222222222222222");
        System.out.println("22222222222222222222222222222222222222222222222222");
        return BindingBuilder.bind(queueTtlQueueProcess)
                .to(queueTtlExchange)
                .with(QUEUE_TTL_QUEUE_PROCESS);
    }
}
```
- 上述程式碼請注意以下兩點：
a. queueTtlQueueSource()方法用來設定佇列，除了**x-dead-letter-exchange**和**x-dead-letter-routing-key**這兩個引數，還多了**x-message-ttl**，此引數對應的值就是進入該佇列的每一條訊息的過期時間；
b. bindingExchangeMessage()方法將佇列queue.ttl.queue.source繫結到Direct模式的交換機；

- 處理web請求的SendMessageController類：
```java
@RestController
public class SendMessageController {

@Autowired
    private RabbitTemplate rabbitTemplate;

@Value("${queue.ttl.queue.source}")
    private String QUEUE_TTL_QUEUE_SOURCE;

/**
     * 生產一條訊息，訊息中不帶過期時間，但是對應的佇列中已經配置了過期時間
     * @param name
     * @param message
     * @return
     */
    @RequestMapping(value = "/queuettl/{name}/{message}", method = RequestMethod.GET)
    public @ResponseBody
    String queuettl(@PathVariable("name") final String name, @PathVariable("message") final String message) {
        SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");
        String timeStr = simpleDateFormat.format(new Date());
        String queueName = QUEUE_TTL_QUEUE_SOURCE;
        String  sendMessage = String.format("hello, %s , %s, from queue [%s], %s", name, message, queueName, timeStr);
        rabbitTemplate.convertAndSend(queueName, sendMessage);

return "send message to [" +  name + "] success , queue is : " + queueName + " (" + timeStr + ")";
    }
}
```
- 如上所示，傳送訊息時只有routing key和訊息物件這兩個引數；

- 以上就是傳送訊息到佇列的應用原始碼，編碼完畢後，在pom.xml檔案所在目錄執行**mvn clean package -U -DskipTests docker:build**，即可編譯、構建、製作Docker映象；

- 接下來我們看看訊息消費者工程delayrabbitmqconsumer的原始碼；

### delayrabbitmqconsumer應用
- delayrabbitmqconsumer應用連線到訊息佇列，消費收到的每條訊息；

- RabbitTemplateConfig.java是連線到RabbitMQ的配置資訊，和前面兩個應用一樣，不再贅述；
- 消費message.ttl.queue.process這個佇列發出的訊息，對應實現類是MessageTtlReceiver：
```java
/**
 * @Description : 訊息接受類，接收第一類延時訊息(在每條訊息中指定過期時間)的轉發結果
 * @Author : zq2599@gmail.com
 * @Date : 2018-06-03 9:52
 */
@Component
@RabbitListener(queues = "${message.ttl.queue.process}")
public class MessageTtlReceiver {
    private static final Logger logger = LoggerFactory.getLogger(MessageTtlReceiver.class);

@RabbitHandler
    public void process(String message) {
        logger.info("receive message : " + message);
    }
}
```
- 如上所示，只要用註解RabbitListener配置好佇列的名稱即可，編碼完畢後，在pom.xml檔案所在目錄執行**mvn clean package -U -DskipTests docker:build**，即可編譯、構建、製作Docker映象；

### docker-compose.yml配置
- 最後我們看一下所有容器的配置檔案docker-compose.yml：
```yml
version: '2'
services:
  rabbit1:
    image: bolingcavalry/rabbitmq-server:0.0.3
    hostname: rabbit1
    ports:
      - "15672:15672"
    environment:
      - RABBITMQ_DEFAULT_USER=admin
      - RABBITMQ_DEFAULT_PASS=888888
  rabbit2:
    image: bolingcavalry/rabbitmq-server:0.0.3
    hostname: rabbit2
    depends_on:
      - rabbit1
    links:
      - rabbit1
    environment:
     - CLUSTERED=true
     - CLUSTER_WITH=rabbit1
     - RAM_NODE=true
     - HA_ENABLE=true
    ports:
      - "15673:15672"
  rabbit3:
    image: bolingcavalry/rabbitmq-server:0.0.3
    hostname: rabbit3
    depends_on:
      - rabbit2
    links:
      - rabbit1
      - rabbit2
    environment:
      - CLUSTERED=true
      - CLUSTER_WITH=rabbit1
    ports:
      - "15675:15672"
  messagettlproducer:
    image: bolingcavalry/messagettlproducer:0.0.1-SNAPSHOT
    hostname: messagettlproducer
    depends_on:
      - rabbit3
    links:
      - rabbit1:rabbitmqhost1
      - rabbit2:rabbitmqhost2
      - rabbit3:rabbitmqhost3
    ports:
      - "18080:8080"
    environment:
      - mq.rabbit.address=rabbitmqhost1:5672,rabbitmqhost2:5672,rabbitmqhost3:5672
      - mq.rabbit.username=admin
      - mq.rabbit.password=888888
      - message.ttl.exchange=message.ttl.exchange
      - message.ttl.queue.source=message.ttl.queue.source
      - message.ttl.queue.process=message.ttl.queue.process
  queuettlproducer:
    image: bolingcavalry/queuettlproducer:0.0.1-SNAPSHOT
    hostname: queuettlproducer
    depends_on:
      - messagettlproducer
    links:
      - rabbit1:rabbitmqhost1
      - rabbit2:rabbitmqhost2
      - rabbit3:rabbitmqhost3
    ports:
      - "18081:8080"
    environment:
      - mq.rabbit.address=rabbitmqhost1:5672,rabbitmqhost2:5672,rabbitmqhost3:5672
      - mq.rabbit.username=admin
      - mq.rabbit.password=888888
      - queue.ttl.exchange=queue.ttl.exchange
      - queue.ttl.queue.source=queue.ttl.queue.source
      - queue.ttl.queue.process=queue.ttl.queue.process
      - queue.ttl.value=5000
  delayrabbitmqconsumer:
    image: bolingcavalry/delayrabbitmqconsumer:0.0.1-SNAPSHOT
    hostname: delayrabbitmqconsumer
    depends_on:
      - queuettlproducer
    links:
      - rabbit1:rabbitmqhost1
      - rabbit2:rabbitmqhost2
      - rabbit3:rabbitmqhost3
    environment:
     - mq.rabbit.address=rabbitmqhost1:5672,rabbitmqhost2:5672,rabbitmqhost3:5672
     - mq.rabbit.username=admin
     - mq.rabbit.password=888888
     - message.ttl.queue.process=message.ttl.queue.process
     - queue.ttl.queue.process=queue.ttl.queue.process
```
- 上述配置檔案有以下幾點需要注意：
- rabbit1、rabbit2、rabbit3是RabbitMQ高可用叢集，如果您對RabbitMQ高可用叢集感興趣，推薦您請看[《Docker下RabbitMQ四部曲》](http://blog.itpub.net/70017844/viewspace-2897069/)系列文章；
- 三個SpringBoot應用都配置了**mq.rabbit.address**引數，值是三個RabbitMQ server的IP加埠，這樣如果RabbitMQ叢集中有一臺機器故障了也不會影響正常的訊息收發；
- 使用了link引數後，容器內就能透過link的引數取代對應的IP；

- 至此，Docker下的RabbitMQ延時佇列實戰就完成了，實戰中Docker發揮的作用並不大，只是用來快速搭建環境，關鍵還是三個工程中對佇列的各種操作，希望本系列能幫助您快速構建延時佇列相關服務；

### 歡迎關注ITpub：程式設計師欣宸
> [學習路上，你不孤單，欣宸原創一路相伴...](http://blog.itpub.net/70017844/)

Docker下RabbitMQ延時佇列實戰兩部曲之二：細說開發

相關文章