8.1 同步调用
即客户端向服务端请求做数据处理，客户端需要一直等待服务端处理直到返回结果给客户端

同步调用存在的问题：
耦合度高：每次加入新的需求，都要修改原来的代码
性能下降：调用者需要等待服务提供者响应，如果调用链过长则响应时间等于每次调用的时间之和
资源浪费：调用链中的每个服务在等待响应过程中，不能释放请求占用的资源，高并发场景下会极度浪费系统资源
级联失败：如果服务提供者出现问题，所有调用方都会跟着出问题，如同多米诺牌一样，迅速导致整个微服务群故障
优点：
时效性较强，可以立即得到结果

8.2 异步调用
即客户端并不是直接向服务端发起请求，而是会通过一个消息队列，客户端发起请求放入消息队列后就不会去等待服务端的执行结果，而是交给消息队列去下发请求做后台处理，客户端察觉不到




缺点：
依赖于消息队列的可靠性、安全性、吞吐能力
架构复杂，业务没有明显的流程线，不好追踪管理
优点：
耦合度低
吞吐量提升
故障隔离
流量削峰
8.3 消息队列框架比较
RabbitMQ ActiveMQ RocketMQ Kafka
公司/社区 Rabbit Apache 阿里 Apache
开发语言 Erlang Java Java Scala&Java
协议支持 AMQP,XMPP,SMTP,STOMP OpenWire,STOMP,REST,XMPP,AMQP 自定义协议 自定义协议
可用性 高 一般 高 高
单机吞吐量 一般 差 高 非常高
消息延迟 微妙级 毫秒级 毫秒级 毫秒以内
消息可靠性 高 一般 高 一般
8.4 RabbitMQ的结构



virtual host：虚拟主机，是对 queue、exchange 等资源的逻辑分组
exchange：路由消息到队列中
queue：缓存消息的队列
channel：操作MQ的工具
8.5 SpringAMQP 框架
用于操作 rabbitmq 的Spring集成框架

AMQP：是用于在应用程序或之间传递业务消息的开放标准。该协议与语言和平台无关，更符合微服务中独立性的要求。

SpringAMQP：是基于AMQP协议定义的一套API规范，提供了模板来发送和接收消息。包含两部分，其中 spring-amqp 是基础抽象， spring-rabbit 是底层的默认实现。

具体依赖：
一般引入到微服务的父工程 pom.xml 中

<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-starter-amqp</artifactId>
</dependency>
1
2
3
4
8.6 RabbitMQ 相关配置
在 application.yml 中进行配置
spring:
rabbitmq:
host: 81.69.245.250 # 主机名
port: 5672 # 端口
virtual-host: / # 虚拟主机
username: rabbit # 用户名
password: rabbit # 密码
listener:
simple:
prefetch: 1 # 默认没有上限，每次只能获取一条消息，处理完成才能获取下一条消息

在服务器安装好 RabbitMQ 后，会有两个端口 port：

15672：从页面直接访问进入消息管理中心端口
5672：代码调用 RabbitMQ 进行消息处理的端口
username 和 password 为登录管理界面的用户名和密码


virtual-host：用户名所连接的虚拟主机




listener.simple.prefetch: 1：针对于客户端的配置

默认客户端接收队列中的消息数量是没有上限的，即不管消息处理完了没有，都先把消息队列中的消息全部取出，这样若有多个客户机向消息队列拿消息，那么消息队列不管各个客户机的处理能力怎么样，会平均分配给这几个客户机队列中的消息，会造成处理性能好的客户机处理完消息空闲，而处理性能不好的客户机仍在排队处理消息，造成资源的浪费。
所以需要通过listener.simple.prefetch: 1来对客户端进行配置，只有处理完设定的消息数后才能再向队列中拿消息
在 SpringBoot 启动类中进行配置
消息格式转换器：在将对象存入消息队列的时候，Spring 的消息对象的处理是由
org.springframework.amqp.support.converter.MessageConverter
来处理的。而默认实现是 SimpleMessageConverter，基于 JDK 的 ObjectOutputStream 完成序列化，所以默认存入消息队列中的对象是一个JDK序列化




为了方便对象在存入消息队列后的可读性，可以定义一个 MessageConverter 类型的 Bean，将对象转化为 JSON 格式序列化

先在父工程的 pom.xml 中引入 json 格式转换依赖

<dependency>
<groupId>com.fasterxml.jackson.dataformat</groupId>
<artifactId>jackson-dataformat-xml</artifactId>
</dependency>

在模块的启动类中注入Bean

@SpringBootApplication
public class PublisherApplication {
public static void main(String[] args) {
SpringApplication.run(PublisherApplication.class);
}

/**
* 消息对象存储，默认JDK序列化，定义为json序列化
* @return
*/
@Bean
public Jackson2JsonMessageConverter jsonMessageConverter() {
return new Jackson2JsonMessageConverter();
}
}


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

8.7 RabbitMQ 中五种消息队列模式
官网：https://www.rabbitmq.com/getstarted.html

1. Simple Queue 基本消息模式：
最简单的模型，发送端把消息放入队列中，接收端从队列中拿消息



该种方式，若 RabbitMQ 中心没有要发送消息进入的队列或者没有接收端要接收的队列，那么需要先创建一个队列才能顺利发送或者接收

方法一：
先在 发送端 创建队列，发送消息

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAMTPTest {
// 注入操作RabbitMQ的对象
@Resource
private RabbitTemplate rabbitTemplate;

@Test
public void testSendSimpleQueue() {
// 创建一个操作队列的对象
RabbitAdmin admin = new RabbitAdmin(rabbitTemplate);
Queue springQueue = new Queue("simple.queue");
// 在管理器中声明该队列
admin.declareQueue(springQueue);
// 队列名
String queueName = "simple.queue";
// 要发送的消息
String message = "this is a simple queue";
rabbitTemplate.convertAndSend(queueName,message);
}
}

接收端 接收

创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息

@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage(String msg) {
System.out.println("spring 消费者接收到消息：【" + msg + "】");
}

方法二：
先在 接收端 创建一个配置类，创建队列

import org.springframework.amqp.core.Queue;

@Configuration
public class QueueConfig {
@Bean
public Queue simpleQueue() {
return new Queue("simple.queue");
}
}

再创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息

@RabbitListener(queues = "simple.queue")
public void listenSimpleQueueMessage(String msg) {
System.out.println("spring 消费者接收到消息：【" + msg + "】");
}

发送端 发送

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAMTPTest {
// 注入操作RabbitMQ的对象
@Resource
private RabbitTemplate rabbitTemplate;

@Test
public void testSendSimpleQueue() {
// 队列名
String queueName = "simple.queue";
// 要发送的消息
String message = "this is a simple queue";
rabbitTemplate.convertAndSend(queueName,message);
}
}

2. Work Queue 工作模式：
多个接收端接收消息，提高消息处理速度，避免消息堆积

方法与模型 1 一样，接收端 增加多个消费者

@Component
public class SpringRabbitListener {

@RabbitListener(queues = "work.queue")
public void listenWorkQueueMessage1(String msg) throws InterruptedException {
System.out.println("spring消费者1---接收到消息：【" + msg + "】" + LocalTime.now());
Thread.sleep(20);
}

@RabbitListener(queues = "work.queue")
public void listenWorkQueueMessage2(String msg) throws InterruptedException {
System.out.println("spring消费者2---接收到消息：【" + msg + "】" + LocalTime.now());
Thread.sleep(200);
}
}

关键配置：
在接收端 application.yml 中配置 spring.rabbitmq.listener.simple.prefetch: 1 使每个接收端消费完定义数量后再从消息队列中提取，减少资源浪费，提高性能

后三个模式与前两者的最大区别在于加入了 exchange（交换机），通过交换机路由到不同消息队列中，允许同一消息发送给多个消费者
3. Fanout Exchange 广播模式
会将接收到的消息路由到每一个跟其绑定的消息队列中



先在 接收端 创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息

@Component
public class SpringRabbitListener {

@RabbitListener(bindings = @QueueBinding(
exchange = @Exchange(name = "cyx.fanout",type = ExchangeTypes.FANOUT),
value = @Queue(name = "fanout.queue1")
))
public void listenFanoutQueue1(String msg) {
System.out.println("消费者接收到fanout.queue1消息：【" + msg + "】");
}

@RabbitListener(bindings = @QueueBinding(
exchange = @Exchange(name = "cyx.fanout",type = ExchangeTypes.FANOUT),
value = @Queue(name = "fanout.queue2")
))
public void listenFanoutQueue2(String msg) {
System.out.println("消费者接收到fanout.queue2消息：【" + msg + "】");
}
}

该种注解方式，若无指定的交换机或者消息队列会先创建一个，无需提前创建

发送端 发送

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAMTPTest {
// 注入操作RabbitMQ的对象
@Resource
private RabbitTemplate rabbitTemplate;

@Test
public void testSendFanoutExchange() {
// 交换机名称
String exchangeName = "cyx.fanout";
// 消息
String message = "this is fanout...";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName,"",message);
}
}


4. Direct Exchange 路由模式
交换机会将接收到的消息根据规则路由到指定的消息队列中，因此称为路由模式


每一个 Queue 都与 Exchange 设置一个 BindingKey
发布者发送消息时，指定消息的 RoutingKey
Exchange 将消息路由到 BindingKey 与消息 RoutingKey 一致的队列
先在 接收端 创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息

@Component
public class SpringRabbitListener {

@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "direct.queue1"),
exchange = @Exchange(name = "cyx.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 = "cyx.direct",type = ExchangeTypes.DIRECT),
key = {"red","yellow"}
))
public void listenDirectQueue2(String msg) {
System.out.println("消费者接收到direct.queue2的消息：【" + msg + "】");
}
}

发送端 发送

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAMTPTest {

@Test
public void testSendDirectExchange() {
// 交换机名称
String exchangeName = "cyx.direct";
// 消息
String message = "this is direct...";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName,"red",message);
}
}

5. Topic Exchange 话题模式
与路由模式类似，区别在于 routingKey 必须是多个单词的列表，并且以.分割，可以使路由根据通配符匹配到指定类型的消息队列中。
#：代指 0 个或多个单词
*：代指一个单词


先在 接收端 创建一个监听类，在其中添加监听方法，并定义为Component组件加入Spring中，开启启动类监听队列消息

@Component
public class SpringRabbitListener {

@RabbitListener(bindings = @QueueBinding(
value = @Queue(name = "topic.queue1"),
exchange = @Exchange(name = "cyx.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 = "cyx.topic",type = ExchangeTypes.TOPIC),
key = "#.news"
))
public void listenTopicQueue2(String msg) {
System.out.println("消费者接收到topic.queue2的消息：【" + msg + "】");
}
}


发送端 发送

@RunWith(SpringRunner.class)
@SpringBootTest
public class SpringAMTPTest {
// 注入操作RabbitMQ的对象
@Resource
private RabbitTemplate rabbitTemplate;

@Test
public void testSendTopicExchange() {
// 交换机名称
String exchangeName = "cyx.topic";
// 消息
String message = "this is topic...";
// 发送消息
rabbitTemplate.convertAndSend(exchangeName,"wether.news",message);
}
}

免责申明：

本文系转载，版权归原作者所有，如若侵权请联系我们进行删除！

《数据治理行业实践白皮书》下载地址：https://fs80.cn/4w2atu

《数栈V6.0产品白皮书》下载地址：https://fs80.cn/cw0iw1

想了解或咨询更多有关袋鼠云大数据产品、行业解决方案、客户案例的朋友，浏览袋鼠云官网：https://www.dtstack.com/?src=bbs

同时，欢迎对大数据开源项目有兴趣的同学加入「袋鼠云开源框架钉钉技术群」，交流最新开源技术信息，群号码：30537511，项目地址：https://github.com/DTStack