1 搭建項目
1.1 創建springboot項目
使用idea創建 Spring Initializr
1.2 添加依賴
<dependencies>
<!--RabbitMQ 依賴-->
<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>
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.47</version>
</dependency>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--swagger-->
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger2</artifactId>
<version>2.9.2</version>
</dependency>
<dependency>
<groupId>io.springfox</groupId>
<artifactId>springfox-swagger-ui</artifactId>
<version>2.9.2</version>
</dependency>
<!--RabbitMQ 測試依賴-->
<dependency>
<groupId>org.springframework.amqp</groupId>
<artifactId>spring-rabbit-test</artifactId>
<scope>test</scope>
</dependency>
</dependencies>
1.3 application.properties添加配置
spring.rabbitmq.host=192.168.1.100
spring.rabbitmq.port=5672
spring.rabbitmq.username=admin
spring.rabbitmq.password=admin
spring.rabbitmq.virtualHost=my_vhost
1.4 添加Swagger配置類
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import springfox.documentation.builders.ApiInfoBuilder;
import springfox.documentation.service.ApiInfo;
import springfox.documentation.spi.DocumentationType;
import springfox.documentation.spring.web.plugins.Docket;
import springfox.documentation.swagger2.annotations.EnableSwagger2;
@Configuration
@EnableSwagger2
public class SwaggerConfig {
@Bean
public Docket webApiConfig() {
return new Docket(DocumentationType.SWAGGER_2)
.groupName("webApi")
.apiInfo(webApiInfo())
.select()
.build();
}
private ApiInfo webApiInfo() {
return new ApiInfoBuilder()
.title("rabbitmq 接口文檔")
.description("本文檔描述了 rabbitmq 微服務接口定義")
.version("1.0")
.build();
}
}
啟動項目即可
2 死信隊列做延遲隊列例子
場景如下：
創建兩個隊列 QA 和 QB，兩者隊列 TTL 分別設置為 10S 和 40S，然后在創建一個交換機 X 和死信交換機 Y，它們的類型都是 direct，創建一個死信隊列 QD，它們的綁定關系如下：
2.1 配置文件類代碼
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import java.util.HashMap;
import java.util.Map;
@Configuration
public class TtlQueueConfig {
public static final String X_EXCHANGE = "X";
public static final String QUEUE_A = "QA";
public static final String QUEUE_B = "QB";
public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
public static final String DEAD_LETTER_QUEUE = "QD";
// 聲明 xExchange
@Bean("xExchange")
public DirectExchange xExchange() {
return new DirectExchange(X_EXCHANGE);
}
// 聲明 xExchange
@Bean("yExchange")
public DirectExchange yExchange() {
return new DirectExchange(Y_DEAD_LETTER_EXCHANGE);
}
//聲明隊列 A ttl 為 10s 並綁定到對應的死信交換機
@Bean("queueA")
public Queue queueA() {
Map<String, Object> args = new HashMap<>(3);
//聲明當前隊列綁定的死信交換機
args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
//聲明當前隊列的死信路由 key
args.put("x-dead-letter-routing-key", "YD");
//聲明隊列的 TTL
args.put("x-message-ttl", 10000);
return QueueBuilder.durable(QUEUE_A).withArguments(args).build();
}
// 聲明隊列 A 綁定 X 交換機
@Bean
public Binding queueaBindingX(@Qualifier("queueA") Queue queueA,
@Qualifier("xExchange") DirectExchange xExchange) {
return BindingBuilder.bind(queueA).to(xExchange).with("XA");
}
//聲明隊列 B ttl 為 40s 並綁定到對應的死信交換機
@Bean("queueB")
public Queue queueB() {
Map<String, Object> args = new HashMap<>(3);
//聲明當前隊列綁定的死信交換機
args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
//聲明當前隊列的死信路由 key
args.put("x-dead-letter-routing-key", "YD");
//聲明隊列的 TTL
args.put("x-message-ttl", 40000);
return QueueBuilder.durable(QUEUE_B).withArguments(args).build();
}
//聲明隊列 B 綁定 X 交換機
@Bean
public Binding queuebBindingX(@Qualifier("queueB") Queue queue1B,
@Qualifier("xExchange") DirectExchange xExchange) {
return BindingBuilder.bind(queue1B).to(xExchange).with("XB");
}
//聲明死信隊列 QD
@Bean("queueD")
public Queue queueD() {
return new Queue(DEAD_LETTER_QUEUE);
}
//聲明死信隊列 QD 綁定關系
@Bean
public Binding deadLetterBindingQAD(@Qualifier("queueD") Queue queueD,
@Qualifier("yExchange") DirectExchange yExchange) {
return BindingBuilder.bind(queueD).to(yExchange).with("YD");
}
}
2.3 消息生產者代碼
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import java.util.Date;
@Slf4j
@RequestMapping("ttl")
@RestController
public class SendMsgController {
@Autowired
private RabbitTemplate rabbitTemplate;
@GetMapping("sendMsg/{message}")
public void sendMsg(@PathVariable String message) {
log.info("當前時間：{},發送一條信息給兩個 TTL 隊列:{}", new Date(), message);
rabbitTemplate.convertAndSend("X", "XA", "消息來自 ttl 為 10S 的隊列: " + message);
rabbitTemplate.convertAndSend("X", "XB", "消息來自 ttl 為 40S 的隊列: " + message);
}
}
2.4 消息消費者代碼
import com.rabbitmq.client.Channel;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.core.Message;
import org.springframework.amqp.rabbit.annotation.RabbitListener;
import org.springframework.stereotype.Component;
import java.io.IOException;
import java.util.Date;
@Slf4j
@Component
public class DeadLetterQueueConsumer {
@RabbitListener(queues = "QD")
public void receiveD(Message message, Channel channel) throws IOException {
String msg = new String(message.getBody());
log.info("當前時間：{},收到死信隊列信息{}", new Date().toString(), msg);
}
}
發起一個請求 http://localhost:8080/ttl/sendMsg/側死哦
第一條消息在 10S 后變成了死信消息，然后被消費者消費掉，第二條消息在 40S 之后變成了死信消息，然后被消費掉，這樣一個延時隊列就打造完成了。
不過，如果這樣使用的話，豈不是每增加一個新的時間需求，就要新增一個隊列，這里只有 10S 和 40S兩個時間選項，如果需要一個小時后處理，那么就需要增加 TTL 為一個小時的隊列，如果是預定會議室然后提前通知這樣的場景，豈不是要增加無數個隊列才能滿足需求？
3 延時隊列優化
代碼架構圖
在這里新增了一個隊列 QC,綁定關系如下,該隊列不設置 TTL 時間
3.1 配置文件類代碼
在原來的基礎上，新增隊列C
import org.springframework.amqp.core.*;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.context.annotation.Bean;
import org.springframework.stereotype.Component;
import java.util.HashMap;
import java.util.Map;
@Component
public class MsgTtlQueueConfig {
public static final String Y_DEAD_LETTER_EXCHANGE = "Y";
public static final String QUEUE_C = "QC";
//聲明隊列 C 死信交換機
@Bean("queueC")
public Queue queueB() {
Map<String, Object> args = new HashMap<>(3);
//聲明當前隊列綁定的死信交換機
args.put("x-dead-letter-exchange", Y_DEAD_LETTER_EXCHANGE);
//聲明當前隊列的死信路由 key
args.put("x-dead-letter-routing-key", "YD");
//沒有聲明 TTL 屬性
return QueueBuilder.durable(QUEUE_C).withArguments(args).build();
}
//聲明隊列 B 綁定 X 交換機
@Bean
public Binding queuecBindingX(@Qualifier("queueC") Queue queueC,
@Qualifier("xExchange") DirectExchange xExchange) {
return BindingBuilder.bind(queueC).to(xExchange).with("XC");
}
}
3.2 消息生產者代碼
@GetMapping("sendExpirationMsg/{message}/{ttlTime}")
public void sendMsg(@PathVariable String message,@PathVariable String ttlTime) {
rabbitTemplate.convertAndSend("X", "XC", message, correlationData ->{
correlationData.getMessageProperties().setExpiration(ttlTime);
return correlationData;
});
log.info("當前時間：{},發送一條時長{}毫秒 TTL 信息給隊列 C:{}", new Date(),ttlTime, message);
}
發起請求
http://localhost:8080/ttl/sendExpirationMsg/你好 1/20000
http://localhost:8080/ttl/sendExpirationMsg/你好 2/2000
看起來似乎沒什么問題，但是在最開始的時候，就介紹過如果使用在消息屬性上設置 TTL 的方式，消息可能並不會按時“死亡“，因為 RabbitMQ 只會檢查第一個消息是否過期，如果過期則丟到死信隊列，如果第一個消息的延時時長很長，而第二個消息的延時時長很短，第二個消息並不會優先得到執行。
4 Rabbitmq 插件實現延遲隊列
上文中提到的問題，確實是一個問題，如果不能實現在消息粒度上的 TTL，並使其在設置的 TTL 時間及時死亡，就無法設計成一個通用的延時隊列。那如何解決呢，接下來我們就去解決該問題。
安裝延時隊列插件
在官網上下載 https://www.rabbitmq.com/community-plugins.html，下載rabbitmq_delayed_message_exchange 插件，然后解壓放置到 RabbitMQ 的插件目錄。
4.1 sudo docker ps -a 查看容器（容器需要啟動）
[vagrant@localhost vagrant]$ sudo docker ps -a
CONTAINER ID IMAGE COMMAND CREATED STATUS PORTS NAMES
4c97bfd2bd98 4af918bb5f6a "docker-entrypoint.s…" 4 days ago Up 6 minutes 4369/tcp, 5671/tcp, 0.0.0.0:5672->5672/tcp, :::5672->5672/tcp, 15671/tcp, 15691-15692/tcp, 25672/tcp, 0.0.0.0:15672->15672/tcp, :::15672->15672/tcp rabbitmq3.9.4
4.2 上傳rabbitmq_delayed_message_exchange-3.9.0.ez插件到Linux中
由於我們是vagrant啟動的。將文件復制到虛擬機目錄下就可以了。/d/vm/centos7
虛擬機會將這個目錄共享到 linux里面的/vagrant目錄。
[vagrant@localhost ~]$ cd /vagrant/
[vagrant@localhost vagrant]$ ls
CentOS-7-x86_64-Vagrant-2004_01.VirtualBox.box rabbitmq-delayed-message-exchange-3.9.0.tar.gz 虛擬機使用說明.txt
rabbitmq_delayed_message_exchange-3.9.0.ez Vagrantfile
4.3 將文件復制到rabbitmq的插件中,然后進入目錄,查看插件列表
[vagrant@localhost vagrant]$ sudo docker cp rabbitmq_delayed_message_exchange-3.9.0.ez rabbitmq3.9.4:/plugins
[vagrant@localhost vagrant]$ sudo docker exec -it rabbitmq3.9.4 bash
root@myRabbit:/# rabbitmq-plugins list
Listing plugins with pattern ".*" ...
Configured: E = explicitly enabled; e = implicitly enabled
| Status: * = running on rabbit@myRabbit
|/
[ ] rabbitmq_amqp1_0 3.9.4
[ ] rabbitmq_auth_backend_cache 3.9.4
[ ] rabbitmq_auth_backend_http 3.9.4
[ ] rabbitmq_auth_backend_ldap 3.9.4
[ ] rabbitmq_auth_backend_oauth2 3.9.4
[ ] rabbitmq_auth_mechanism_ssl 3.9.4
[ ] rabbitmq_consistent_hash_exchange 3.9.4
[ ] rabbitmq_delayed_message_exchange 3.9.0
[ ] rabbitmq_event_exchange 3.9.4
[ ] rabbitmq_federation 3.9.4
[ ] rabbitmq_federation_management 3.9.4
[ ] rabbitmq_jms_topic_exchange 3.9.4
[E*] rabbitmq_management 3.9.4
[e*] rabbitmq_management_agent 3.9.4
[ ] rabbitmq_mqtt 3.9.4
[ ] rabbitmq_peer_discovery_aws 3.9.4
[ ] rabbitmq_peer_discovery_common 3.9.4
[ ] rabbitmq_peer_discovery_consul 3.9.4
[ ] rabbitmq_peer_discovery_etcd 3.9.4
[ ] rabbitmq_peer_discovery_k8s 3.9.4
[E*] rabbitmq_prometheus 3.9.4
[ ] rabbitmq_random_exchange 3.9.4
[ ] rabbitmq_recent_history_exchange 3.9.4
[ ] rabbitmq_sharding 3.9.4
[ ] rabbitmq_shovel 3.9.4
[ ] rabbitmq_shovel_management 3.9.4
[ ] rabbitmq_stomp 3.9.4
[ ] rabbitmq_stream 3.9.4
[ ] rabbitmq_stream_management 3.9.4
[ ] rabbitmq_top 3.9.4
[ ] rabbitmq_tracing 3.9.4
[ ] rabbitmq_trust_store 3.9.4
[e*] rabbitmq_web_dispatch 3.9.4
[ ] rabbitmq_web_mqtt 3.9.4
[ ] rabbitmq_web_mqtt_examples 3.9.4
[ ] rabbitmq_web_stomp 3.9.4
[ ] rabbitmq_web_stomp_examples 3.9.4
4.4 發現插件已經處理，然后啟動插件
root@myRabbit:/# rabbitmq-plugins enable rabbitmq_delayed_message_exchange
Enabling plugins on node rabbit@myRabbit:
rabbitmq_delayed_message_exchange
The following plugins have been configured:
rabbitmq_delayed_message_exchange
rabbitmq_management
rabbitmq_management_agent
rabbitmq_prometheus
rabbitmq_web_dispatch
Applying plugin configuration to rabbit@myRabbit...
The following plugins have been enabled:
rabbitmq_delayed_message_exchange
started 1 plugins.
啟動插件后，控制台創建交換機就可以看到了。
4.5 代碼架構圖
在這里新增了一個隊列 delayed.queue,一個自定義交換機 delayed.exchange，綁定關系如下:
4.6 配置文件類代碼
再次新增配置類
@Configuration
public class DelayedQueueConfig {
public static final String DELAYED_QUEUE_NAME = "delayed.queue";
public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
@Bean
public Queue delayedQueue() {
return new Queue(DELAYED_QUEUE_NAME);
}
//自定義交換機 我們在這里定義的是一個延遲交換機
@Bean
public CustomExchange delayedExchange() {
Map<String, Object> args = new HashMap<>();
//自定義交換機的類型
args.put("x-delayed-type", "direct");
return new CustomExchange(DELAYED_EXCHANGE_NAME, "x-delayed-message", true, false,
args);
}
@Bean
public Binding bindingDelayedQueue(@Qualifier("delayedQueue") Queue queue,
@Qualifier("delayedExchange") CustomExchange
delayedExchange) {
return
BindingBuilder.bind(queue).to(delayedExchange).with(DELAYED_ROUTING_KEY).noargs();
}
}
4.7 生產者代碼：
public static final String DELAYED_EXCHANGE_NAME = "delayed.exchange";
public static final String DELAYED_ROUTING_KEY = "delayed.routingkey";
@GetMapping("sendDelayMsg/{message}/{delayTime}")
public void sendMsg(@PathVariable String message,@PathVariable Integer delayTime) {
rabbitTemplate.convertAndSend(DELAYED_EXCHANGE_NAME, DELAYED_ROUTING_KEY, message,
correlationData ->{
correlationData.getMessageProperties().setDelay(delayTime);
return correlationData;
});
log.info(" 當 前 時 間 ： {}, 發送一條延遲 {} 毫秒的信息給隊列 delayed.queue:{}", new
Date(),delayTime, message);
}
4.8 消費者代碼：
public static final String DELAYED_QUEUE_NAME = "delayed.queue";
@RabbitListener(queues = DELAYED_QUEUE_NAME)
public void receiveDelayedQueue(Message message){
String msg = new String(message.getBody());
log.info("當前時間：{},收到延時隊列的消息：{}", new Date().toString(), msg);
}
發起請求：
http://localhost:8080/ttl/sendDelayMsg/come on baby1/20000
http://localhost:8080/ttl/sendDelayMsg/come on baby2/2000
第二個消息被先消費掉了，符合預期
5 總結
延時隊列在需要延時處理的場景下非常有用，使用 RabbitMQ 來實現延時隊列可以很好的利用RabbitMQ 的特性，如：消息可靠發送、消息可靠投遞、死信隊列來保障消息至少被消費一次以及未被正確處理的消息不會被丟棄。另外，通過 RabbitMQ 集群的特性，可以很好的解決單點故障問題，不會因為單個節點掛掉導致延時隊列不可用或者消息丟失。
當然，延時隊列還有很多其它選擇，比如利用 Java 的 DelayQueue，利用 Redis 的 zset，利用 Quartz或者利用 kafka 的時間輪，這些方式各有特點,看需要適用的場景