RabbitMQ官网:https://www.rabbitmq.com

参考视频:黑马程序员RabbitMQ入门到实战教程,MQ消息中间件,微服务rabbitmq消息队列实战,RabbitMQ面试题一套全覆盖

0. 写在前面

微服务一旦拆分,必然涉及到服务之间的相互调用,目前我们服务之间调用采用的都是基于 OpenFeign 的调用。这种调用中,调用者发起请求后需要等待服务提供者执行业务返回结果后,才能继续执行后面的业务。也就是说调用者在调用过程中处于阻塞状态,因此我们成这种调用方式为同步调用,也可以叫同步通讯。但在很多场景下,我们可能需要采用异步通讯的方式,为什么呢?

我们先来看看什么是同步通讯和异步通讯。如图:

同步通讯和异步通讯

解读:

  • 同步通讯:就如同打视频电话,双方的交互都是实时的。因此同一时刻你只能跟一个人打视频电话。
  • 异步通讯:就如同发微信聊天,双方的交互不是实时的,你不需要立刻给对方回应。因此你可以多线操作,同时跟多人聊天。

两种方式各有优劣,打电话可以立即得到响应,但是你却不能跟多个人同时通话。发微信可以同时与多个人收发微信,但是往往响应会有延迟。

所以,如果我们的业务需要实时得到服务提供方的响应,则应该选择同步通讯(同步调用)。而如果我们追求更高的效率,并且不需要实时响应,则应该选择异步通讯(异步调用)。

OpenFeign 调用就是同步调用的方式。但是:

  • 异步调用又该如何实现?
  • 哪些业务适合用异步调用来实现呢?

通过今天的学习你就能明白这些问题了。

1. 初识MQ

1.1 同步调用

我们基于 OpenFeign 的调用都属于是同步调用,那么这种方式存在哪些问题呢?

举个例子,以余额支付功能为例来分析,首先看下整个流程:

余额支付功能流程

目前我们采用的是基于 OpenFeign 的同步调用,也就是说业务执行流程是这样的:

  1. 支付服务需要先调用用户服务完成余额扣减
  2. 然后支付服务自己要更新支付流水单的状态
  3. 然后支付服务调用交易服务,更新业务订单状态为已支付

这其中就存在3个问题:

拓展性差

我们目前的业务相对简单,但是随着业务规模扩大,产品的功能也在不断完善。

在大多数电商业务中,用户支付成功后都会以短信或者其它方式通知用户,告知支付成功。假如后期产品经理提出这样新的需求,你怎么办?是不是要在上述业务中再加入通知用户的业务?

某些电商项目中,还会有积分或金币的概念。假如产品经理提出需求,用户支付成功后,给用户以积分奖励或者返还金币,你怎么办?是不是要在上述业务中再加入积分业务、返还金币业务?

最终你的支付业务会越来越臃肿:

支付业务

也就是说每次有新的需求,现有支付逻辑都要跟着变化,代码经常变动,不符合开闭原则,拓展性不好。

性能下降

由于我们采用了同步调用,调用者需要等待服务提供者执行完返回结果后,才能继续向下执行,也就是说每次远程调用,调用者都是阻塞等待状态。最终整个业务的响应时长就是每次远程调用的执行时长之和:

执行时长

假如每个微服务的执行时长都是 50ms,则最终整个业务的耗时可能高达 300ms,性能太差了。

级联失败

由于我们是基于 OpenFeign 调用交易服务、通知服务。当交易服务、通知服务出现故障时,整个事务都会回滚,交易失败。

这其实就是同步调用的级联失败问题。

但是大家思考一下,我们假设用户余额充足,扣款已经成功,此时我们应该确保支付流水单更新为已支付,确保交易成功。毕竟收到手里的钱没道理再退回去吧。😬

因此,这里不能因为短信通知、更新订单状态失败而回滚整个事务。

总结

综上,同步调用的方式存在下列问题:

  • 拓展性差
  • 性能下降
  • 级联失败

而要解决这些问题,我们就必须用异步调用的方式来代替同步调用

1.2 异步调用

异步调用方式其实就是基于消息通知的方式,一般包含三个角色:

  • 消息发送者:投递消息的人,就是原来的调用方
  • 消息 Broker:管理、暂存、转发消息,你可以把它理解成微信服务器
  • 消息接收者:接收和处理消息的人,就是原来的服务提供方

异步调用三角色

在异步调用中,发送者不再直接同步调用接收者的业务接口,而是发送一条消息投递给消息Broker。然后接收者根据自己的需求从消息 Broker 那里订阅消息。每当发送方发送消息后,接受者都能获取消息并处理。

这样,发送消息的人和接收消息的人就完全解耦了。

还是以余额支付业务为例:

余额支付业务

除了扣减余额、更新支付流水单状态以外,其它调用逻辑全部取消。而是改为发送一条消息到 Broker。而相关的微服务都可以订阅消息通知,一旦消息到达 Broker,则会分发给每一个订阅了的微服务,处理各自的业务。

假如产品经理提出了新的需求,比如要在支付成功后更新用户积分。支付代码完全不用变更,而仅仅是让积分服务也订阅消息即可:

增加更新用户积分

不管后期增加了多少消息订阅者,作为支付服务来讲,执行问扣减余额、更新支付流水状态后,发送消息即可。业务耗时仅仅是这三部分业务耗时,仅仅 100ms,大大提高了业务性能。

另外,不管是交易服务、通知服务,还是积分服务,他们的业务与支付关联度低。现在采用了异步调用,解除了耦合,他们即便执行过程中出现了故障,也不会影响到支付服务。

总结

综上,异步调用的优势包括

  • 耦合度更低
  • 性能更好
  • 业务拓展性强
  • 故障隔离,避免级联失败

当然,异步通信也并非完美无缺,它存在下列缺点:

  • 完全依赖于 Broker 的可靠性、安全性和性能
  • 架构复杂,后期维护和调试麻烦

1.3 技术选型

消息 Broker,目前常见的实现方案就是消息队列(MessageQueue),简称为 MQ。

目比较常见的 MQ 实现对比:

RabbitMQ ActiveMQ RocketMQ Kafka
公司/社区 Rabbit Apache 阿里 Apache
开发语言 Erlang Java Java Scala&Java
协议支持 AMQP,XMPP,SMTP,STOMP OpenWire,STOMP,REST,XMPP,AMQP 自定义协议 自定义协议
可用性 一般
单机吞吐量 一般 非常高
消息延迟 微秒级 毫秒级 毫秒级 毫秒以内
消息可靠性 一般 一般

追求可用性:Kafka、 RocketMQ 、RabbitMQ

追求可靠性:RabbitMQ、RocketMQ

追求吞吐能力:RocketMQ、Kafka

追求消息低延迟:RabbitMQ、Kafka

据统计,目前国内消息队列使用最多的还是 RabbitMQ,其各方面都比较均衡,稳定性也好。

2. RabbitMQ

RabbitMQ 是基于 Erlang 语言开发的开源消息通信中间件,官网地址:https://www.rabbitmq.com

2.1 安装

我们基于 Docker 来安装 RabbitMQ,使用下面的命令即可:

1、拉取镜像

1
docker pull rabbitmq:3.8-management

2、创建并运行容器

1
2
3
4
5
6
7
8
9
10
11
docker run \
-e RABBITMQ_DEFAULT_USER=muyoukule \
-e RABBITMQ_DEFAULT_PASS=123456 \
-v mq-plugins:/plugins \
--name mq \
--hostname mq \
-p 15672:15672 \
-p 5672:5672 \
--network hmall \
-d \
rabbitmq:3.8-management

可以看到在安装命令中有两个映射的端口:

  • 15672:RabbitMQ 提供的管理控制台的端口
  • 5672:RabbitMQ 的消息发送处理接口

安装完成后,我们访问 http://YourIp:15672/ 即可看到管理控制台。首次访问需要登录,默认的用户名和密码在配置文件中已经指定了。

登录后即可看到管理控制台总览页面:

RabbitMQ管理控制台总览页面

RabbitMQ 对应的架构如图:
RabbitMQ架构如图

其中包含几个概念:

  • publisher:生产者,也就是发送消息的一方
  • consumer:消费者,也就是消费消息的一方
  • queue:队列,存储消息。生产者投递的消息会暂存在消息队列中,等待消费者处理
  • exchange:交换机,负责消息路由。生产者发送的消息由交换机决定投递到哪个队列。
  • virtual host:虚拟主机,起到数据隔离的作用。每个虚拟主机相互独立,有各自的exchange、queue

上述这些东西都可以在 RabbitMQ 的管理控制台来管理,下一节我们就一起来学习控制台的使用。

2.2 收发消息

2.2.1 交换机

我们打开 Exchanges 选项卡,可以看到已经存在很多交换机:

RabbitMQ默认交换机

我们点击任意交换机,即可进入交换机详情页面。仍然会利用控制台中的 publish message 发送一条消息:

RabbitMQ交换机详情页面
RabbitMQ控制台发送消息

点击后会提示Message published, but not routed.这里是由控制台模拟了生产者发送的消息。由于没有消费者存在,最终消息丢失了,这样说明交换机没有存储消息的能力。

2.2.2 队列

我们打开 Queues 选项卡,新建一个队列:
RabbitMQ新建队列

命名为 hello.queue1

命名队列为hello.queue1

再以相同的方式,创建一个队列,命名为 hello.queue2,最终队列列表如下:

命名队列为hello.queue2

此时,我们再次向 amq.fanout 交换机发送一条消息。会发现消息依然没有到达队列!!

怎么回事呢?

发送到交换机的消息,只会路由到与其绑定的队列,因此仅仅创建队列是不够的,我们还需要将其与交换机绑定。

2.2.3 绑定关系

点击 Exchanges 选项卡,点击 amq.fanout 交换机,进入交换机详情页,然后点击Bindings菜单,在表单中填写要绑定的队列名称:

填写要绑定的队列名称

相同的方式,将 hello.queue2 也绑定到改交换机。

最终,绑定结果如下:

交换机绑定结果

2.2.4 发送消息

再次回到 Exchange 页面,找到刚刚绑定的 amq.fanout,点击进入详情页,再次发送一条消息:

填写要绑定的队列名称

回到 Queues 页面,可以发现 hello.queue 中已经有一条消息了:

hello.queue中已有一条消息

点击队列名称,进入详情页,查看队列详情,这次我们点击 Get message

点击getmessage

可以看到消息到达队列了:

消息到达队列

这个时候如果有消费者监听了 MQ 的 hello.queue1hello.queue2 队列,自然就能接收到消息了。

总结

  • 交换机负责路由和转发消息,没有存储消息的能力

  • 一旦队列与交换机绑定,每个队列都可以收到信息

2.3 数据隔离

2.3.1 用户管理

点击 Admin 选项卡,首先会看到 RabbitMQ 控制台的用户管理界面:

RabbitMQ控制台用户管理界面

这里的用户都是 RabbitMQ 的管理或运维人员。目前只有安装 RabbitMQ 时添加的 muyoukule 这个用户。仔细观察用户表格中的字段,如下:

  • Namemuyoukule,也就是用户名
  • Tagsadministrator,说明 muyoukule 用户是超级管理员,拥有所有权限
  • Can access virtual host/,可以访问的virtual host,这里的 / 是默认的 virtual host

对于小型企业而言,出于成本考虑,我们通常只会搭建一套 MQ 集群,公司内的多个不同项目同时使用。这个时候为了避免互相干扰,我们会利用 virtual host 的隔离特性,将不同项目隔离。一般会做两件事情:

  • 给每个项目创建独立的运维账号,将管理权限分离。
  • 给每个项目创建不同的 virtual host ,将每个项目的数据隔离。

比如,我们给黑马商城创建一个新的用户,命名为 hmall ,密码为 123

创建新用户hmall

你会发现此时 hmall 用户没有任何 virtual host 的访问权限:hmall无访问权限

别急,接下来我们就来授权。

2.3.2 virtual host

我们先退出登录:

退出登录

切换到刚刚创建的 hmall 用户登录,然后点击 Virtual Hosts 菜单,进入 virtual host 管理页:

进入virtual host管理页

可以看到目前只有一个默认的 virtual host,名字为 /

我们可以给黑马商城项目创建一个单独的 virtual host,而不是使用默认的/PS:注意 hmall 前面有个 /

创建单独的virtual host

创建完成后如图:

创建单独的virtual host完成

由于我们是登录 hmall 账户后创建的 virtual host,因此回到 users 菜单,你会发现当前用户已经具备了对 /hmall 这个virtual host 的访问权限了:

具备访问权限

此时,点击页面右上角的 virtual host 下拉菜单,切换 virtual host/hmall

切换virtual host

然后再次查看 Queues 选项卡,会发现之前的队列已经看不到了:

队列列表

这就是基于virtual host 的隔离效果。

3. SpringAMQP

将来我们开发业务功能的时候,肯定不会在控制台收发消息,而是应该基于编程的方式。由于RabbitMQ采用了AMQP协议,因此它具备跨语言的特性。任何语言只要遵循 AMQP 协议收发消息,都可以与 RabbitMQ 交互。并且 RabbitMQ 官方也提供了各种不同语言的客户端。

但是,RabbitMQ 官方提供的 Java 客户端编码相对复杂,一般生产环境下我们更多会结合 Spring 来使用。而 Spring 的官方刚好基于RabbitMQ 提供了这样一套消息收发的模板工具:SpringAMQP。并且还基于 SpringBoot 对其实现了自动装配,使用起来非常方便。

SpringAMQP 的官方地址:https://spring.io/projects/spring-amqp/

SpringAMQP 提供了三个功能:

  • 自动声明队列、交换机及其绑定关系
  • 基于注解的监听器模式,异步接收消息
  • 封装了RabbitTemplate工具,用于发送消息

这一章我们就一起学习一下,如何利用 SpringAMQP 实现对 RabbitMQ 的消息收发。

3.1 导入Demo工程

项目结构如图:

Demo项目结构

包括三部分:

  • mq-demo:父工程,管理项目依赖
  • publisher:消息的发送者
  • consumer:消息的消费者

mq-demo 这个父工程中,已经配置好了 SpringAMQP 相关的依赖:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
<?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>cn.itcast.demo</groupId>
<artifactId>mq-demo</artifactId>
<version>1.0-SNAPSHOT</version>
<modules>
<module>publisher</module>
<module>consumer</module>
</modules>
<packaging>pom</packaging>

<parent>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-parent</artifactId>
<version>2.7.12</version>
<relativePath/>
</parent>

<properties>
<maven.compiler.source>8</maven.compiler.source>
<maven.compiler.target>8</maven.compiler.target>
</properties>

<dependencies>
<dependency>
<groupId>org.projectlombok</groupId>
<artifactId>lombok</artifactId>
</dependency>
<!--AMQP依赖,包含RabbitMQ-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
<!--单元测试-->
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-test</artifactId>
</dependency>
</dependencies>
</project>

因此,子工程中就可以直接使用 SpringAMQP 了。

3.2 快速入门

在之前的案例中,我们都是经过交换机发送消息到队列,不过有时候为了测试方便,我们也可以直接向队列发送消息,跳过交换机。

在入门案例中,我们就演示这样的简单模型,如图:

MQ简单模型

也就是:

  • publisher直接发送消息到队列
  • 消费者监听并处理队列中的消息

注意:这种模式一般测试使用,很少在生产中使用。

为了方便测试,我们现在控制台新建一个队列:simple.queue

新建队列simple.queue

添加成功:

队列simple.queue

接下来,我们就可以利用 Java 代码收发消息了。

3.1.1 消息发送

首先配置 MQ 地址,在 publisher 服务的 application.yml 中添加配置:

1
2
3
4
5
6
7
spring:
rabbitmq:
host: 192.168.88.132 # 你的虚拟机IP
port: 5672 # 端口
virtual-host: /hmall # 虚拟主机
username: hmall # 用户名
password: 123 # 密码

然后在 publisher 服务中编写测试类 SpringAmqpTest,并利用 RabbitTemplate 实现消息发送:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
package com.muyoukule.publisher.amqp;

@SpringBootTest
public class SpringAmqpTest {

@Autowired
private RabbitTemplate rabbitTemplate;

@Test
public void testSimpleQueue() {
// 队列名称
String queueName = "simple.queue";
// 消息
String message = "hello, spring amqp!";
// 发送消息
rabbitTemplate.convertAndSend(queueName, message);
}
}

打开控制台,可以看到消息已经发送到队列中:

消息已经发送到队列

3.1.2 消息接收

首先配置 MQ 地址,在 consumer 服务的 application.yml 中添加配置:

1
2
3
4
5
6
7
spring:
rabbitmq:
host: 192.168.88.132 # 你的虚拟机IP
port: 5672 # 端口
virtual-host: /hmall # 虚拟主机
username: hmall # 用户名
password: 123 # 密码

然后在 consumer 服务的 com.muyoukule.consumer.listener 包中新建一个类 SpringRabbitListener,代码如下:

1
2
3
4
5
6
7
8
9
10
11
12
package com.muyoukule.consumer.listener;

@Component
public class SpringRabbitListener {
// 利用RabbitListener来声明要监听的队列信息
// 将来一旦监听的队列中有了消息,就会推送给当前服务,调用当前方法,处理消息。
// 可以看到方法体中接收的就是消息体的内容
@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage(String msg) {
System.out.println("spring 消费者接收到消息:【" + msg + "】");
}
}

测试

启动 consumer 服务,然后在 publisher 服务中运行测试代码,发送 MQ 消息。最终 consumer 收到消息:

1
spring 消费者接收到消息:【hello, spring amqp!】

3.3 WorkQueues模型

Work queues,任务模型。简单来说就是让多个消费者绑定到一个队列,共同消费队列中的消息

WorkQueues模型

当消息处理比较耗时的时候,可能生产消息的速度会远远大于消息的消费速度。长此以往,消息就会堆积越来越多,无法及时处理。

此时就可以使用 work 模型,多个消费者共同处理消息处理,消息处理的速度就能大大提高了。

接下来,我们就来模拟这样的场景。

首先,我们在控制台创建一个新的队列,命名为 work.queue

新建work.queue

3.3.1 消息发送

这次我们循环发送,模拟大量消息堆积现象。

publisher 服务中的 SpringAmqpTest 类中添加一个测试方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
* workQueue
* 向队列中不停发送消息,模拟消息堆积。
*/
@Test
public void testWorkQueue() throws InterruptedException {
// 队列名称
String queueName = "work.queue";
// 消息
String message = "hello, message_";
for (int i = 0; i < 50; i++) {
// 发送消息,每20毫秒发送一次,相当于每秒发送50条消息
rabbitTemplate.convertAndSend(queueName, message + i);
Thread.sleep(20);
}
}

3.3.2 消息接收

要模拟多个消费者绑定同一个队列,我们在 consumer 服务的 SpringRabbitListener 中添加2个新的方法:

1
2
3
4
5
6
7
8
9
10
11
@RabbitListener(queues = "work.queue")
public void listenWorkQueue1(String msg) throws InterruptedException {
System.out.println("消费者1接收到消息:【" + msg + "】" + Localtime.now());
Thread.sleep(20);
}

@RabbitListener(queues = "work.queue")
public void listenWorkQueue2(String msg) throws InterruptedException {
System.err.println("消费者2........接收到消息:【" + msg + "】" + Localtime.now());
Thread.sleep(200);
}

注意到这两消费者,都设置了 Thead.sleep,模拟任务耗时:

  • 消费者1 sleep了20毫秒,相当于每秒钟处理 50 个消息
  • 消费者2 sleep了200毫秒,相当于每秒处理 5 个消息

测试

启动 ConsumerApplication 后,在执行 publisher 服务中刚刚编写的发送测试方法 testWorkQueue

最终结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
消费者2........接收到消息:【hello, message_0】13:32:09.536087700
消费者1接收到消息:【hello, message_1】13:32:09.551980600
消费者1接收到消息:【hello, message_3】13:32:09.613422600
消费者1接收到消息:【hello, message_5】13:32:09.675505600
消费者1接收到消息:【hello, message_7】13:32:09.736149700
消费者2........接收到消息:【hello, message_2】13:32:09.750059700
消费者1接收到消息:【hello, message_9】13:32:09.798666
消费者1接收到消息:【hello, message_11】13:32:09.858968900
消费者1接收到消息:【hello, message_13】13:32:09.921156200
消费者2........接收到消息:【hello, message_4】13:32:09.964499700
消费者1接收到消息:【hello, message_15】13:32:09.981896500
消费者1接收到消息:【hello, message_17】13:32:10.042619700
消费者1接收到消息:【hello, message_19】13:32:10.104275100
消费者1接收到消息:【hello, message_21】13:32:10.165434600
消费者2........接收到消息:【hello, message_6】13:32:10.178848100
消费者1接收到消息:【hello, message_23】13:32:10.225494800
消费者1接收到消息:【hello, message_25】13:32:10.287941400
消费者1接收到消息:【hello, message_27】13:32:10.349246100
消费者2........接收到消息:【hello, message_8】13:32:10.393275300
消费者1接收到消息:【hello, message_29】13:32:10.409556700
消费者1接收到消息:【hello, message_31】13:32:10.471235500
消费者1接收到消息:【hello, message_33】13:32:10.532975600
消费者1接收到消息:【hello, message_35】13:32:10.594234
消费者2........接收到消息:【hello, message_10】13:32:10.608551200
消费者1接收到消息:【hello, message_37】13:32:10.655375500
消费者1接收到消息:【hello, message_39】13:32:10.716239400
消费者1接收到消息:【hello, message_41】13:32:10.777315
消费者2........接收到消息:【hello, message_12】13:32:10.822535300
消费者1接收到消息:【hello, message_43】13:32:10.838913400
消费者1接收到消息:【hello, message_45】13:32:10.900169200
消费者1接收到消息:【hello, message_47】13:32:10.961616800
消费者1接收到消息:【hello, message_49】13:32:11.022953200
消费者2........接收到消息:【hello, message_14】13:32:11.037243800
消费者2........接收到消息:【hello, message_16】13:32:11.251656100
消费者2........接收到消息:【hello, message_18】13:32:11.465585400
消费者2........接收到消息:【hello, message_20】13:32:11.665810700
消费者2........接收到消息:【hello, message_22】13:32:11.880131200
消费者2........接收到消息:【hello, message_24】13:32:12.094026700
消费者2........接收到消息:【hello, message_26】13:32:12.309042400
消费者2........接收到消息:【hello, message_28】13:32:12.523591600
消费者2........接收到消息:【hello, message_30】13:32:12.724700700
消费者2........接收到消息:【hello, message_32】13:32:12.939740200
消费者2........接收到消息:【hello, message_34】13:32:13.141516900
消费者2........接收到消息:【hello, message_36】13:32:13.354740500
消费者2........接收到消息:【hello, message_38】13:32:13.555752900
消费者2........接收到消息:【hello, message_40】13:32:13.771193800
消费者2........接收到消息:【hello, message_42】13:32:13.984944100
消费者2........接收到消息:【hello, message_44】13:32:14.198056
消费者2........接收到消息:【hello, message_46】13:32:14.412763700
消费者2........接收到消息:【hello, message_48】13:32:14.627655600

可以看到消费者 1 和消费者 2 竟然每人消费了 25 条消息:

  • 消费者1很快完成了自己的 25 条消息
  • 消费者 2 却在缓慢的处理自己的 25 条消息。

也就是说消息是平均分配给每个消费者,并没有考虑到消费者的处理能力。导致 1 个消费者空闲,另一个消费者忙的不可开交。没有充分利用每一个消费者的能力,最终消息处理的耗时远远超过了1秒。这样显然是有问题的。

3.3.3 能者多劳

在 spring 中有一个简单的配置,可以解决这个问题。我们修改 consumer 服务的 application.yml 文件,添加配置:

1
2
3
4
5
spring:
rabbitmq:
listener:
simple:
prefetch: 1 # 每次只能获取一条消息,处理完成才能获取下一个消息

再次测试,发现结果如下:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
消费者2........接收到消息:【hello, message_0】13:35:42.160102800
消费者1接收到消息:【hello, message_1】13:35:42.181459500
消费者1接收到消息:【hello, message_2】13:35:42.212252400
消费者1接收到消息:【hello, message_3】13:35:42.243198500
消费者1接收到消息:【hello, message_4】13:35:42.273495200
消费者1接收到消息:【hello, message_5】13:35:42.304288600
消费者1接收到消息:【hello, message_6】13:35:42.334585200
消费者1接收到消息:【hello, message_7】13:35:42.366371400
消费者2........接收到消息:【hello, message_8】13:35:42.396668300
消费者1接收到消息:【hello, message_9】13:35:42.427462
消费者1接收到消息:【hello, message_10】13:35:42.458255100
消费者1接收到消息:【hello, message_11】13:35:42.489047900
消费者1接收到消息:【hello, message_12】13:35:42.519842500
消费者1接收到消息:【hello, message_13】13:35:42.550635400
消费者1接收到消息:【hello, message_14】13:35:42.581428100
消费者1接收到消息:【hello, message_15】13:35:42.612221700
消费者2........接收到消息:【hello, message_16】13:35:42.643014600
消费者1接收到消息:【hello, message_17】13:35:42.674304900
消费者1接收到消息:【hello, message_18】13:35:42.704601200
消费者1接收到消息:【hello, message_19】13:35:42.735394900
消费者1接收到消息:【hello, message_20】13:35:42.766188100
消费者1接收到消息:【hello, message_21】13:35:42.796458
消费者1接收到消息:【hello, message_22】13:35:42.830668700
消费者1接收到消息:【hello, message_23】13:35:42.858482500
消费者2........接收到消息:【hello, message_24】13:35:42.888778200
消费者1接收到消息:【hello, message_25】13:35:42.920069300
消费者1接收到消息:【hello, message_26】13:35:42.950364900
消费者1接收到消息:【hello, message_27】13:35:42.981163300
消费者1接收到消息:【hello, message_28】13:35:43.011454900
消费者1接收到消息:【hello, message_29】13:35:43.042248
消费者1接收到消息:【hello, message_30】13:35:43.073042600
消费者1接收到消息:【hello, message_31】13:35:43.103835100
消费者2........接收到消息:【hello, message_32】13:35:43.134628400
消费者1接收到消息:【hello, message_33】13:35:43.165923
消费者1接收到消息:【hello, message_34】13:35:43.196219900
消费者1接收到消息:【hello, message_35】13:35:43.227505100
消费者1接收到消息:【hello, message_36】13:35:43.259292700
消费者1接收到消息:【hello, message_37】13:35:43.289091200
消费者1接收到消息:【hello, message_38】13:35:43.319387700
消费者1接收到消息:【hello, message_39】13:35:43.350181800
消费者2........接收到消息:【hello, message_40】13:35:43.380978800
消费者1接收到消息:【hello, message_41】13:35:43.411920700
消费者1接收到消息:【hello, message_42】13:35:43.443211600
消费者1接收到消息:【hello, message_43】13:35:43.474500800
消费者1接收到消息:【hello, message_44】13:35:43.504301700
消费者1接收到消息:【hello, message_45】13:35:43.535094800
消费者1接收到消息:【hello, message_46】13:35:43.565888200
消费者1接收到消息:【hello, message_47】13:35:43.596681100
消费者1接收到消息:【hello, message_48】13:35:43.627474500
消费者2........接收到消息:【hello, message_49】13:35:43.658764100

可以发现,由于消费者 1 处理速度较快,所以处理了更多的消息;消费者 2 处理速度较慢,只处理了 6 条消息。而最终总的执行耗时也在 1 秒左右,大大提升。

正所谓能者多劳,这样充分利用了每一个消费者的处理能力,可以有效避免消息积压问题。

总结

Work 模型的使用:

  • 多个消费者绑定到一个队列,同一条消息只会被一个消费者处理
  • 通过设置prefetch来控制消费者预取的消息数量

3.4 交换机类型

在之前的两个测试案例中,都没有交换机,生产者直接发送消息到队列。而一旦引入交换机,消息发送的模式会有很大变化:

消息发送模式引入交换机
可以看到,在订阅模型中,多了一个 Exchange 角色,而且过程略有变化:

  • Publisher:生产者,不再发送消息到队列中,而是发给交换机
  • Exchange:交换机,一方面,接收生产者发送的消息。另一方面,知道如何处理消息,例如递交给某个特别队列、递交给所有队列、或是将消息丢弃。到底如何操作,取决于 Exchange 的类型。
  • Queue:消息队列也与以前一样,接收消息、缓存消息。不过队列一定要与交换机绑定。
  • Consumer:消费者,与以前一样,订阅队列,没有变化

Exchange (交换机)只负责转发消息,不具备存储消息的能力,因此如果没有任何队列与 Exchange 绑定,或者没有符合路由规则的队列,那么消息会丢失!

交换机的类型有四种:

  • Fanout:广播,将消息交给所有绑定到交换机的队列。我们最早在控制台使用的正是Fanout交换机
  • Direct:订阅,基于 RoutingKey (路由 key )发送给订阅了消息的队列
  • Topic:通配符订阅,与 Direct 类似,只不过 RoutingKey 可以使用通配符
  • Headers:头匹配,基于 MQ 的消息头匹配,用的较少。

这里,我们讲解前面的三种交换机模式。

3.5 Fanout交换机

Fanout,英文翻译是扇出,我觉得在 MQ 中叫广播更合适。

在广播模式下,消息发送流程是这样的:

广播模式下消息发送流程

  •  可以有多个队列
  • 每个队列都要绑定到 Exchange (交换机)
  • 生产者发送的消息,只能发送到交换机
  • 机把消息发送给绑定过的所有队列
  • 订阅队列的消费者都能拿到消息

案例需求如图:
Fanout交换机需求案例

  • 创建一个名为 hmall.fanout 的交换机,类型是 Fanout
  • 创建两个队列 fanout.queue1 fanout.queue2,绑定到交换机 hmall.fanout

3.5.1 声明队列和交换机

在控制台创建队列 fanout.queue1,创建一个队列 fanout.queue2,然后再创建一个交换机 hmall.fanout

声明Fanout队列和交换机

然后绑定两个队列到交换机:

绑定fanout.queue1队列到交换机 绑定fanout.queue2队列到交换机

3.5.2 消息发送

publisher 服务的 SpringAmqpTest 类中添加测试方法:

1
2
3
4
5
6
7
8
@Test
public void testFanoutExchange() {
// 交换机名称
String exchangeName = "hmall.fanout";
// 消息
String message = "hello, everyone!";
rabbitTemplate.convertAndSend(exchangeName, "", message);
}

3.5.3 消息接收

consumer 服务的 SpringRabbitListener 中添加两个方法,作为消费者:

1
2
3
4
5
6
7
8
9
@RabbitListener(queues = "fanout.queue1")
public void listenFanoutQueue1(String msg) {
System.out.println("消费者1接收到Fanout消息:【" + msg + "】");
}

@RabbitListener(queues = "fanout.queue2")
public void listenFanoutQueue2(String msg) {
System.out.println("消费者2接收到Fanout消息:【" + msg + "】");
}

结果:

1
2
消费者2接收到Fanout消息:【hello, everyone!】
消费者1接收到Fanout消息:【hello, everyone!】

总结

交换机的作用是什么?

  • 接收 publisher 发送的消息
  • 将消息按照规则路由到与之绑定的队列
  • 不能缓存消息,路由失败,消息丢失
  • FanoutExchange 会将消息路由到每个绑定的队列

3.6 Direct交换机

在 Fanout 模式中,一条消息,会被所有订阅的队列都消费。但是,在某些场景下,我们希望不同的消息被不同的队列消费。这时就要用到 Direct 类型的 Exchange。

Direct交换机

在 Direct 模型下:

  • 队列与交换机的绑定,不能是任意绑定了,而是要指定一个 RoutingKey (路由 key )
  • 消息的发送方在 向 Exchange 发送消息时,也必须指定消息的 RoutingKey
  • Exchange不再把消息交给每一个绑定的队列,而是根据消息的 Routing Key 进行判断,只有队列的 Routingkey 与消息的 Routing key 完全一致,才会接收到消息

案例需求如图:

Direct交换机需求案例

  • 声明一个名为 hmall.direct 的交换机
  • 声明队列 direct.queue1,绑定 hmall.directbindingKey blud red
  • 声明队列 direct.queue2,绑定 hmall.directbindingKeyyellowred
  • consumer服务中,编写两个消费者方法,分别监听 direct.queue1direct.queue2
  • 在 publisher 中编写测试方法,向 hmall.direct 发送消息

3.6.1 声明队列和交换机

首先在控制台声明两个队列 direct.queue1direct.queue2 ,这里不再展示过程:

声明Direct队列和交换机

然后声明一个 Direct 类型的交换机,命名为 hmall.direct

Direct交换机hmall.direct

然后使用 red blue 作为 key,绑定 direct.queue1 hmall.direct

使用red作为key绑定direct.queue1
使用blue作为key绑定direct.queue1

同理,使用 red yellow 作为 key,绑定 direct.queue2hmall.direct,步骤略,最终结果:
hmall.direct交换机绑定结果

3.6.2 消息接收

consumer 服务的 SpringRabbitListener 中添加方法:

1
2
3
4
5
6
7
8
9
@RabbitListener(queues = "direct.queue1")
public void listenDirectQueue1(String msg) {
System.out.println("消费者1接收到direct.queue1的消息:【" + msg + "】");
}

@RabbitListener(queues = "direct.queue2")
public void listenDirectQueue2(String msg) {
System.out.println("消费者2接收到direct.queue2的消息:【" + msg + "】");
}

3.6.3 消息发送

publisher 服务的 SpringAmqpTest 类中添加测试方法:

1
2
3
4
5
6
7
8
9
@Test
public void testSendDirectExchange() {
// 交换机名称
String exchangeName = "hmall.direct";
// 消息
String message = "红色警报!日本乱排核废水,导致海洋生物变异,惊现哥斯拉!";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName, "red", message);
}

由于使用的 red 这个 key,所以两个消费者都收到了消息:

1
2
消费者2接收到direct.queue2的消息:【红色警报!日本乱排核废水,导致海洋生物变异,惊现哥斯拉!】
消费者1接收到direct.queue1的消息:【红色警报!日本乱排核废水,导致海洋生物变异,惊现哥斯拉!】

我们再切换为 blue 这个 key:

1
2
3
4
5
6
7
8
9
@Test
public void testSendDirectExchange() {
// 交换机名称
String exchangeName = "hmall.direct";
// 消息
String message = "最新报道,哥斯拉是居民自治巨型气球,虚惊一场!";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName, "blue", message);
}

会发现,只有消费者 1 收到了消息:

1
消费者1接收到direct.queue1的消息:【最新报道,哥斯拉是居民自治巨型气球,虚惊一场!】

总结

描述下 Direct 交换机与 Fanout 交换机的差异?

  • Fanout 交换机将消息路由给每一个与之绑定的队列
  • Direct交换机根据 RoutingKey 判断路由给哪个队列
  • 如果多个队列具有相同的 RoutingKey,则与 Fanout 功能类似

3.7 Topic交换机

3.7.1 说明

Topic 类型的 ExchangeDirect 相比,都是可以根据 RoutingKey 把消息路由到不同的队列。

只不过 Topic 类型 Exchange 可以让队列在绑定 BindingKey 的时候使用通配符!

BindingKey 一般都是有一个或多个单词组成,多个单词之间以 . 分割,例如: item.insert

通配符规则:

  • #:匹配一个或多个词
  • *:匹配不多不少恰好1个词

举例:

  • item.#:能够匹配 item.spu.insert 或者 item.spu
  • item.*:只能匹配 item.spu

图示:

Topic交换机

假如此时 publisher 发送的消息使用的 RoutingKey 共有四种:

  • china.news 代表有中国的新闻消息;
  • china.weather 代表中国的天气消息;
  • japan.news 则代表日本新闻
  • japan.weather 代表日本的天气消息;

解释:

  • topic.queue1:绑定的是 china.# ,凡是以 china.开头的 routing key 都会被匹配到,包括:
    • china.news
    • china.weather
  • topic.queue2:绑定的是 #.news ,凡是以 .news 结尾的 routing key 都会被匹配。包括:
    • china.news
    • japan.news

接下来,我们就按照上图所示,来演示一下 Topic 交换机的用法。

首先,在控制台按照图示例子创建队列、交换机,并利用通配符绑定队列和交换机。此处步骤略。最终结果如下:

利用通配符绑定队列和交换机

3.7.2 消息发送

在 publisher 服务的 SpringAmqpTest 类中添加测试方法:

1
2
3
4
5
6
7
8
9
10
11
12
/**
* topicExchange
*/
@Test
public void testSendTopicExchange() {
// 交换机名称
String exchangeName = "hmall.topic";
// 消息
String message = "喜报!孙悟空大战哥斯拉,胜!";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName, "china.news", message);
}

3.7.3 消息接收

consumer 服务的 SpringRabbitListener 中添加方法:

1
2
3
4
5
6
7
8
9
@RabbitListener(queues = "topic.queue1")
public void listenTopicQueue1(String msg){
System.out.println("消费者1接收到topic.queue1的消息:【" + msg + "】");
}

@RabbitListener(queues = "topic.queue2")
public void listenTopicQueue2(String msg){
System.out.println("消费者2接收到topic.queue2的消息:【" + msg + "】");
}
1
2
消费者2接收到topic.queue2的消息:【喜报!孙悟空大战哥斯拉,胜!】
消费者1接收到topic.queue1的消息:【喜报!孙悟空大战哥斯拉,胜!】

我们再切换为 china.message 这个 key 测试:

1
消费者1接收到topic.queue1的消息:【喜报!孙悟空大战哥斯拉,胜!】

我们再切换为 chengdu.news 这个 key 测试:

1
消费者2接收到topic.queue2的消息:【喜报!孙悟空大战哥斯拉,胜!】

总结

描述下 Direct 交换机与 Topic 交换机的差异?

  • Topic 交换机接收的消息 RoutingKey 可以是多个单词,以 **.** 分割
  • Topic交换机与队列绑定时的 bindingKey 可以指定通配符
  • #:代表0个或多个词
  • *:代表1个词

3.8 声明队列和交换机

在之前我们都是基于 RabbitMQ 控制台来创建队列、交换机。但是在实际开发时,队列和交换机是程序员定义的,将来项目上线,又要交给运维去创建。那么程序员就需要把程序中运行的所有队列和交换机都写下来,交给运维。在这个过程中是很容易出现错误的。

因此推荐的做法是由程序启动时检查队列和交换机是否存在,如果不存在自动创建。

3.8.1 基本API

SpringAMQP 提供了一个 Queue 类,用来创建队列:

1
2
3
public class Queue extends AbstractDeclarable implements Cloneable {
// --snip--
}

SpringAMQP 还提供了一个 Exchange 接口,来表示所有不同类型的交换机:

Exchange接口

我们可以自己创建队列和交换机,不过 SpringAMQP 还提供了 ExchangeBuilder 来简化这个过程:

ExchangeBuilder

而在绑定队列和交换机时,则需要使用 BindingBuilder 来创建 Binding 对象:

BindingBuilder中的方法

3.8.2 Fanout示例

consumer 中创建一个类,声明队列和交换机:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
package com.muyoukule.consumer.config;

@Configuration
public class FanoutConfig {
/**
* 声明交换机
*
* @return Fanout类型交换机
*/
@Bean
public FanoutExchange fanoutExchange() {
return new FanoutExchange("hmall.fanout");
}

/**
* 第1个队列
*/
@Bean
public Queue fanoutQueue1() {
return new Queue("fanout.queue1");
}

/**
* 绑定队列和交换机
*/
@Bean
public Binding bindingQueue1(Queue fanoutQueue1, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(fanoutQueue1).to(fanoutExchange);
}

/**
* 第2个队列
*/
@Bean
public Queue fanoutQueue2() {
return new Queue("fanout.queue2");
}

/**
* 绑定队列和交换机
*/
@Bean
public Binding bindingQueue2(Queue fanoutQueue2, FanoutExchange fanoutExchange) {
return BindingBuilder.bind(fanoutQueue2).to(fanoutExchange);
}
}

3.8.3 Direct示例

Direct 模式由于要绑定多个 Key,会非常麻烦,每一个 Key 都要编写一个 binding:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
package com.muyoukule.consumer.config;

@Configuration
public class DirectConfig {

/**
* 声明交换机
*
* @return Direct类型交换机
*/
@Bean
public DirectExchange directExchange() {
return ExchangeBuilder.directExchange("hmall.direct").build();
}

/**
* 第1个队列
*/
@Bean
public Queue directQueue1() {
return new Queue("direct.queue1");
}

/**
* 绑定队列和交换机
*/
@Bean
public Binding bindingQueue1WithRed(Queue directQueue1, DirectExchange directExchange) {
return BindingBuilder.bind(directQueue1).to(directExchange).with("red");
}

/**
* 绑定队列和交换机
*/
@Bean
public Binding bindingQueue1WithBlue(Queue directQueue1, DirectExchange directExchange) {
return BindingBuilder.bind(directQueue1).to(directExchange).with("blue");
}

/**
* 第2个队列
*/
@Bean
public Queue directQueue2() {
return new Queue("direct.queue2");
}

/**
* 绑定队列和交换机
*/
@Bean
public Binding bindingQueue2WithRed(Queue directQueue2, DirectExchange directExchange) {
return BindingBuilder.bind(directQueue2).to(directExchange).with("red");
}

/**
* 绑定队列和交换机
*/
@Bean
public Binding bindingQueue2WithYellow(Queue directQueue2, DirectExchange directExchange) {
return BindingBuilder.bind(directQueue2).to(directExchange).with("yellow");
}
}

3.8.4 基于注解声明

基于 @Bean 的方式声明队列和交换机比较麻烦,Spring 还提供了基于注解方式来声明。PS:不要导错包了哦,是注解类型的包😀

例如,我们同样声明 Direct 模式的交换机和队列:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1"),
exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
key = {"red", "blue"}
))
public void listenDirectQueue1(String msg) {
System.out.println("消费者1接收到direct.queue1的消息:【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue2"),
exchange = @Exchange(name = "hmall.direct", type = ExchangeTypes.DIRECT),
key = {"red", "yellow"}
))
public void listenDirectQueue2(String msg) {
System.out.println("消费者2接收到direct.queue2的消息:【" + msg + "】");
}

是不是简单多了。

再试试 Topic 模式:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue1"),
exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
key = "china.#"
))
public void listenTopicQueue1(String msg) {
System.out.println("消费者1接收到topic.queue1的消息:【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue2"),
exchange = @Exchange(name = "hmall.topic", type = ExchangeTypes.TOPIC),
key = "#.news"
))
public void listenTopicQueue2(String msg) {
System.out.println("消费者2接收到topic.queue2的消息:【" + msg + "】");
}

3.9 消息转换器

Spring 的消息发送代码接收的消息体是一个 Object:

接收的Object

而在数据传输时,它会把你发送的消息序列化为字节发送给 MQ,接收消息的时候,还会把字节反序列化为 Java 对象。

只不过,默认情况下 Spring 采用的序列化方式是 JDK 序列化。众所周知,JDK 序列化存在下列问题:

  • 数据体积过大
  • 有安全漏洞
  • 可读性差

我们来测试一下。

3.9.1 测试默认转换器

1、创建测试队列

首先,我们在 consumer 服务中声明一个新的配置类 MessageConfig,利用 @Bean 的方式创建一个队列,具体代码:

1
2
3
4
5
6
7
@Configuration
public class MessageConfig {
@Bean
public Queue objectQueue() {
return new Queue("object.queue");
}
}

注意,这里我们先不要给这个队列添加消费者,我们要查看消息体的格式。

重启 consumer 服务以后,该队列就会被自动创建出来了:

object.queue队列

2、发送消息

我们在 publisher 模块的 SpringAmqpTest 中新增一个消息发送的代码,发送一个 Map 对象:

1
2
3
4
5
6
7
8
9
@Test
public void testSendMap() {
// 准备消息
Map<String, Object> msg = new HashMap<>();
msg.put("name", "柳岩");
msg.put("age", 21);
// 发送消息
rabbitTemplate.convertAndSend("object.queue", msg);
}

3、发送消息后查看控制台:

 JDK序列化消息

可以看到消息格式非常不友好。

3.9.2 配置JSON转换器

显然,JDK 序列化方式并不合适。我们希望消息体的体积更小、可读性更高,因此可以使用 JSON 方式来做序列化和反序列化。

1、在父工程引入依赖:

1
2
3
4
5
6
<!--jackson-->
<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
<version>2.9.10</version>
</dependency>

PS:如果项目中引入了 spring-boot-starter-web 依赖,则无需再次引入 Jackson 依赖。

2、配置消息转换器,在 publisher consumer 两个服务的启动类中添加一个 Bean 即可:

1
2
3
4
5
6
7
8
@Bean
public MessageConverter messageConverter() {
// 1.定义消息转换器
Jackson2JsonMessageConverter jackson2JsonMessageConverter = new Jackson2JsonMessageConverter();
// 2.配置自动创建消息id,用于识别不同消息,也可以在业务中基于ID判断是否是重复消息
jackson2JsonMessageConverter.setCreateMessageIds(true);
return jackson2JsonMessageConverter;
}

消息转换器中添加的 messageId 可以便于我们将来做幂等性判断。

3、此时,再次执行刚才的消息发送的代码,到 RabbitMQ 的控制台查看消息结构(Get messages 填 2 ) :

RabbitMQ控制台查看消息结构

对比发现数据体积小了很多。

3.9.3 消费者接收Object

我们在consumer服务中定义一个新的消费者,publisher是用 Map 发送,那么消费者也一定要用 Map 接收,格式如下:

1
2
3
4
@RabbitListener(queues = "object.queue")
public void listenSimpleQueueMessage(Map<String, Object> msg) {
System.out.println("消费者接收到object.queue消息:【" + msg + "】");
}

会发现接收第一条消息报错,第二条消息正常。但是回到 RabbitMQ 控制台发现第一条消息消失了,说明第一条消息丢失了。

怎么解决呢?

请参考文章 RabbitMQ高级 😁