服务异步通讯-RabbitMQ

一、初始MQ

1、同步通讯

同步调用存在的问题

1、耦合度高：每次加入新的需求，都要修改原来的代码

2、性能下降：调用者需要等待服务提供者响应，如果调用链过长则响应时间等于每次调用的时间之和。

3、资源浪费：调用链中的每个服务在等待响应过程中，不能释放请求占用的资源，高并发场景下会极度浪费系统资源。

4、级联失败：如果服务提供者出现问题所有调用方都会跟着出问题，如同多米诺骨牌一样迅速导致整个微服务群故障。

总结：

同步调用的优点：

• 时效性较强，可以立即得到结果

同步调用的问题：

• 耦合度高

• 性能和吞吐能力下降

• 有额外的资源消耗

• 有级联失败问题

2、异步通讯

异步通信的优点：

• 耦合度低

• 吞吐量提升

• 故障隔离

• 流量削峰

异步通信的缺点：

• 依赖于 Broker 的可靠性、安全性、吞吐能力

• 架构复杂了，业务没有明显的流程线，不好追踪管理

3、MQ常见框架

MQ （MessageQueue），中文是消息队列，字面来看就是存放消息的队列。也就是事件驱动架构中的Broker。

二、RabbitMQ快速入门

1、RabbitMQ概述和安装

RabbitMQ是基于Erlang语言开发的开源消息通信中间件，官网地址：RabbitMQ: easy to use, flexible messaging and streaming — RabbitMQ

总结：

RabbitMQ中的几个概念：

• channel ：操作 MQ 的工具

• exchange ：路由消息到队列中

• queue ：缓存消息

• virtual host ：虚拟主机，是对 queue 、 exchange 等资源的逻辑分组

2、常见消息模型

MQ的官方文档中给出了5个MQ的Demo示例，对应了几种不同的用法：

1、基本消息队列（BasicQueue）

2、工作消息队列（WorkQueue）

3、发布订阅（Publish、Subscribe），又根据交换机类型不同分为三种：

1、Fanout Exchange：广播

2、Direct Exchange：路由

3、Topic Exchange：主题

HelloWorld案例

官方的HelloWorld是基于最基础的消息队列模型来实现的，只包括三个角色：

1、publisher：消息发布者，将消息发送到队列queue

2、queue：消息队列，负责接受并缓存消息

3、consumer：订阅队列，处理队列中的消息

总结：

基本消息队列的消息发送流程：

1. 建立 connection

2. 创建 channel

3. 利用 channel 声明队列

4. 利用 channel 向队列发送消息

基本消息队列的消息接收流程：

1. 建立 connection

2. 创建 channel

3. 利用 channel 声明队列

4. 定义 consumer 的消费行为 handleDelivery()

5. 利用 channel 将消费者与队列绑定

三、SpringAMQP

1、Basic Queue 简单队列模型

什么是SpringAMQP

SpringAmqp的官方地址：Spring AMQP

案例：利用SpringAMQP实现HelloWorld中的基础消息队列功能

流程如下：

1.在父工程中引入spring-amqp的依赖

2.在publisher服务中利用RabbitTemplate发送消息到simple.queue这个队列

3.在consumer服务中编写消费逻辑，绑定simple.queue这个队列

步骤1：引入AMQP依赖

因为publisher和consumer服务都需要amqp依赖，因此这里把依赖直接放到父工程mq-demo中：

步骤2：在publisher中编写测试方法，向simple.queue发送消息

1.在publisher服务中编写application.yml，添加mq连接信息：

2.在publisher服务中新建一个测试类，编写测试方法：

总结：

什么是AMQP？

• 应用间消息通信的一种协议，与语言和平台无关。

SpringAMQP如何发送消息？

• 引入 amqp 的 starter 依赖

• 配置 RabbitMQ 地址

• 利用 RabbitTemplate 的 convertAndSend 方法

步骤3：在consumer中编写消费逻辑，监听simple.queue

1.在consumer服务中编写application.yml，添加mq连接信息：

2.在consumer服务中新建一个类，编写消费逻辑：

总结：

SpringAMQP如何接收消息？

• 引入 amqp 的 starter 依赖

• 配置 RabbitMQ 地址

• 定义类，添加 @Component 注解

• 类中声明方法，添加 @RabbitListener 注解，方法参数就时消息

注意：消息一旦消费就会从队列删除，RabbitMQ没有消息回溯功能

2、Work Queue 工作队列模型

Work queue，工作队列，可以提高消息处理速度，避免队列消息堆积

案例：模拟WorkQueue，实现一个队列绑定多个消费者

基本思路如下：

1.在publisher服务中定义测试方法，每秒产生50条消息，发送到simple.queue

2.在consumer服务中定义两个消息监听者，都监听simple.queue队列

3.消费者1每秒处理50条消息，消费者2每秒处理10条消息

步骤1：生产者循环发送消息到simple.queue

在publisher服务中添加一个测试方法，循环发送50条消息到simple.queue队列

步骤2：编写两个消费者，都监听simple.queue

在consumer服务中添加一个消费者，也监听simple.queue：

消费预取限制

修改application.yml文件，设置preFetch这个值，可以控制预取消息的上限：

总结：

Work模型的使用：

• 多个消费者绑定到一个队列，同一条消息只会被一个消费者处理

• 通过设置 prefetch 来控制消费者预取的消息数量

3、发布、订阅模型-Fanout

发布订阅模式与之前案例的区别就是允许将同一消息发送给多个消费者。实现方式是加入了exchange（交换机）。

常见exchange类型包括：

1、Fanout：广播

2、Direct：路由

3、Topic：话题

注意：exchange负责消息路由，而不是存储，路由失败则消息丢失

Fanout Exchange 会将接收到的消息广播到每一个跟其绑定的queue

案例：利用SpringAMQP演示FanoutExchange的使用

实现思路如下：

1.在consumer服务中，利用代码声明队列、交换机，并将两者绑定

2.在consumer服务中，编写两个消费者方法，分别监听fanout.queue1和fanout.queue2

3.在publisher中编写测试方法，向itcast.fanout发送消息

步骤1：在consumer服务声明Exchange、Queue、Binding

SpringAMQP提供了声明交换机、队列、绑定关系的API，例如：

在consumer服务常见一个类，添加@Configuration注解，并声明FanoutExchange、Queue和绑定关系对象Binding，代码如下：

步骤2：在consumer服务声明两个消费者

在consumer服务的SpringRabbitListener类中，添加两个方法，分别监听fanout.queue1和fanout.queue2：

步骤3：在publisher服务发送消息到FanoutExchange

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

总结：

交换机的作用是什么？

• 接收 publisher 发送的消息

• 将消息按照规则路由到与之绑定的队列

• 不能缓存消息，路由失败，消息丢失

• FanoutExchange 的会将消息路由到每个绑定的队列

声明队列、交换机、绑定关系的Bean是什么？

• Queue

• FanoutExchange

• Binding

4、发布、订阅模型-Direct

Direct Exchange 会将接收到的消息根据规则路由到指定的Queue，因此称为路由模式（routes）。

1、每一个Queue都与Exchange设置一个BindingKey

2、发布者发送消息时，指定消息的RoutingKey

3、Exchange将消息路由到BindingKey与消息RoutingKey一致的队列

案例：利用SpringAMQP演示DirectExchange的使用

实现思路如下：

1.利用@RabbitListener声明Exchange、Queue、RoutingKey

2.在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2

3.在publisher中编写测试方法，向itcast. direct发送消息

步骤1：在consumer服务声明Exchange、Queue

1.在consumer服务中，编写两个消费者方法，分别监听direct.queue1和direct.queue2，

2.并利用@RabbitListener声明Exchange、Queue、RoutingKey

步骤2：在publisher服务发送消息到DirectExchange

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

总结：

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

• Fanout 交换机将消息路由给每一个与之绑定的队列

• Direct 交换机根据 RoutingKey 判断路由给哪个队列

• 如果多个队列具有相同的 RoutingKey ，则与 Fanout 功能类似

基于@RabbitListener注解声明队列和交换机有哪些常见注解？

• @Queue

• @Exchange

5、发布、订阅模型-Topic

发布订阅-TopicExchange

TopicExchange与DirectExchange类似，区别在于routingKey可以是多个单词的列表，并且以 . 分割。

Queue与Exchange指定BindingKey时可以使用通配符：

#：代指0个或多个单词

*：代指一个单词

案例：利用SpringAMQP演示TopicExchange的使用

实现思路如下：

1.并利用@RabbitListener声明Exchange、Queue、RoutingKey

2.在consumer服务中，编写两个消费者方法，分别监听topic.queue1和topic.queue2

3.在publisher中编写测试方法，向itcast. topic发送消息

步骤1：在consumer服务声明Exchange、Queue

1.在consumer服务中，编写两个消费者方法，分别监听topic.queue1和topic.queue2，

2.并利用@RabbitListener声明Exchange、Queue、RoutingKey

步骤2：在publisher服务发送消息到TopicExchange

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

总结：

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

• Topic 交换机接收的消息 RoutingKey 必须是多个单词，以 . 分割

• Topic 交换机与队列绑定时的 bindingKey 可以指定通配符

• # ：代表 0 个或多个词

• * ：代表 1 个词

 案例：测试发送Object类型消息

说明：在SpringAMQP的发送方法中，接收消息的类型是Object，也就是说我们可以发送任意对象类型的消息，SpringAMQP会帮我们序列化为字节后发送。

我们在consumer中利用@Bean声明一个队列：

在publisher中发送消息以测试：

6、消息转换器

Spring的对消息对象的处理是由org.springframework.amqp.support.converter.MessageConverter来处理的。而默认实现是SimpleMessageConverter，基于JDK的ObjectOutputStream完成序列化。

如果要修改只需要定义一个MessageConverter 类型的Bean即可。推荐用JSON方式序列化，步骤如下：

1、我们在publisher服务引入依赖

2、我们在publisher服务声明MessageConverter：

3、我们在consumer服务引入Jackson依赖：

4、我们在consumer服务定义MessageConverter：

5、然后定义一个消费者，监听object.queue队列并消费消息：

总结：

SpringAMQP中消息的序列化和反序列化是怎么实现的？

• 利用 MessageConverter 实现的，默认是 JDK 的序列化

• 注意发送方与接收方必须使用相同的 MessageConverter