小小MQ，知识点竟然这么多？？？

Posted 林⁣熙

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了小小MQ，知识点竟然这么多？？？相关的知识，希望对你有一定的参考价值。

小小MQ，知识点竟然这么多？？？

一、MQ的基本概念

1.MQ概述

MQ全称Message Queue（消息队列），是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。
常见的服务通信：

加入MQ后：

二、MQ的优势

1.应用解耦

服务与服务之间不再约定协议而对接接口，而是通过生产者/消费者的模式让中间件的MQ来对接两边的数据通信实现解耦合（扩展性更强）。
常见的服务通信：
加入MQ后：

2.异步提速

常见的服务通信：
需要阻塞成功获取到响应状态在写入数据到数据库，阻塞同步往下执行。
加入MQ后：

3.削峰填谷

常见的服务通信：当一瞬间有5000个请求给到服务器时，服务器最大能处理1000请求，受不了了当场去世。

加入MQ后：
先把请求丢到队列中等待处理，系统每秒从mq中拉取1000个请求进行处理（刚好卡在能处理的1000个，真实压榨案例），这样就变成了从1秒钟处理5000个请求的高峰期，拆分成了 5秒钟，每秒钟处理1000请求的平缓处理期，哦不，是满载处理期。

根据下面的图所示，确实高峰期被削掉了

三、MQ的劣势

系统可用性降低

系统引入的外部依赖越多，系统稳定性越差。一旦MQ宕机，就会对业务产生影响。如何保证MQ的高可用？

系统复杂度提高

MQ的加入大大增加了系统的复杂度，以前系统间是同步的远程调用，现在是通过MQ进行的异步调用。如何保证消息不背丢失等等。

四、常见的MQ产品

MQ是一种抽象的概念，衍生了各种基于其思想的实现，如常见的：RabbitMQ，RocketMQ，Kafka。

五、RabbitMQ 介绍

建议直接看总结，下面的知识可以慢慢品（以下引用Guide哥的）

1.RabbitMQ 简介

RabbitMQ 是采用 Erlang 语言实现 AMQP(Advanced Message Queuing Protocol，高级消息队列协议）的消息中间件，它最初起源于金融系统，用于在分布式系统中存储转发消息。

RabbitMQ 发展到今天，被越来越多的人认可，这和它在易用性、扩展性、可靠性和高可用性等方面的卓著表现是分不开的。RabbitMQ 的具体特点可以概括为以下几点：

  • 可靠性： RabbitMQ使用一些机制来保证消息的可靠性，如持久化、传输确认及发布确认等。
  • 灵活的路由： 在消息进入队列之前，通过交换器来路由消息。对于典型的路由功能，RabbitMQ 己经提供了一些内置的交换器来实现。针对更复杂的路由功能，可以将多个交换器绑定在一起，也可以通过插件机制来实现自己的交换器。这个后面会在我们将 RabbitMQ 核心概念的时候详细介绍到。
  • 扩展性： 多个RabbitMQ节点可以组成一个集群，也可以根据实际业务情况动态地扩展集群中节点。
  • 高可用性： 队列可以在集群中的机器上设置镜像，使得在部分节点出现问题的情况下队列仍然可用。
  • 支持多种协议： RabbitMQ 除了原生支持 AMQP 协议，还支持 STOMP、MQTT 等多种消息中间件协议。
  • 多语言客户端： RabbitMQ几乎支持所有常用语言，比如 Java、Python、Ruby、php、C#、javascript等。
  • 易用的管理界面： RabbitMQ提供了一个易用的用户界面，使得用户可以监控和管理消息、集群中的节点等。在安装 RabbitMQ 的时候会介绍到，安装好 RabbitMQ 就自带管理界面。
  • 插件机制： RabbitMQ 提供了许多插件，以实现从多方面进行扩展，当然也可以编写自己的插件。感觉这个有点类似 Dubbo 的 SPI机制。

RabbitMQ 整体上是一个生产者与消费者模型，主要负责接收、存储和转发消息。可以把消息传递的过程想象成：当你将一个包裹送到邮局，邮局会暂存并最终将邮件通过邮递员送到收件人的手上，RabbitMQ就好比由邮局、邮箱和邮递员组成的一个系统。从计算机术语层面来说，RabbitMQ 模型更像是一种交换机模型。

下面再来看看图—— RabbitMQ 的整体模型架构。

1.1 Producer(生产者) 和 Consumer(消费者)

  • Producer(生产者) :生产消息的一方（邮件投递者）
  • Consumer(消费者) :消费消息的一方（邮件收件人）

消息一般由 2 部分组成：消息头（或者说是标签 Label）和 消息体。消息体也可以称为 payLoad ,消息体是不透明的，而消息头则由一系列的可选属性组成，这些属性包括 routing-key（路由键）、priority（相对于其他消息的优先权）、delivery-mode（指出该消息可能需要持久性存储）等。生产者把消息交由 RabbitMQ 后，RabbitMQ 会根据消息头把消息发送给感兴趣的 Consumer(消费者)。

1.2 Exchange(交换器)

在 RabbitMQ 中，消息并不是直接被投递到 Queue(消息队列) 中的，中间还必须经过 Exchange(交换器) 这一层，Exchange(交换器) 会把我们的消息分配到对应的 Queue(消息队列) 中。

Exchange(交换器) 用来接收生产者发送的消息并将这些消息路由给服务器中的队列中，如果路由不到，或许会返回给 Producer(生产者) ，或许会被直接丢弃掉 。这里可以将RabbitMQ中的交换器看作一个简单的实体。

RabbitMQ 的 Exchange(交换器) 有4种类型，不同的类型对应着不同的路由策略：direct(默认)，fanout, topic, 和 headers，不同类型的Exchange转发消息的策略有所区别。这个会在介绍 Exchange Types(交换器类型) 的时候介绍到。

Exchange(交换器) 示意图如下：

生产者将消息发给交换器的时候，一般会指定一个 RoutingKey(路由键)，用来指定这个消息的路由规则，而这个 RoutingKey 需要与交换器类型和绑定键(BindingKey)联合使用才能最终生效。

RabbitMQ 中通过 Binding(绑定) 将 Exchange(交换器) 与 Queue(消息队列) 关联起来，在绑定的时候一般会指定一个 BindingKey(绑定建) ,这样 RabbitMQ 就知道如何正确将消息路由到队列了,如下图所示。一个绑定就是基于路由键将交换器和消息队列连接起来的路由规则，所以可以将交换器理解成一个由绑定构成的路由表。Exchange 和 Queue 的绑定可以是多对多的关系。

Binding(绑定) 示意图：

生产者将消息发送给交换器时，需要一个RoutingKey,当 BindingKey 和 RoutingKey 相匹配时，消息会被路由到对应的队列中。在绑定多个队列到同一个交换器的时候，这些绑定允许使用相同的 BindingKey。BindingKey 并不是在所有的情况下都生效，它依赖于交换器类型，比如fanout类型的交换器就会无视，而是将消息路由到所有绑定到该交换器的队列中。

1.3 Queue(消息队列)

Queue(消息队列) 用来保存消息直到发送给消费者。它是消息的容器，也是消息的终点。一个消息可投入一个或多个队列。消息一直在队列里面，等待消费者连接到这个队列将其取走。

RabbitMQ 中消息只能存储在 队列 中，这一点和 Kafka 这种消息中间件相反。Kafka 将消息存储在 topic（主题） 这个逻辑层面，而相对应的队列逻辑只是topic实际存储文件中的位移标识。 RabbitMQ 的生产者生产消息并最终投递到队列中，消费者可以从队列中获取消息并消费。

多个消费者可以订阅同一个队列，这时队列中的消息会被平均分摊（Round-Robin，即轮询）给多个消费者进行处理，而不是每个消费者都收到所有的消息并处理，这样避免的消息被重复消费。

RabbitMQ 不支持队列层面的广播消费,如果有广播消费的需求，需要在其上进行二次开发,这样会很麻烦，不建议这样做。

1.4 Broker（消息中间件的服务节点）

对于 RabbitMQ 来说，一个 RabbitMQ Broker 可以简单地看作一个 RabbitMQ 服务节点，或者RabbitMQ服务实例。大多数情况下也可以将一个 RabbitMQ Broker 看作一台 RabbitMQ 服务器。

下图展示了生产者将消息存入 RabbitMQ Broker,以及消费者从Broker中消费数据的整个流程。

这样图1中的一些关于 RabbitMQ 的基本概念我们就介绍完毕了，下面再来介绍一下 Exchange Types(交换器类型) 。

1.5 Exchange Types(交换器类型)

RabbitMQ 常用的 Exchange Type 有 fanout、direct、topic、headers 这四种（AMQP规范里还提到两种 Exchange Type，分别为 system 与 自定义，这里不予以描述）。

① fanout

fanout 类型的Exchange路由规则非常简单，它会把所有发送到该Exchange的消息路由到所有与它绑定的Queue中，不需要做任何判断操作，所以 fanout 类型是所有的交换机类型里面速度最快的。fanout 类型常用来广播消息。

② direct

direct 类型的Exchange路由规则也很简单，它会把消息路由到那些 Bindingkey 与 RoutingKey 完全匹配的 Queue 中。

以上图为例，如果发送消息的时候设置路由键为“warning”,那么消息会路由到 Queue1 和 Queue2。如果在发送消息的时候设置路由键为"Info”或者"debug”，消息只会路由到Queue2。如果以其他的路由键发送消息，则消息不会路由到这两个队列中。
direct 类型常用在处理有优先级的任务，根据任务的优先级把消息发送到对应的队列，这样可以指派更多的资源去处理高优先级的队列。

③ topic

前面讲到direct类型的交换器路由规则是完全匹配 BindingKey 和 RoutingKey ，但是这种严格的匹配方式在很多情况下不能满足实际业务的需求。topic类型的交换器在匹配规则上进行了扩展，它与 direct 类型的交换器相似，也是将消息路由到 BindingKey 和 RoutingKey 相匹配的队列中，但这里的匹配规则有些不同，它约定：

  • RoutingKey 为一个点号“．”分隔的字符串（被点号“．”分隔开的每一段独立的字符串称为一个单词），如 “com.rabbitmq.client”、“java.util.concurrent”、“com.hidden.client”;
  • BindingKey 和 RoutingKey 一样也是点号“．”分隔的字符串；
  • BindingKey 中可以存在两种特殊字符串“*”和“#”，用于做模糊匹配，其中“*”用于匹配一个单词，“#”用于匹配多个单词(可以是零个)。

    以上图为例：
  • 路由键为 “com.rabbitmq.client” 的消息会同时路由到 Queuel 和 Queue2;
  • 路由键为 “com.hidden.client” 的消息只会路由到 Queue2 中；
  • 路由键为 “com.hidden.demo” 的消息只会路由到 Queue2 中；
  • 路由键为 “java.rabbitmq.demo” 的消息只会路由到Queuel中；
  • 路由键为 “java.util.concurrent” 的消息将会被丢弃或者返回给生产者（需要设置 mandatory 参数），因为它没有匹配任何路由键。
④ headers(不推荐)

headers 类型的交换器不依赖于路由键的匹配规则来路由消息，而是根据发送的消息内容中的 headers 属性进行匹配。在绑定队列和交换器时制定一组键值对，当发送消息到交换器时，RabbitMQ会获取到该消息的 headers（也是一个键值对的形式)'对比其中的键值对是否完全匹配队列和交换器绑定时指定的键值对，如果完全匹配则消息会路由到该队列，否则不会路由到该队列。headers 类型的交换器性能会很差，而且也不实用，基本上不会看到它的存在。

2.总结

用大白话说，RabbitMQ整个架构就是：客户端、交换机、队列，这三个角色因为交换机不同的模式（直连交换机、扇形交换机、主体交换机、首部交换机）以及不同的组装形成了RabbitMQ使用的各种模式：简单模式（）、工作队列模式、发布/订阅模式、路由模式、通配符模式等，其最核心的莫过于队列，提供者及对应入队，消费后对应出队。

3.Windows本地环境安装RabbitMQ

3.1 下载Erlang

RabbitMQ是基于Erlang环境开发的，先下载个Erlang（24），https://erlang.org/download/otp_win64_24.0.exe，下载直接一键点安装

3.2 安装RabbitMQ（3.9.5）

https://github.com/rabbitmq/rabbitmq-server/releases/download/v3.9.5/rabbitmq-server-3.9.5.exe，·1下载直接一键点安装

3.3启动

这个应该不用我说按啥启动了吧

启动成功，如下

3.4安装管理插件

右键快捷方式打开文件夹所在目录

执行：
rabbitmq-plugins enable rabbitmq_management

5.访问后台

后台管理网址：
http://localhost:15672/
安装后的默认初始
账号：guest
密码：guset
然后就得到了黑化版的RabbitMQ？

4.从一个简单的例子认识RabbitMQ

1.示例

依赖：

		 <dependency>
	        <groupId>org.springframework.boot</groupId>
			 <artifactId>spring-boot-starter-amqp</artifactId>
	        <version>2.4.1</version>
	    </dependency>

生产者：

package boot.spring.test;

import com.rabbitmq.client.Channel;
import com.rabbitmq.client.Connection;
import com.rabbitmq.client.ConnectionFactory;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @description:
 * @author：lx
 * @date: 2021/09/04 下午 3:12
 * @Copyright： lx
 */
public class Provider {

	/**
	 * 声明的队列名
	 */
	private final static String QUEUE_NAME = "test_queue";

	public static void main(String[] args) throws IOException, TimeoutException {

		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		// 默认端口号
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		connectionFactory.setVirtualHost("/");

		// 获取TCP长连接
		Connection conn = connectionFactory.newConnection();

		// 创建通信“通道”，相当于TCP中的虚拟连接
		Channel channel = conn.createChannel();
		// 开启RabbitMQ事务，当没有接收到MQ反馈时抛出异常并回滚
		channel.txSelect();

		// 创建队列，声明并创建一个队列，如果队列已存在，则使用这个队列
		// 第一个参数：队列名称
		// 第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失
		// 第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有一次则拥有它的消费者才能一直使用，其它消费者不让访问
		// 第四个参数：是否自动删除，false代表连接停掉后不自动删除这个队列
		// 其它额外参数：null
		channel.queueDeclare(QUEUE_NAME, true, false, false, null);
		String message = "hello world!";

		try {
			// 第一个参数：交换机，这里时简单demo版本，没有用到交换机
			// 第二个参数：队列名称
			// 第三个参数：额外的设置属性
			// 第四个参数：要传递的消息字节数组
			channel.basicPublish("", QUEUE_NAME, null, message.getBytes());
		} catch (Exception e) {
			// 发生异常的回滚
			channel.txRollback();
		}

		// 正常流程提交事务
		channel.txCommit();
		channel.close();
		conn.close();
		System.out.println("发送成功！");
	}
}

消费者：

package boot.spring.test;

import com.rabbitmq.client.*;

import java.io.IOException;
import java.util.concurrent.TimeoutException;

/**
 * @description:
 * @author：lx
 * @date: 2021/09/04 下午 3:33
 * @Copyright： lx
 */
public class Consumer {

	private final static String QUEUE_NAME = "test_queue";

	public static void main(String[] args) throws IOException, TimeoutException {

		ConnectionFactory connectionFactory = new ConnectionFactory();
		connectionFactory.setHost("127.0.0.1");
		connectionFactory.setPort(5672);
		connectionFactory.setUsername("guest");
		connectionFactory.setPassword("guest");
		connectionFactory.setVirtualHost("/");

		// 获取TCP长连接
		Connection conn = connectionFactory.newConnection();

		// 创建通信“通道”，相当于TCP中的虚拟连接
		Channel channel = conn.createChannel();

		// 创建队列，声明并创建一个队列，如果队列已存在，则使用这个队列
		// 第一个参数：队列名称
		// 第二个参数：是否持久化，false对应不持久化数据，MQ停掉数据就会丢失
		// 第三个参数：是否队列私有化，false则代表所有消费者都可以访问，true代表只有一次则拥有它的消费者才能一直使用，其它消费者不让访问
		// 第四个参数：是否自动删除，false代表连接停掉后不自动删除这个队列
		// 其它额外参数：null
		channel.queueDeclare(QUEUE_NAME, true, false, false, null);

		// 创建一个消息消费者
		// 第一个参数：队列名称
		// 第二个参数：第二个参数表示是否自动确认收到消息，false代表手动编程确认消息
		// 第三个参数：传入DefaultConsumer的实现类
		channel.basicConsume(QUEUE_NAME, false, new Receiver(channel));

	}
}

/**
 * @description:
 * @author：lx
 * @date: 2021/09/04 下午 3:37
 * @Copyright： lx
 */
class Receiver extends DefaultConsumer {

	private Channel channel;

	/**
	 * 重写构造函数，channel通道对象需要从外层传入，在handleDelivery中要用到
	 *
	 * @param channel
	 */
	public Receiver(Channel channel) {
		super(channel);
		this.channel = channel;
	}

	@Override
	public void handleDelivery(String consumerTag,
	                           Envelope envelope,
	                           AMQP.BasicProperties properties,
	                           byte[] body)
			throws IOException {
		String message = new String(body);
		System.out.println("消费者接收到的消息：" + message);
		System.out.println("消息的TagID:" + envelope.getDeliveryTag());
//		int i = 1 / 0;
		// false只签收当前的消息，设置为true的时候代表签收该消费者所有未签收的消息
		channel.basicAck(envelope.getDeliveryTag(), false);
	}
}

2.重复消费

启动生产者，来到管理页面，可以看到消息已经入队，进入准备被消费的状态。

Debug启动消费者后，在管理页面可以看到，队内消息状态由准备-转变到了待回应状态，total总数还是存在的，此时消息已被接收到，但未被响应。

由于断点导致MQ超时未收到响应，状态回滚到ready，消息仍然在队中，但事实上消费者已经消费过一次了，这里引出一个问题-重复消费。

还是很多场景导致你发生异常回滚的情况还有很多，比如：
程序发送异常导致，顺带一提，程序异常会导致消费者程序崩溃，MQ也会一直阻塞在等待响应的阶段
消费者进程突然GG

使用代理将捕获转发，模拟丢包的情况

解决方案

既然重复消费这种情况是难以避免的，那么我们如何去处理这种情况呢？
消费端处理消息的业务逻辑保持幂等性。
幂等性，通俗点说，就一个数据，或者一个请求，给你重复来多次，你得确保对应的数据是不会改变的，不能出错。

1.你拿到这个消息做数据库的insert操作。那就容易了，给这个消息做一个唯一主键，那么就算出现重复消费的情况，就会导致主键冲突，避免数据库出现脏数据。
2.你拿到这个消息做redis的set的操作，那就容易了，不用解决，因为你无论set几次结果都是一样的，set操作本来就算幂等操作。
3.准备一个第三方介质,来做消费记录。以redis为例，给消息分配一个全局id，只要消费过该消息，将<id,message>以K-V形式写入redis。那消费者开始消费前，先去redis中查询有没消费记录即可。

3.消息丢失

消息在网络传输中丢失，MQ宕机丢失消息

4.消息积压

程序异常会导致消费者程序崩溃，MQ也会一直阻塞在等待响应的阶段，导致消息一直堆积

5.MQ高可用

https://blog.csdn.net/yygEwing/article/details/116329666?utm_source=app&app_version=4.14.1

六、源码分析

从简单的源码分析更深入的认知RabbitMQ

Broker： 接收和分发消息的应用，RabbitMQ Server就是Message Broker
Virtual Host： 处于多租户和安全因素设计的，把AMQP的基本组件划分到一个虚拟的分组中，类似于网络中的namespace概念。当多个不同的用户使用同一个RabbitMQserver提供的服务时，可以划分出多个vhost，每个用户在自己的vhost创建exchange/queue等
Connection： publisher/consumer和broker之间的TCP连接
Channel： 如何每一次访问RabbitMQ都建立一个Connection，在消息量大的时候建立TCP Connection的开销将是巨大的，效率也低。channel是在connection内部建立的逻辑连接，如果应用程序支持多线程，通常每个thread创建单独的channel进行通讯，AMQPmethod包含了channelId帮助客户端和message broker识别channel，所以channel之间是完全隔离的。Channel作为轻量级的Connection极大减少了操作系统建立TCP connection的开销。

1.回顾设计模式

1.1 工厂方法模式


将多段代码的共性行为抽象到接口中去定义，具体的实现由子类实现父类后去定义。最后，通过一个工厂类去根据传参来选择返回对应的实例化对象。
关键词：工厂类一般带有Factory

1.2 抽象工厂模式

抽象工厂的本质是其它工厂类的抽象类，也就是将其他工厂类中的共性行为提取到了抽象工厂类
AbstractXXX
小傅哥在抽象工厂模式中是使用了抽象工厂的另一种实现，其中用到了代理、适配器、抽象工厂几个点，这里为CacheService的两种缓存模式实现加上了适配器，使其对应的方法与CacheService接口的方法对应，然后使用了动态代理，在代理实例调用方法时，方法调用被编码分派到调用处理程序的invoke方法。
可以将不同的缓存模式的适配器类看作为工厂的构建类，这些工厂类都存在有共性的getter、setter。
这些共性行为被抽象到了CacheService中，通过动态代理，在service调用的方法实际上调用的是适配器类中的方法。

        CacheService proxy_EGM = JDKProxy.getProxy(CacheServiceImpl.class, new EGMCacheAdapter());
        proxy_EGM.set("user_name_01", "小傅哥");
        String val01 = proxy_EGM.get("user_name_01");
        System.out.println("测试结果：" + val01);
        
	    CacheService proxy_IIR = JDKProxy.getProxy(CacheServiceImpl.class, new IIRCacheAdapter());
        proxy_IIR.set("user_name_01", "小傅哥");
        String val02 = proxy_IIR.get("user_name_01");
        System.out.println("测试结果：" + val02);

1.3 建造者模式

日常生活中，装修房子会根据不同的场景、品牌、型号、价格等等组合形成了各式各样的装修风格（套餐A：现代简约，套餐B：轻奢田园，套餐C：欧式豪华）
一些基本物料不会变，而其组合经常变化的时候，就可以选择这样的构建者模式来构建代码。Builder

1.4 原型模式

在考试中，每个考生得到的考卷题目大致相同，都是从同一个考题池中随机组合一套题目出来分发给所有考生进行考试，但是这样得到的题目，题序一样，容易引起作弊，而且还是不断地创建初始化统一对象。
使用原型模式：通过克隆方式创建复杂对象、也可以避免重复做初始化操作、不需要与类中所属的其他类耦合等。但也有一些缺点如果对象中包括了循环引用的克隆，以及类中深度使用对象的克隆，都会使此模式变得异常麻烦。（在重写的克隆方法中进行乱序）
实现了Cloneable

1.5 单例模式

每次拿到或者创建获得的都是同一个实例
例如：Spring中的通过@Autowird自动注入获取的对象也是单例模式的一种体现（设定的Bean注入模式是单例），其底层是通过Bean的注入模式去决定，单例模式是将new创建的实例放入容器，每次拿到的都是这个实例对象，原型模式的话就是把创建类的Class对象放入容器，每次拿都是调用这个Class.newInstance
推荐使用枚举单例模式
这种方式解决了最主要的；线程安全、自由串行化、单一实例。
enum

1.6 适配器模式

为存在共性行为但是调用方法不同的类创建适配器接口，适配器的实现类实际上调用的是原对象的对应方法。
接口已经做了统一的包装，外部使用时候就不需要关心内部的具体逻辑了。而且在调用的时候只需要传入统一的参数即可，这样就满足了适配的作用。
Adapter

1.7 桥接模式

桥接模式的主要作用就是通过将抽象部分与实现部分分离，把多种可匹配的使用进行组合。说白了核心实现也就是在A类中含有B类接口，通过构造函数传递B类的实现，这个B类就是设计的桥。
通过模拟微信与支付宝两个支付渠道在不同的支付模式下，刷脸、指纹、密码，的组合从而体现了桥接模式的在这类场景中的合理运用。
在支付方式中桥接了指纹支付、人脸支付
Pay zfbPay = new ZfbPay(new PayFingerprintMode());
Bridge/在初始化时传入其它对象作为本类执行方法的判断

1.8 组合模式（没细品）

组合模式的主要解决的是一系列简单逻辑节点或者扩展的复杂逻辑节点在不同结构的组织下，对于外部的调用是仍然可以非常简单的。

1.9 装饰器模式（没细品）

new BufferedReader(new FileReader(""));，这段代码你是否熟悉，相信学习java开发到字节流、字符流、文件流的内容时都见到了这样的代码，一层嵌套一层，一层嵌套一层，字节流转字符流等等，而这样方式的使用就是装饰器模式的一种体现。

1.10 外观模式（没细品）

外观模式也叫门面模式，主要解决的是降低调用方的使用接口的复杂逻辑组合。这样调用方与实际的接口提供方提供方提供了一个中间层，用于包装逻辑提供API接口。有些时候外观模式也被用在中间件层，对服务中的通用性复杂逻辑进行中间件层包装，让使用方

以上是关于小小MQ，知识点竟然这么多？？？的主要内容，如果未能解决你的问题，请参考以下文章

我为什么坚持这么多年写博客

JAVA中计算两个日期时间的差值竟然也有这么多门道

用了这么久的RabbitMQ异步编程竟然都是错的!

转太强了！Github上竟然有这么多改改就能赚钱的项目。。。

TCP/IP 协议竟然有这么多漏洞？

一起学源码-微服务Nexflix Eureka 源码十一：EurekaServer自我保护机制竟然有这么多Bug？