SpringCloud学习笔记（四）RabbitMQ
一、同步通讯的优缺点
- 时效性较强，可以立即得到结果
- 但是耦合度高，性能和吞吐能力下降
- 有额外的资源消耗
二、异步通讯的优缺点
- 耦合度低，吞吐量提升
- 故障隔离，流量削峰
- 依赖于Broker的可靠性、安全性和吞吐能力
三、什么是MQ
- MQ（MessageQueue），指消息队列，也就是事件驱动架构中的Broker
- 常见的有RabbitMQ、ActiveMQ、RocketMQ、Kafka等
四、RabbitMQ入门
- 架构如下
- 常见概念如下
- channel：信道，操作MQ的工具
- exchange：交换器，路由消息到队列中
- queue：队列，缓存消息
- virtual host：虚拟主机，对queue、exchange等资源进行逻辑分组
- Publisher：生产者，生产消息的服务，将消息发送到queue中
- Consumer：消费者，消费消息的服务，监听queue，拉取消息
五、常见消息模型
- 基本消息队列（BaseQueue）
- 工作消息队列（WorkQueue）
- 发布订阅（Publish、Subscribe）
- Fanout Exchange：广播
- Direct Exchange：路由
- Topic Exchange：主题
- Fanout Exchange：广播
六、简单队列模型（一对一）
- 三个基本角色
- publisher：消息发布者，将消息发送到队列queue中
- queue：消息队列，负责接受并缓存消息
- consumer：订阅队列，处理队列中的消息
- 消息发送流程：
- 建立connection
- 创建channel
- 利用channel声明队列
- 利用channel向队列发送消息
- 消息接收流程：
- 建立connection
- 创建channel
- 利用channel声明队列
- 定义consumer的消费行为handleDelivery()
- 利用channel将消费者与队列绑定
- 代码如下
//Publisher
public void testSendMessage() throws IOException, TimeoutException {
// 1.建立连接
ConnectionFactory factory = new ConnectionFactory();
// 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
factory.setHost("192.168.150.101");
factory.setPort(5672);
factory.setVirtualHost("/");
factory.setUsername("itcast");
factory.setPassword("123321");
// 1.2.建立连接
Connection connection = factory.newConnection();
// 2.创建通道Channel
Channel channel = connection.createChannel();
// 3.创建队列
String queueName = "simple.queue";
channel.queueDeclare(queueName, false, false, false, null);
// 4.发送消息
String message = "hello, rabbitmq!";
channel.basicPublish("", queueName, null, message.getBytes());
System.out.println("发送消息成功：【" + message + "】");
// 5.关闭通道和连接
channel.close();
connection.close();
}
//Consumer
public static void main(String[] args) throws IOException, TimeoutException {
// 1.建立连接
ConnectionFactory factory = new ConnectionFactory();
// 1.1.设置连接参数，分别是：主机名、端口号、vhost、用户名、密码
factory.setHost("192.168.124.150");
factory.setPort(5672);
factory.setVirtualHost("/");
factory.setUsername("itcast");
factory.setPassword("123321");
// 1.2.建立连接
Connection connection = factory.newConnection();
// 2.创建通道Channel
Channel channel = connection.createChannel();
// 3.创建队列
String queueName = "simple.queue";
channel.queueDeclare(queueName, false, false, false, null);
// 4.订阅消息
channel.basicConsume(queueName, true, new DefaultConsumer(channel){
@Override
public void handleDelivery(String consumerTag, Envelope envelope,
AMQP.BasicProperties properties, byte[] body) throws IOException {
// 5.处理消息
String message = new String(body);
System.out.println("接收到消息：【" + message + "】");
}
});
System.out.println("等待接收消息。。。。");
}
七、什么是SpringAMQP
- AMQP：是用于在应用程序或之间传递业务消息的开发标准，该协议与语言与平台无关，更符合微服务中独立性的要求
- SpringAMQP：是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息
八、使用SpringAMQP的简单步骤
- 引入AMQP依赖
<dependency>
<groupId>org.springframework.bootgroupId>
<artifactId>spring-boot-starter-amqpartifactId>
dependency>
- publisher修改配置文件，并向Simple.queue队列中发送消息
spring:
rabbitmq:
host: 192.168.150.101 # rabbitMQ的ip地址
port: 5672 # 端口
username: itcast
password: 123321
virtual-host: /
@Autowired
private RabbitTemplate rabbitTemplate;
@Test
public void testSendMessage2SimpleQueue() {
String queueName = "simple.queue";
String message = "hello, spring amqp!";
rabbitTemplate.convertAndSend(queueName, message);
}
- consumer修改配置文件，并绑定simple.queue队列消费消息
spring:
rabbitmq:
host: 192.168.150.101 # rabbitMQ的ip地址
port: 5672 # 端口
username: itcast
password: 123321
virtual-host: /
//定义的类记得加注解
@Component
public class SpringRabbitListener {
//方法需要加RabbitListener注解
@RabbitListener(queues = "simple.queue")
public void listenSimpleQueue(String msg) {
System.out.println("消费者接收到simple.queue的消息：【" + msg + "】");
}
}
- 注意：消息一旦消费就会从队列中删除，RabbitMQ没有消息回溯功能
九、Work Queue
- 多个消费者绑定到一个队列，同一条消息只会被一个消费者处理
- 结构如下
- 使用如下：
//Publisher
public void testSendMessage2WorkQueue() throws InterruptedException {
String queueName = "simple.queue";
String message = "hello, message__";
for (int i = 1; i <= 50; i++) {
rabbitTemplate.convertAndSend(queueName, message + i);
Thread.sleep(20);
}
}
//Consumer
@RabbitListener(queues = "simple.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
System.out.println("消费者1接收到消息：【" + msg + "】" + LocalTime.now());
Thread.sleep(20);
}
@RabbitListener(queues = "simple.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
System.err.println("消费者2........接收到消息：【" + msg + "】" + LocalTime.now());
Thread.sleep(200);
}
- 如果没有设置消息预取，消息就会被两个消费者平分；可以通过设置preFetch控制预取消息的上限
spring:
rabbitmq:
host: 192.168.150.101 # rabbitMQ的ip地址
port: 5672 # 端口
username: itcast
password: 123321
virtual-host: /
listener:
simple:
prefetch: 1
十、发布订阅模式
- 发布订阅模式允许将同一消息发送给多个消费者
- 注意：exchange（交换机）负责消息路由，而不是存储，路由失败则消息丢失
- 结构如下
十一、Fanout Exchange
- Fanout Exchange会将接收到的消息路由到每一个跟其绑定的queue
- 使用案例：
Publisher
//Publisher
public void testSendFanoutExchange() {
// 交换机名称
String exchangeName = "itcast.fanout";
// 消息
String message = "hello, every one!";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName, "", message);
}
消费者可以用两种办法
// 其一：设置配置类
@Configuration
public class FanoutConfig {
@Bean
public FanoutExchange fanoutExchange(){
return new FanoutExchange("itcast.fanout");
}
// fanout.queue1
@Bean
public Queue fanoutQueue1(){
return new Queue("fanout.queue1");
}
// 绑定队列1到交换机
@Bean
public Binding fanoutBinding1(Queue fanoutQueue1, FanoutExchange fanoutExchange){
return BindingBuilder
.bind(fanoutQueue1)
.to(fanoutExchange);
}
// fanout.queue2
@Bean
public Queue fanoutQueue2(){
return new Queue("fanout.queue2");
}
// 绑定队列2到交换机
@Bean
public Binding fanoutBinding2(Queue fanoutQueue2, FanoutExchange fanoutExchange){
return BindingBuilder
.bind(fanoutQueue2)
.to(fanoutExchange);
}
@Bean
public Queue objectQueue(){
return new Queue("object.queue");
}
}
//其二：直接监听
@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
System.out.println("消费者接收到fanout.queue1的消息：【" + msg + "】");
}
@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
System.out.println("消费者接收到fanout.queue2的消息：【" + msg + "】");
}
十二、DirectExchange
- 路由模式，该交换器会将消息根据路由规则发送到指定的Queue中
- 每一个Queue都与Exchange设置一个BindingKey，以便匹配
- 使用案例如下：
Publisher
public void testSendDirectExchange() {
// 交换机名称
String exchangeName = "itcast.direct";
// 消息
String message = "hello, red!";
// 发送消息，red就是指定的BindingKey，可以改成其他的
rabbitTemplate.convertAndSend(exchangeName, "red", message);
}
Consumer
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1"),
exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
key = {"red", "blue"}
))
public void listenDirectQueue1(String msg){
System.out.println("消费者接收到direct.queue1的消息：【" + msg + "】");
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "itcast.direct", type = ExchangeTypes.DIRECT),
key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg){
System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}
十三、TopicExchange
- TopicExchange与Directchange类似，区别在于routinKey必须是多个单词的列表，并且以 . 分割
- 使用案例如下：
Publisher
public void testSendTopicExchange() {
// 交换机名称
String exchangeName = "itcast.topic";
// 消息
String message = "今天天气不错，我的心情好极了!";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName, "china.weather", message);
}
Consumer
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue1"),
exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
key = "china.#"
))
public void listenTopicQueue1(String msg){
System.out.println("消费者接收到topic.queue1的消息：【" + msg + "】");
}
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue2"),
exchange = @Exchange(name = "itcast.topic", type = ExchangeTypes.TOPIC),
key = "#.news"
))
public void listenTopicQueue2(String msg){
System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}
十四、消息转换器
- SpinrgAMQP发送和接收消息不仅仅是字符串，还可以是其他对象，发送过程会将对象序列化后进行发送
- 可以将发送的消息进行JSON方式序列化，消息会更简短易读
- 使用步骤：
在publisher和consumer服务中都引入依赖
<dependency>
<groupId>com.fasterxml.jackson.coregroupId>
<artifactId>jackson-databindartifactId>
dependency>
在publisher和consumer服务的启动程序中声明MessageConverter，声明后底层就会自动将消息进行JSON序列化
@Bean
public MessageConverter messageConverter(){
return new Jackson2JsonMessageConverter();
}
然后consumer正常接受消息
- SpringAMQP中消息的序列化和反序列化是如何实现的？
- 利用MessageConverter实现的，默认是JDK的序列化
- 注意发送方和接收方必须使用相同的MessageConverter
十五、消息堆积问题
- 当生产者发送消费的速度超过了消费者处理消息的速度，就会导致队列中的消息堆积，知道队列存储达到上限
- 解决有三种思路：
- 增加更多消费者，提高消费速度
- 在消费者内开启线程池加快消息处理速度
- 扩大队列容积，提高堆积上限
十六、惰性队列
- 从RabbitMQ的3.6.0版本后就有了
- 特征如下：
- 接收到消息后直接存入磁盘而非内存
- 消费者要消费消息时才会从磁盘中读取并加载到内存
- 支持数百万条的消息存储
- 优点在于性能稳定，消息上限高
- 缺点在于消息时效性降低，受限于磁盘IO
- 开启惰性队列有两种方式
- @ Bean的方式
- 注解方式：
- @ Bean的方式
十七、消息应答
- 消息应答就是：消费者在接收到消息并且处理该消息之后，告诉RabbitMQ它已经处理了，RabbitMQ可以把该消息删除了
- 自动应答：即消息发送后立即被认为已经传送成功，仅适用于消费者可以高效处理这些信息的情况下使用
- 手动应答：使用方法通知RabbitMQ该消息成功处理
- Channel.basicAck（用于肯定确认）：成功处理该消息，可以丢弃了
- Channel.basicNack（用于否定确认）：不处理该消息直接拒绝，可以丢弃了
- Channel.basicReject（用于否定确认）：和basicNack相比少了一个批处理的参数
- 消息自动重新入队：若消费者由于某些原因失去连接，导致消息未发送ACK确认，RabbitMQ将了解到消息未完全处理，并将其重新排队，若此时存在其他消费者，将会重新分发给另一个消费者
十八、使用消息手动应答
- 默认消息采用的是自动应答，所以需要将其关闭
//basicConsume的第二个参数就是关闭自动应答
channel.basicConsume(TASK_QUEUE_NAME,false,deliverCallback,consumerTag->());
- 手动应答
//consumer的核心代码
Channel channel=RabbitUtils.getChannel();
channel.queueDeclare(TASK_QUEUE_NAME,false,false,false,null);
DeliverCallback deliverCallback=(consumerTag,delivery)->{
String message=new String(delivery.getBody(),"UTF-8");
//第一个参数指消息标记Tag
//第二个参数指是否批量应答消息，false指只应答当前传递的消息
channel.basicAck(delivery.getEnvelope().getDeliveryTag(),false);
}
//basicConsume的第二个参数就是关闭自动应答
channel.basicConsume(TASK_QUEUE_NAME,false,deliverCallback,consumerTag->());
十九、RabbitMQ持久化
- 队列持久化：一般的队列在RabbitMQ重启后就会被删除，若想重启后队列依然存在，就需要在声明队列时把durable参数设置为持久化
//消费者将通道和队列绑定时将第二个参数设置为true
//参数依次为Queue名称、是否持久化、是否排外（加锁）、是否自动删除该队列、设置队列的其他一些参数
channel.queueDeclare(ACK_QUEUE_NAME,true,false,false,null);
- 注意：若想将一个正在运行的未持久化队列修改为持久化，需要将该队列先删除掉，然后重新创建一个持久化队列，否则会报错
- 消息持久化：即使设置了队列持久化，但当RabbitMQ重启时，里面的消息依然会丢失，因此需要将消息也设置为持久化才不会消息
- 原理就是高速RabbitMQ将消息保存到磁盘中，而不是内存中，代码实现如下
//生产者添加MessageProperties.PERSISTENT_TEXT_PLAIN参数
//参数依次为Exchange名称、Queue名称（或者说路由地址）、消息的配置属性（通常为null）、消息实体
channel.basicPublish("",TASK_QUEUE_NAME,MessageProperties.PERSISTENT_TEXT_PLAIN,message.getBytes("UTF-8"));
二十、发布确认
- 当信道被设置为confirm模式时，所有在该信道上发布的消息都将会被指派一个唯一的ID（从1开始），一旦消息成功投递到所有匹配的队列后，broker会发送一个确认给生产者（包含消息的唯一ID），这就是发布确认
- 开启发布确认的方法
//在创建channel后，调用confirmSelect方法即可
Channel channel=connection.createChannel();
channel.confirmSelect();
- 单个确认发布：即发布一个消息后只有被确认发布后才会发第二个消息
//核心代码
//即调用waitForConfirms等待发布的确认
for(...){
channel.basicPublish("",queueName,null,message.getBytes());
boolean flag=channel.waitForConfirms();
if(flag){
//TODO 其他业务
}
}
- 批量发布确认：等发布一批消息后再确认，其实就是加个条件判断，不要确认地这么频繁
//核心代码
for(...){
channel.basicPublish("",queueName,null,message.getBytes());
count++;
if(count%10==0){
channel.waitForConfirms();
//TODO 其他业务
}
}
- 异步确认发布：通过中间件的函数回调来判断是否投递成功，发布者只管发布
//发布者模块的核心代码
//消息确认成功 回调函数
//两个参数分别表示消息的标记和是否为批量确认
ConfirmCallback ackCallback=(deliveryTag,multiple)->{
System.out.println("确认的消息："+deliveryTag);
};
//消息确认失败 回调函数
ConfirmCallback nackCallback=(deliveryTag,multiple)->{
System.out.println("未确认的消息："+deliveryTag);
//TODO 其他业务
};
//准备消息的监听器，监听哪些消息成功或失败
channel.addConfirmListener(ackCallback,nackCallback);
//批量发送消息
for(...){
channel.basicPublish("",queueName,null,message.getBytes());
}
参考
- B站黑马2021SpringCloud课程：https://www.bilibili.com/video/BV1LQ4y127n4
- B站尚硅谷RabbitMQ教程：https://www.bilibili.com/video/BV1cb4y1o7zz