若文章内容或图片失效,请留言反馈。部分素材来自网络,若不小心影响到您的利益,请联系博主删除。
前言
- 学习资料链接
- 写这篇博客旨在制作笔记,巩固知识。同时方便个人在线阅览,回顾知识。
- 博客的内容主要来自视频内容和资料中提供的学习笔记。
系列目录
SpringCloud 微服务技术栈_实用篇②_黑马旅游案例
SpringCloud 微服务技术栈_高级篇⑤_可靠消息服务
微服务技术栈导学
服务异步通讯(高级篇)_RabbitMQ 的高级特性 |
21.服务异步通信
消息队列在使用过程中,面临着很多的实际问题。
22.消息可靠性
22.1.回顾 RabbitMQ 发送流程
RabbitMQ 官网:https://www.rabbitmq.com/
消息从发送,到消费者接收,会经理多个过程
其中的每一步都可能导致消息丢失,常见的丢失原因包括
- 发送时丢失
- 生产者发送的消息未送达 exchange
- 消息到达 exchange 后未到达 queue
- MQ 宕机,queue 将消息丢失
- consumer 接收到消息后未消费就宕机
针对这些问题,RabbitMQ 分别给出了解决方案:
- 生产者确认机制
- MQ 持久化
- 消费者确认机制
- 失败重试机制
22.2.生产者消息确认
22.2.1.生产者确认机制
RabbitMQ 提供了 publisher confirm 机制来避免消息发送到 MQ 过程中丢失。
这种机制必须给每个消息指定一个唯一 ID。
消息发送到 MQ 以后,会返回一个结果给发送者,表示消息是否处理成功。
返回结果有两种方式
- publisher-confirm:发送者确认
- 消息成功投递到交换机,返回 ack
- 消息未投递到交换机,返回 nack
- publisher-return:发送者回执
- 消息投递到交换机了,但是没有路由到队列。返回 ACK,及路由失败原因。
注意
- 确认机制发送消息时,需要给每个消息设置一个全局唯一 id,以区分不同消息,避免 ack 冲突
22.2.2.RabbitMQ 准备工作
下述的前三个回顾的内容即为 单机部署 RabbitMQ
- 使用 Docker 运行 RabiitMQ 容器的操作在之前的博客中已经说明过。
- 【SpringCloud 微服务技术栈_实用篇①_基础知识】 中的 15.RabbitMQ 快速入门
- 此处只当作是复习了。
- 加载上传镜像
本章节的学习资料中也同样提供了 mq.tar,将该镜像包上传到虚拟机中使用命令加载
docker load -i mq.tar
加载完成后得到的镜像的名称是:rabbitmq:3-management
- 执行下面的命令来执行 RabbitMQ 容器
docker run \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123456 \
-v mq-plugins:/plugins \
--name mq \
--hostname mq1 \
-p 15672:15672 \
-p 5672:5672 \
-d \
rabbitmq:3.8-management
- 使用命令关闭之前创建过的 mq 容器
docker stop mq
- 使用命令开启之前创建过的 mq 容器
docker start mq
访问 虚拟机地址:15672
,输入之前设置的用户名和密码,即可进入 RabbitMQ 的管理平台
输入你之前创建启动容器时的用户名和密码就可以了
更多细节还请参考 Docker 官网:https://hub.docker.com/_/rabbitmq
在进行下面的操作前还需要先创建一个队列:simple.queue
22.2.3.导入项目
导入课前资料提供的 demo 工程(mq-advanced-demo
)
导入的项目的结构如下
22.2.4.修改配置
修改 publisher
服务中的 application.yml
文件,添加下面的内容
spring:
rabbitmq:
publisher-confirm-type: correlated
publisher-returns: true
template:
mandatory: true
说明
publish-confirm-type
:开启 publisher-confirm,这里支持两种类型simple
:同步等待 confirm 结果,直到超时correlated
:异步回调,定义 ConfirmCallback,MQ 返回结果时会回调这个 ConfirmCallback
publish-returns
:开启 publish-return 功能,同样是基于 callback 机制,不过是定义 ReturnCallbacktemplate.mandatory
:定义消息路由失败时的策略。- true,则调用 ReturnCallback
- false:则直接丢弃消息
22.2.5.定义 Return 回调
消息到了交换机,但是路由的时候失败了
每个 RabbitTemplate 只能配置一个 ReturnCallback,因此需要在项目加载时配置
修改 publisher
服务中的 src/main/java/cn/itcast/mq/config/CommonConfig.java
文件
package cn.itcast.mq.config;
import lombok.extern.slf4j.Slf4j;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.BeansException;
import org.springframework.context.ApplicationContext;
import org.springframework.context.ApplicationContextAware;
import org.springframework.context.annotation.Configuration;
@Slf4j
@Configuration
public class CommonConfig implements ApplicationContextAware {
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
// 获取 RabbitTemplate 对象
RabbitTemplate rabbitTemplate = applicationContext.getBean(RabbitTemplate.class);
// 配置 ReturnCallback
rabbitTemplate.setReturnCallback((message, replyCode, replyText, exchange, routingKey) -> {
// 投递失败,记录日志
log.info(
"消息发送失败,应答码{},原因{},交换机{},路由键{},消息{}",
replyCode, replyText, exchange, routingKey, message.toString()
);
// 如果有业务需要,可以重发消息
});
}
}
22.2.6.定义 ConfirmCallback
消息连交换机都没有到达
ConfirmCallback 可以在发送消息时指定,因为每个业务处理 confirm 成功或失败的逻辑不一定相同。
在 publisher
服务的 cn.itcast.mq.spring.SpringAmqpTest
类中,定义一个单元测试方法
package cn.itcast.mq.spring;
import lombok.extern.slf4j.Slf4j;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.springframework.amqp.rabbit.connection.CorrelationData;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.boot.test.context.SpringBootTest;
import org.springframework.test.context.junit4.SpringRunner;
import java.util.UUID;
@Slf4j
@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAmqpTest {
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testSendMessage2SimpleQueue() throws InterruptedException {
// 1.消息体
String message = "hello, spring amqp!";
/* 2.准备 CorrelationData */
// 2.1.全局唯一的消息 ID,需要封装到 CorrelationData 中
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
// 2.2.添加 callback
correlationData.getFuture().addCallback(
result -> {
//判断结果
if (result.isAck()) {
// 3.1.ack,消息成功
log.debug("消息投递到交换机成功!消息ID:{}", correlationData.getId());
} else {
// 3.2.nack,消息失败
log.error("消息投递到交换机失败!消息ID:{}, 原因{}", correlationData.getId(), result.getReason());
}
//重发消息
},
ex -> log.error("消息发送异常,!消息ID:{}, 原因:{}", correlationData.getId(), ex.getMessage())
);
// 3.发送消息
rabbitTemplate.convertAndSend("amq.topic", "simple.test", message, correlationData);
// 休眠一会儿,等待 ack 回执
Thread.sleep(2000);
}
}
22.2.7.小结
SpringAMQP 中处理消息确认的几种情况
publisher-comfirm
- 消息成功发送到 exchange,返回 ack
- 消息发送失败,没有到达交换机,返回 nack
- 消息发送过程中出现异常,没有收到回执
- 消息成功发送到 exchange,但没有路由到 queue,调用 ReturnCallback
22.3.消息持久化
22.3.1.交换机持久化
RabbitMQ 中交换机默认是非持久化的,mq
重启后就丢失。
SpringAMQP 中可以通过代码指定交换机持久化
@Bean
public DirectExchange simpleExchange(){
// 三个参数:交换机名称、是否持久化、当没有 queue 与其绑定时是否自动删除
return new DirectExchange("simple.direct", true, false);
}
事实上,默认情况下,由 SpringAMQP 声明的交换机都是持久化的。
可以在 RabbitMQ 控制台看到持久化的交换机都会带上 D
(durable) 的标示
22.3.2.队列持久化
RabbitMQ 中队列默认是非持久化的,mq
重启后就丢失。
SpringAMQP 中可以通过代码指定交换机持久化
@Bean
public Queue simpleQueue(){
// 使用 QueueBuilder 构建队列,durable 就是持久化的
return QueueBuilder.durable("simple.queue").build();
}
事实上,默认情况下,由 SpringAMQP 声明的队列都是持久化的。
可以在 RabbitMQ 控制台看到持久化的队列都会带上 D
的标示
因为消费者在启动时可以帮我们创建队列和交换机,故可以在消费者模块下声明一下
consumer
服务下的 src/main/java/cn/itcast/mq/config/CommonConfig.java
import org.springframework.amqp.core.*;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class CommonConfig {
@Bean
public DirectExchange simpleDirect() {
return new DirectExchange("simple.direct", true, false);
}
@Bean
public Queue simpleQueue() {
return QueueBuilder.durable("simple.queue").build();
}
}
22.3.3.消息持久化
利用 SpringAMQP 发送消息时,可以设置消息的属性(MessageProperties),指定 delivery-mode
- 非持久化
- 持久化
用 java 代码指定
Message message = MessageBuilder.withBody(
"hello, spring".getBytes(StandardCharsets.UTF_8))// 消息体
.setDeliveryMode(MessageDeliveryMode.PERSISTENT)// 持久化
.build();
默认情况下,SpringAMQP 发出的任何消息都是持久化的,不用特意指定。
22.4.消费者消息确认
22.4.1.概念
RabbitMQ是 阅后即焚 机制,RabbitMQ 确认消息被消费者消费后会立刻删除。
RabbitMQ 是通过消费者回执来确认消费者是否成功处理消息的
- 消费者获取消息后,应该向 RabbitMQ 发送 ACK 回执,表明自己已经处理消息。
设想这样的场景
- RabbitMQ 投递消息给消费者
- 消费者获取消息后,返回 ACK 给 RabbitMQ
- RabbitMQ 删除消息
- 消费者宕机,消息尚未处理
这样,消息就丢失了。因此消费者返回 ACK 的时机非常重要。
而 SpringAMQP 则允许配置三种确认模式
manual
:手动 ack,需要在业务代码结束后,调用 api 发送 ack。auto
:自动 ack,由 spring 监测 listener 代码是否出现异常,没有异常则返回 ack;抛出异常则返回 nacknone
:关闭 ack,MQ 假定消费者获取消息后会成功处理,因此消息投递后立即被删除
由此可知
none
模式下,消息投递是不可靠的,可能丢失auto
模式类似事务机制,出现异常时返回 nack,消息回滚到 mq;没有异常,返回 ackmanual
:自己根据业务情况,判断什么时候该 ack
一般,我们都是使用默认的 auto 即可。
22.4.2.演示 none 模式
修改 consumer
服务的 application.yml
文件,添加下面内容
src/main/resources/application.yml
spring:
rabbitmq:
listener:
simple:
acknowledge-mode: none # [none:关闭 ack];[manual:手动 ack];[auto:自动 ack]
修改 consumer
服务的 SpringRabbitListener 类中的方法,模拟一个消息处理异常
src/main/java/cn/itcast/mq/listener/SpringRabbitListener.java
@Slf4j
@Component
public class SpringRabbitListener {
@RabbitListener(queues = "simple.queue")
public void listenSimpleQueue(String msg) {
log.info("消费者接收到 simple.queue 的消息:【{}】", msg);
// 模拟异常
System.out.println(1 / 0);
log.debug("消息处理完成!");
}
}
通过测试可以发现,当消息处理抛异常时,消息依然被 RabbitMQ 删除了。
22.4.3.演示 auto 模式
再次把确认机制修改为 auto
consumer
服务下的 src/main/resources/application.yml
文件
spring:
rabbitmq:
listener:
simple:
acknowledge-mode: auto # [none:关闭 ack];[manual:手动 ack];[auto:自动 ack]
在异常位置打断点,再次发送消息,程序卡在断点时,可以发现此时消息状态为 unack(未确定状态)
抛出异常后,因为 Spring 会自动返回 nack,所以消息恢复至 Ready 状态,并且没有被 RabbitMQ 删除
22.5.消费失败重试机制
22.5.1.auto 模式中存在的问题
当消费者出现异常后,消息会不断 requeue(重入队)到队列,再重新发送给消费者,然后再次异常,再次requeue,无限循环
从而导致 mq 的消息处理飙升,带来不必要的压力
22.5.2.本地重试
我们可以利用 Spring 的 retry 机制,在消费者出现异常时利用本地重试,而不是无限制的 requeue 到 mq 队列。
修改 consumer
服务的 application.yml
文件,添加内容
spring:
rabbitmq:
listener:
simple:
retry:
enabled: true # 开启消费者失败重试
initial-interval: 1000 # 设置初始的失败等待时长为 1 秒
multiplier: 1 # 失败的等待时长倍数,下次等待时长 = multiplier * last-interval
max-attempts: 3 # 最大重试次数
stateless: true # [true 无状态];[false 有状态]。如果业务中包含事务,这里最好改为 false
重启 consumer
服务,重复之前的测试。
可以发现
- 在重试 3 次后,SpringAMQP 会抛出异常 AmqpRejectAndDontRequeueException,说明本地重试触发了
- 查看 RabbitMQ 控制台,发现消息被删除了,说明最后 SpringAMQP 返回的是 ack,mq 删除消息了
结论
- 开启本地重试时,消息处理过程中抛出异常,不会 requeue 到队列,而是在消费者本地重试
- 重试达到最大次数后,Spring 会返回 ack,消息会被丢弃
22.5.3.失败策略
在之前的测试中,达到最大重试次数后,消息会被丢弃,这是由 Spring 内部机制决定的。
在开启重试模式后,重试次数耗尽。如果消息依然失败,则需要有 MessageRecovery 接口来处理
MessageRecovery 接口包含三种不同的实现
- RejectAndDontRequeueRecoverer:重试耗尽后,直接 reject,丢弃消息。默认就是这种方式
- ImmediateRequeueMessageRecoverer:重试耗尽后,返回 nack,消息重新入队
- RepublishMessageRecoverer:重试耗尽后,将失败消息投递到指定的交换机
比较优雅的一种处理方案是 RepublishMessageRecoverer
- 失败后将消息投递到一个指定的,专门存放异常消息的队列,后续由人工集中处理。
某种意义上算是一种兜底方案
- 在
consumer
服务中定义处理失败消息的交换机、队列
@Bean
public DirectExchange errorMessageExchange(){
return new DirectExchange("error.direct");
}
@Bean
public Queue errorQueue(){
return new Queue("error.queue", true);
}
@Bean
public Binding errorBinding(Queue errorQueue, DirectExchange errorMessageExchange){
return BindingBuilder.bind(errorQueue).to(errorMessageExchange).with("error");
}
- 定义一个 RepublishMessageRecoverer,关联队列和交换机
@Bean
public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
return new RepublishMessageRecoverer(rabbitTemplate, "error.direct", "error");
}
完整代码
consumer
服务下的 src/main/java/cn/itcast/mq/config/ErrorMessageConfig.java
package cn.itcast.mq.config;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.Binding;
import org.springframework.context.annotation.Bean;
import org.springframework.amqp.core.BindingBuilder;
import org.springframework.amqp.core.DirectExchange;
import org.springframework.amqp.rabbit.core.RabbitTemplate;
import org.springframework.context.annotation.Configuration;
import org.springframework.amqp.rabbit.retry.MessageRecoverer;
import org.springframework.amqp.rabbit.retry.RepublishMessageRecoverer;
@Configuration
public class ErrorMessageConfig {
@Bean
public DirectExchange errorMessageExchange(){
return new DirectExchange("error.direct");
}
@Bean
public Queue errorQueue(){
return new Queue("error.queue", true);
}
@Bean
public Binding errorBinding(Queue errorQueue, DirectExchange errorMessageExchange){
return BindingBuilder.bind(errorQueue).to(errorMessageExchange).with("error");
}
@Bean
public MessageRecoverer republishMessageRecoverer(RabbitTemplate rabbitTemplate){
return new RepublishMessageRecoverer(rabbitTemplate, "error.direct", "error");
}
}
22.6.总结
如何确保 RabbitMQ 消息的可靠性?
- 开启生产者确认机制,确保生产者的消息能到达队列
- 开启持久化功能,确保消息未消费前在队列中不会丢失
- 开启消费者确认机制为
auto
,由 spring 确认消息处理成功后完成 ack - 开启消费者失败重试机制,并设置 MessageRecoverer,多次重试失败后将消息投递到异常交换机,交由人工处理
23.死信交换机
23.1.初识死信交换机
23.1.1.什么是死信交换机
什么是死信?
当一个队列中的消息满足下列情况之一时,可以成为 死信(dead letter)
- 消费者使用 basic.reject 或 basic.nack 声明消费失败,并且消息的 requeue 参数设置为 false
- 消息是一个过期消息,超时无人消费
- 要投递的队列消息满了,无法投递
如果这个包含死信的队列配置了 dead-letter-exchange
属性,指定了一个交换机
- 那么队列中的死信就会投递到这个交换机中,而这个交换机称为 死信交换机(Dead Letter Exchange,检查 DLX)。
如图,一个消息被消费者拒绝了,变成了死信
因为 simple.queue 绑定了死信交换机 dl.direct,因此死信会投递给这个交换机
如果这个死信交换机也绑定了一个队列,则消息最终会进入这个存放死信的队列
另外,队列将死信投递给死信交换机时,必须知道两个信息
- 死信交换机名称
- 死信交换机与死信队列绑定的 RoutingKey
这样才能确保投递的消息能到达死信交换机,并且正确的路由到死信队列。
23.1.2.利用死信交换机接收死信
在失败重试策略中,默认的 RejectAndDontRequeueRecoverer 会在本地重试次数耗尽后,
发送 reject 给 RabbitMQ,消息变成死信,被丢弃。
我们可以给 simple.queue 添加一个死信交换机,给死信交换机绑定一个队列。
这样消息变成死信后也不会丢弃,而是最终投递到死信交换机,路由到与死信交换机绑定的队列。
我们在 consumer
服务中,定义一组死信交换机、死信队列
src/main/java/cn/itcast/mq/listener/SpringRabbitListener.java
// 声明普通的 simple.queue 队列,并且为其指定死信交换机:dl.direct
@Bean
public Queue simpleQueue2(){
return QueueBuilder.durable("simple.queue") // 指定队列名称,并持久化
.deadLetterExchange("dl.direct") // 指定死信交换机
.build();
}
// 声明死信交换机 dl.direct
@Bean
public DirectExchange dlExchange(){
return new DirectExchange("dl.direct", true, false);
}
// 声明存储死信的队列 dl.queue
@Bean
public Queue dlQueue(){
return new Queue("dl.queue", true);
}
// 将死信队列 与 死信交换机绑定
@Bean
public Binding dlBinding(){
return BindingBuilder.bind(dlQueue()).to(dlExchange()).with("simple");
}
23.1.3.小结
什么样的消息会成为死信?
- 消息被消费者 reject 或者返回 nack
- 消息超时未消费
- 队列满了
死信交换机的使用场景是什么?
- 如果队列绑定了死信交换机,死信会投递到死信交换机
- 可以利用死信交换机收集所有消费者处理失败的消息(死信),交由人工处理,进一步提高消息队列的可靠性。
23.2.TTL
23.2.1.TTL 简单介绍
TTL(Time-To-Live)
一个队列中的消息如果超时未消费,则会变为死信,超时分为两种情况
- 消息所在的队列设置了超时时间
- 消息本身设置了超时时间
23.2.1.接收超时死信的死信交换机
在 consumer
服务的 SpringRabbitListener 中,定义一个新的消费者,并且声明 死信交换机、死信队列
src/main/java/cn/itcast/mq/listener/SpringRabbitListener.java
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "dl.ttl.queue", durable = "true"),
exchange = @Exchange(name = "dl.ttl.direct"),
key = "ttl"
))
public void listenDlQueue(String msg){
log.info("接收到 dl.ttl.queue 的延迟消息:{}", msg);
}
23.2.2.声明一个队列,并且指定 TTL
要给队列设置超时时间,需要在声明队列时配置 x-message-ttl 属性
注意,这个队列设定了死信交换机为 dl.ttl.direct
气候还需要声明交换机,并且要将 TTL 与交换机绑定
consumer
服务下的 src/main/java/cn/itcast/mq/config/TTLMessageConfig.java
//声明队列
@Bean
public Queue ttlQueue(){
return QueueBuilder.durable("ttl.queue") // 指定队列名称,并持久化
.ttl(10000) // 设置队列的超时时间,10秒
.deadLetterExchange("dl.ttl.direct") // 指定死信交换机
.deadLetterRoutingKey("dl") // 指定死信 RoutingKey
.build();
}
//声明交换机
@Bean
public DirectExchange ttlExchange(){
return new DirectExchange("ttl.direct");
}
//将队列与交换机绑定
@Bean
public Binding ttlBinding(){
return BindingBuilder.bind(ttlQueue()).to(ttlExchange()).with("ttl");
}
发送消息,但是不要指定 TTL
publisher
服务下的 src/test/java/cn/itcast/mq/spring/SpringAmqpTest.java
@Test
public void testTTLQueue() {
// 创建消息
String message = "hello, ttl queue";
// 消息ID,需要封装到 CorrelationData 中
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
// 发送消息
rabbitTemplate.convertAndSend("ttl.direct", "ttl", message, correlationData);
// 记录日志
log.debug("发送消息成功");
}
发送消息的日志
查看下接收消息的日志
队列的 TTL 值是 10000 ms,也就是 10 秒。
观察上面的两个消息日志,可以看出消息发送与接收之间的时差刚好是 10 秒。
23.2.3.发送消息时,设定 TTL
在发送消息时,也可以指定 TTL
@Test
public void testTTLMsg() {
// 创建消息
Message message = MessageBuilder
.withBody("hello, ttl message".getBytes(StandardCharsets.UTF_8))
.setExpiration("5000")
.build();
// 消息 ID,需要封装到 CorrelationData 中
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
// 发送消息
rabbitTemplate.convertAndSend("ttl.direct", "ttl", message, correlationData);
log.debug("发送消息成功");
}
查看发送消息日志
查看接收消息日志
这次,发送与接收的延迟只有 5 秒。
说明当队列、消息都设置了 TTL 时,任意一个到期就会成为死信。
23.2.4.小结
消息超时的两种方式是?
- 给队列设置 TTL 属性,进入队列后超过 TTL 时间的消息变为死信
- 给消息设置 TTL 属性,队列接收到消息超过 TTL 时间后变为死信
- 此外,当上述二者共存时,以时间短的 TTL 为准
如何实现发送一个消息 20 秒后消费者才收到消息?
- 给消息的目标队列指定死信交换机
- 将消费者监听的队列绑定到死信交换机
- 发送消息时给消息设置超时时间为 20 秒
23.3.延迟队列
23.3.1.延迟队列简单介绍
利用TTL结合死信交换机,我们实现了消息发出后,消费者延迟收到消息的效果。
这种消息模式就称为 延迟队列(Delay Queue)模式。
延迟队列的使用场景包括
- 延迟发送短信
- 用户下单,如果用户在 15 分钟内未支付,则自动取消
- 预约工作会议,20 分钟后自动通知所有参会人员
因为延迟队列的需求非常多,所以 RabbitMQ 的官方也推出了一个插件,原生支持延迟队列效果。
这个插件就是 DelayExchange 插件。
参考 RabbitMQ 的插件列表页面:https://www.rabbitmq.com/community-plugins.html
使用方式可以参考官网地址:https://blog.rabbitmq.com/posts/2015/04/scheduling-messages-with-rabbitmq
23.3.2.安装 DelayExchange 插件
官方的安装指南地址为:https://blog.rabbitmq.com/posts/2015/04/scheduling-messages-with-rabbitmq
官方的安装文档是基于 Linux 原生安装 RabbitMQ,然后安装插件。
因为我们之前是基于 Docker 安装 RabbitMQ,所以下面我们会讲解基于 Docker 来安装 RabbitMQ 插件。
RabbitMQ 有一个官方的插件社区,地址为:https://www.rabbitmq.com/community-plugins.html
其中包含各种各样的插件,包括我们要使用的 DelayExchange 插件
诸位可以去对应的 GitHub 页面下载 3.8.9 版本的插件
- 地址:https://github.com/rabbitmq/rabbitmq-delayed-message-exchange/releases/tag/3.8.9 (对应 RabbitMQ 的 3.8.5 以上版本)。
课前资料也提供了下载好的插件
因为我们是基于 Docker 安装,所以需要先查看 RabbitMQ 的插件目录对应的数据卷。
如果诸位不是基于 Docker 安装 RabbitMQ,请参考之前的 22.2.2.RabbitMQ 准备工作 部分,重新创建 Docker 容器。
我们之前设定的 RabbitMQ 的挂载的数据卷名称为 mq-plugins
- 回顾知识:Docker 容器启动的时候,如果要挂载宿主机的一个目录,可以用
-v
参数指定。
所以我们使用下面命令查看数据卷
docker volume inspect mq-plugins
接下来,将插件 rabbitmq_delayed_message_exchange-3.8.9-0199d11c.ez
上传到这个目录即可
我是直接上传到 /root
目录了,故使用下面的命令移动到上述目录中。
mv rabbitmq_delayed_message_exchange-3.8.9-0199d11c.ez /var/lib/docker/volumes/mq-plugins/_data/
最后就是安装了,需要进入 MQ 容器内部来执行安装。我的容器名为 mq
执行下面的命令
docker exec -it mq bash
执行时,请将其中的 -it
后面的 mq
替换为诸位自己的容器名
进入容器内部后,执行下面命令开启插件
rabbitmq-plugins enable rabbitmq_delayed_message_exchange
23.3.3.DelayExchange 原理
DelayExchange 的原理是对官方原生的 Exchange 做了功能的升级
- 将 DelayExchange 接收到的消息暂存在内存中(官方的 Exchange 是无法存储消息的)
- 在 DelayExchange 中计时,超市后才投递消息到队列中
DelayExchange 需要将一个交换机声明为 delayed 类型。
当我们发送消息到 delayExchange 时,流程如下
- 接收消息
- 判断消息是否具备 x-delay 属性
- 如果有 x-delay 属性,说明是延迟消息,持久化到硬盘,读取 x-delay 值,作为延迟时间
- 返回 routing not found 结果给消息发送者
- x-delay 时间到期后,重新投递消息到指定队列
23.3.4.使用 DelayExchange(控制台)
插件的使用非常简单
声明一个交换机,交换机的类型可以是任意类型,只需要设定 delayed 属性为 true ,然后声明队列与其绑定即可。
在 RabbitMQ 管理平台上声明一个 DelayExchange
消息的延迟时间需要在发送消息的时候指定
23.3.5.使用 DelayExchange(SpringAMQP)
DelayExchange 本质上还是官方的三种交换机,只是添加了延迟功能。
因此,使用插件的时候,只需要声明一个交换机,交换机的类型可以是任意类型,然后设定 delayed 属性 为 true 。
最后还需要声明队列与其绑定。
- 声明 DelayExchange 交换机
基于注解方式(推荐)
也可以基于 @Bean
的方式
- 发送消息
23.3.6.延迟队列演示
consumer
服务下的 src/main/java/cn/itcast/mq/listener/SpringRabbitListener.java
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "delay.queue", durable = "true"),
exchange = @Exchange(name = "delay.direct", delayed = "true"),
key = "delay"
))
public void listenDelayExchange(String msg) {
log.info("消费者受到了 delay.queue 的延迟消息");
}
publisher
服务下的 src/test/java/cn/itcast/mq/spring/SpringAmqpTest.java
@Test
public void testSendDelayMessage() throws InterruptedException {
// 1.准备消息
Message message = MessageBuilder
.withBody("Hello, delay message".getBytes(StandardCharsets.UTF_8))
.setDeliveryMode(MessageDeliveryMode.PERSISTENT)
.setHeader("x-delay", 5000)
.build();
// 2.全局唯一的消息 ID,需要封装到 CorrelationData 中
CorrelationData correlationData = new CorrelationData(UUID.randomUUID().toString());
// 3.发送消息
rabbitTemplate.convertAndSend("delay.direct", "delay", message, correlationData);
log.info("发送消息成功!");
}
启动消费者服务后,再进行单元测试
显然,NO_ROUTE
,表明消息没有到达队列,故报错。但是消费者那边又收到了消息(5 秒后)。
因为延迟交换机是先存消息,过一段时间再转发,并不是即时路由到队列。5 秒后就会到达队列。
我们可以根据这个 receivedDelay=5000
来避免触发它的报错功能(加一个判断就可以了)。
//判断是否为延迟消息
if (message.getMessageProperties().getReceivedDelay() > 0) {
//当消息是一个延迟消息时,忽略这个错误提示
return;
}
publisher
服务下的 src/main/java/cn/itcast/mq/config/CommonConfig.java
23.3.7.总结
延迟队列插件的使用步骤包括哪些?
- 声明一个交换机,添加 delayed 属性为 true
- 发送消息时,添加 x-delay 头,值为超时时间
24.惰性队列
24.1.消息堆积问题
当生产者发送消息的速度超过了消费者处理消息的速度,就会导致队列中的消息堆积,直到队列存储消息达到上限。
之后发送的消息就会成为死信,可能会被丢弃,这就是消息堆积问题。
解决消息堆积有三种思路:
- 增加更多消费者,提高消费速度。也就是我们之前说的 work queue 模式
- 在消费者内开启线程池加快消息处理速度
- 扩大队列容积,提高堆积上限
要提升队列容积,把消息保存在内存中显然是不行的。
24.2.惰性队列
从 RabbitMQ 的 3.6.0 版本开始,就增加了 Lazy Queues 的概念,也就是 惰性队列。
惰性队列的特征如下
- 接收到消息后直接存入磁盘而非内存
- 消费者要消费消息时才会从磁盘中读取并加载到内存
- 支持数百万条的消息存储
24.2.1.基于命令行设置 lazy-queue
- 基于命令行设置 lazy-queue
要设置一个队列为惰性队列,只需要在声明队列时,指定 x-queue-mode
属性为 lazy 即可。
可以通过命令行将一个运行中的队列修改为惰性队列
rabbitmqctl set_policy Lazy "^lazy-queue$" '{"queue-mode":"lazy"}' --apply-to queues
命令解读
rabbitmqctl
:RabbitMQ 的命令行工具set_policy
:添加一个策略Lazy
:策略名称,可以自定义"^lazy-queue$"
:用正则表达式匹配队列的名字'{"queue-mode":"lazy"}'
:设置队列模式为 lazy 模式--apply-to queues
:策略的作用对象,是所有的队列
24.2.2.基于 @Bean 声明 lazy-queue
- 基于
@Bean
声明 lazy-queue
24.2.3.基于 @RabbitListener 声明 LazyQueue
- 基于
@RabbitListener
声明 LazyQueue
24.2.4.惰性队列演示
consumer
服务下的 src/main/java/cn/itcast/mq/config/LazyConfig.java
package cn.itcast.mq.config;
import org.springframework.amqp.core.Queue;
import org.springframework.amqp.core.QueueBuilder;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
@Configuration
public class LazyConfig {
@Bean
public Queue lazyQueue() {
return QueueBuilder
.durable("lazy.queue")
.lazy()
.build();
}
@Bean
public Queue normalQueue() {
return QueueBuilder
.durable("normal.queue")
.build();
}
}
consumer
服务下的 src/test/java/cn/itcast/mq/spring/SpringAmqpTest.java
@Test
public void testSendLazyQueue() throws InterruptedException {
for (int i = 0; i < 1000000; i++) {
//准备消息
Message message = MessageBuilder
.withBody("Hello,lazy queue".getBytes(StandardCharsets.UTF_8))
.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT)
.build();
//发送消息
rabbitTemplate.convertAndSend("lazy.queue", message);
}
}
@Test
public void testSendNormalQueue() throws InterruptedException {
for (int i = 0; i < 1000000; i++) {
//准备消息
Message message = MessageBuilder
.withBody("Hello,normal queue".getBytes(StandardCharsets.UTF_8))
.setDeliveryMode(MessageDeliveryMode.NON_PERSISTENT)
.build();
//发送消息
rabbitTemplate.convertAndSend("normal.queue", message);
}
}
24.2.5.小结
消息堆积问题的解决方案?
- 队列上绑定多个消费者,提高消费速度
- 使用惰性队列,可以再 mq 中保存更多消息
惰性队列的优点有哪些?
- 基于磁盘存储,消息上限高
- 没有间歇性的 page-out,性能比较稳定
惰性队列的缺点有哪些?
- 基于磁盘存储,消息时效性会降低
- 性能受限于磁盘的 IO
25.MQ 集群
25.1.基本概念
25.1.1.集群分类
RabbitMQ 的是基于 Erlang 语言编写,而 Erlang 又是一个面向并发的语言,天然支持集群模式。
RabbitMQ 的集群有两种模式
- 普通集群
- 是一种分布式集群,将队列分散到集群的各个节点,从而提高整个集群的并发能力。
- 镜像集群
- 是一种主从集群,普通集群的基础上,添加了主从备份功能,提高集群的数据可用性。
- 镜像集群虽然支持主从,但主从同步并不是强一致的,某些情况下可能有数据丢失的风险。
- 仲裁队列
- 其是在因此在 RabbitMQ 的 3.8 版本以后推出的新功能
- 该功能是用来代替镜像集群的,其底层采用 Raft 协议确保主从的数据一致性。
25.1.2.普通集群
普通集群,或者叫 标准集群(classic cluster),具备下列特征
- 会在集群的各个节点间共享部分数据,包括:交换机、队列元信息。不包含队列中的消息。
- 当访问集群某节点时,如果队列不在该节点,会从数据所在节点传递到当前节点并返回
- 队列所在节点宕机,队列中的消息就会丢失
结构如图
25.1.3.镜像集群
镜像集群:本质是主从模式
其具备下面的特征
- 交换机、队列、队列中的消息会在各个 mq 的镜像节点之间同步备份。
- 创建队列的节点被称为该队列的 主节点,备份到的其它节点叫做该队列的 镜像节点。
- 一个队列的主节点可能是另一个队列的镜像节点
- 所有操作都是主节点完成,然后同步给镜像节点
- 主宕机后,镜像节点会替代成新的主
结构如图
25.1.4.仲裁队列
从 RabbitMQ 3.8 版本开始,引入了新的仲裁队列,他具备与镜像队里类似的功能,但使用更加方便。
仲裁队列:仲裁队列是 3.8 版本以后才有的新功能,用来替代镜像队列
仲裁队列具备下列特征
- 与镜像队列一样,都是主从模式,支持主从数据同步
- 使用非常简单,没有复杂的配置
- 主从同步基于 Raft 协议,强一致
25.2.集群部署
25.2.1.集群分类
在 RabbitMQ 的官方文档中,讲述了两种集群的配置方式
- 普通模式
- 普通模式集群不进行数据同步,每个 MQ 都有自己的队列、数据信息(其它元数据信息如交换机等会同步)。
- 例如我们有 2 个 MQ:mq1、mq2。
- 如果你的消息在 mq1,而你连接到了 mq2,那么 mq2 会去 mq1 拉取消息,然后返回给你。
- 如果 mq1 宕机,在 mq1 中的消息就会丢失。
- 镜像模式
- 与普通模式不同,队列会在各个 mq 的镜像节点之间同步。
- 因此你连接到任何一个镜像节点,均可获取到消息。
- 而且如果一个节点宕机,并不会导致数据丢失。
- 不过,这种方式增加了数据同步的带宽消耗。
我们先来看普通模式集群,我们的计划部署 3 节点的 mq 集群
主机名 | 控制台端口 | amqp 通信端口 |
---|---|---|
mq1 | 8081 —> 15672 | 8071 —> 5672 |
mq2 | 8082 —> 15672 | 8072 —> 5672 |
mq3 | 8083 —> 15672 | 8073 —> 5672 |
集群中的节点标示默认都是:rabbit@[hostname]
因此以上三个节点的名称分别为
- rabbit@mq1
- rabbit@mq2
- rabbit@mq3
25.2.2.获取 cookie
RabbitMQ 底层依赖于 Erlang,而 Erlang 虚拟机就是一个面向分布式的语言,默认就支持集群模式。
集群模式中的每个 RabbitMQ 节点使用 cookie 来确定它们是否被允许相互通信。
要使两个节点能够通信,它们必须具有相同的共享秘密,称为 Erlang cookie。
cookie 只是一串最多 255 个字符的字母数字字符。
每个集群节点必须具有 相同的 cookie。实例之间也需要它来相互通信。
我们先在之前启动的 mq
容器中获取一个 cookie 值,作为集群的 cookie。
执行下面的命令
docker exec -it mq cat /var/lib/rabbitmq/.erlang.cookie
可以看到 cookie 值如下
AGUCVAZKNPTNBIFHDLDH
接下来,停止并删除当前的 mq
容器,我们重新搭建集群。
docker rm -f mq
- 下面两个命令就当是复习吧
- 删除所有未在使用的数据卷:
docker volume prune
- 删除指定数据卷:
docker volume rm 数据卷名称
- 删除所有未在使用的数据卷:
25.2.3.准备集群部署
在 /tmp
目录新建一个配置文件 rabbitmq.conf
cd /tmp
touch rabbitmq.conf
rabbitmq.conf
文件内容如下
loopback_users.guest = false
listeners.tcp.default = 5672
cluster_formation.peer_discovery_backend = rabbit_peer_discovery_classic_config
cluster_formation.classic_config.nodes.1 = rabbit@mq1
cluster_formation.classic_config.nodes.2 = rabbit@mq2
cluster_formation.classic_config.nodes.3 = rabbit@mq3
再创建一个文件,记录 cookie
cd /tmp
touch .erlang.cookie
写入 cookie
echo "AGUCVAZKNPTNBIFHDLDH" > .erlang.cookie
修改 cookie 文件的权限
chmod 600 .erlang.cookie
准备三个目录:mq1
、mq2
、mq3
cd /tmp
mkdir mq1 mq2 mq3
然后拷贝 rabbitmq.conf
、cookie 文件(即 .erlang.cookie
)到 mq1
、mq2
、mq3
cd /tmp
cp rabbitmq.conf mq1
cp rabbitmq.conf mq2
cp rabbitmq.conf mq3
cp .erlang.cookie mq1
cp .erlang.cookie mq2
cp .erlang.cookie mq3
25.2.4.启动集群
创建一个网络
docker network create mq-net
运行命令
docker run -d --net mq-net \
-v ${PWD}/mq1/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-v ${PWD}/.erlang.cookie:/var/lib/rabbitmq/.erlang.cookie \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123456 \
--name mq1 \
--hostname mq1 \
-p 8071:5672 \
-p 8081:15672 \
rabbitmq:3.8-management
docker run -d --net mq-net \
-v ${PWD}/mq2/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-v ${PWD}/.erlang.cookie:/var/lib/rabbitmq/.erlang.cookie \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123456 \
--name mq2 \
--hostname mq2 \
-p 8072:5672 \
-p 8082:15672 \
rabbitmq:3.8-management
docker run -d --net mq-net \
-v ${PWD}/mq3/rabbitmq.conf:/etc/rabbitmq/rabbitmq.conf \
-v ${PWD}/.erlang.cookie:/var/lib/rabbitmq/.erlang.cookie \
-e RABBITMQ_DEFAULT_USER=itcast \
-e RABBITMQ_DEFAULT_PASS=123456 \
--name mq3 \
--hostname mq3 \
-p 8073:5672 \
-p 8083:15672 \
rabbitmq:3.8-management
此后,访问 虚拟机IP:端口号
,都可以成功进入 RabbitMQ 控制台
25.2.5.测试数据共享
- 在
mq1
中新建一个队列
- 创建完毕
- 发现三个节点都可以看到创建的队列(因为普通集群中的队列的元信息是互通的嘛)
- 在
mq1
中的simple.queue
中尝试发送消息
- 发现
mq2
中有数据,在mq2
中尝试获取消息
mq3
同理,此处就不贴图了。
25.2.6.测试可用性
关闭 mq1
docker stop mq1
发现 mq2
、mq3
控制台上的 simple.queue
也不可用了
要想 simple.queue
重新使用,就必须重启 mq1
docker start mq1
重启后发现 mq1
和 mq2
控制台上显示的 simple.queue
又可用了。
因为发送消息的时候设置了 Durable 属性,故 mq1
重启后,仍可以在其他节点中获取消息 (懒得贴图了)
25.3.镜像集群部署
在普通集群部署的案例中,一旦创建队列的主机宕机,队列就会不可用。不具备高可用能力。
如果要解决这个问题,必须使用官方提供的镜像集群方案。
25.3.1.镜像模式的特征
默认情况下,队列只保存在创建该队列的节点上。
而镜像模式下,创建队列的节点被称为该队列的主节点,队列还会拷贝到集群中的其它节点,也叫做该队列的镜像节点。
但是,不同队列可以在集群中的任意节点上创建,因此不同队列的主节点可以不同。
甚至是,一个队列的主节点可能是另一个队列的镜像节点。
用户发送给队列的一切请求,例如发送消息、消息回执默认都会在主节点完成,如果是从节点接收到请求,也会路由到主节点去完成。
镜像节点仅仅起到备份数据作用。
当主节点接收到消费者的 ACK 时,所有镜像都会删除节点中的数据。
总结
- 镜像队列结构是一主多从(从就是镜像)
- 所有操作都是主节点完成,然后同步给镜像节点
- 主宕机后,镜像节点会替代成新的主(如果在主从同步完成前,主就已经宕机,可能出现数据丢失)
- 不具备负载均衡功能,因为所有操作都会有主节点完成(但是不同队列,其主节点可以不同,可以利用这个提高吞吐量)
25.3.2.镜像模式的配置
镜像模式的配置有 3 种模式
ha-mode | ha-params | 效果 |
---|---|---|
准确模式 exactly | 队列的副本量 count | 集群中队列副本(主服务器和镜像服务器之和)的数量。 count 如果为 1 意味着单个副本:即队列主节点。 count 值为 2 表示 2 个副本:1 个队列主和 1 个队列镜像。 换句话说: count = 镜像数量 + 1 。如果群集中的节点数少于 count,则该队列将镜像到所有节点。 如果有集群总数大于 count + 1,并且包含镜像的节点出现故障,则将在另一个节点上创建一个新的镜像。 |
all | (none) | 队列在群集中的所有节点之间进行镜像。 队列将镜像到任何新加入的节点。 镜像到所有节点将对所有群集节点施加额外的压力(包括网络 I / O,磁盘 I / O 和磁盘空间使用情况)。 推荐使用 exactly,设置副本数为(N / 2 +1)。 |
nodes | node names | 指定队列创建到哪些节点。 如果指定的节点全部不存在,则会出现异常。 如果指定的节点在集群中存在,但是暂时不可用,会创建节点到当前客户端连接到的节点。 |
这里我们以 rabbitmqctl
命令作为案例来讲解配置语法。
rabbitmqctl set_policy ha-two "^two\." '{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"automatic"}'
rabbitmqctl set_policy
:固定写法ha-two
:策略名称,自定义"^two\."
:匹配队列的正则表达式,符合命名规则的队列才生效,这里是任何以two.
开头的队列名称'{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"automatic"}'
: 策略内容"ha-mode":"exactly"
:策略模式,此处是 exactly 模式,指定副本数量"ha-params":2
:策略参数,这里是 2,就是副本数量为 2,1 主 1 镜像"ha-sync-mode":"automatic"
:同步策略- 默认是 manual,即新加入的镜像节点不会同步旧的消息。
- 如果设置为 automatic,则新加入的镜像节点会把主节点中所有消息都同步,会带来额外的网络开销
rabbitmqctl set_policy ha-all "^all\." '{"ha-mode":"all"}'
ha-all
:策略名称,自定义"^all\."
:匹配所有以all.
开头的队列名'{"ha-mode":"all"}'
:策略内容"ha-mode":"all"
:策略模式,此处是 all 模式,即所有节点都会称为镜像节点
rabbitmqctl set_policy ha-nodes "^nodes\." '{"ha-mode":"nodes","ha-params":["rabbit@nodeA", "rabbit@nodeB"]}'
rabbitmqctl set_policy
:固定写法ha-nodes
:策略名称,自定义"^nodes\."
:匹配队列的正则表达式,符合命名规则的队列才生效,这里是任何以nodes.
开头的队列名称'{"ha-mode":"nodes","ha-params":["rabbit@nodeA", "rabbit@nodeB"]}'
: 策略内容"ha-mode":"nodes"
:策略模式,此处是 nodes 模式"ha-params":["rabbit@mq1", "rabbit@mq2"]
:策略参数,这里指定副本所在节点名称
25.3.3.测试数据共享
我们使用 exactly 模式的镜像,因为集群节点数量为 3,因此镜像数量就设置为 2
运行下面的命令
docker exec -it mq1 bash
rabbitmqctl set_policy ha-two "^two\." '{"ha-mode":"exactly","ha-params":2,"ha-sync-mode":"automatic"}'
下面,创建一个新的队列
在任意一个 mq
控制台查看队列
25.3.4.测试高可用
现在,我们让 two.queue
的主节点 mq1
宕机
docker stop mq1
查看集群状态
查看队列状态
发现依然是健康的!并且其主节点切换到了 rabbit@mq2
上
25.4.仲裁队列部署
从 RabbitMQ 3.8 版本开始,引入了新的仲裁队列,他具备与镜像队里类似的功能,但使用更加方便。
25.4.1.添加仲裁队列(控制台)
在任意控制台添加一个队列,一定要选择队列类型为 Quorum 类型。
在任意控制台查看队列
可以看到,仲裁队列的 + 2
的字样。代表这个队列有 2 个镜像节点。
因为仲裁队列默认的镜像数为 5。
如果你的集群有 7 个节点,那么镜像数肯定是 5;而我们集群只有 3 个节点,因此镜像数量就是3.
之后对其测试数据共享、测试高可用性,与镜像模式下的集群无异。此处不再赘述。
25.4.2.Java 代码创建仲裁队列
@Bean
public Queue quorumQueue() {
return QueueBuilder
.durable("quorum.queue") // 持久化
.quorum() // 仲裁队列
.build();
}
25.4.3.SpringAMQP 连接 MQ 集群(配置文件)
spring:
rabbitmq:
addresses: 192.168.150.105:8071, 192.168.150.105:8072, 192.168.150.105:8073
username: itcast
password: 123456
virtual-host: /