头图

小小MQ,知识点竟然这么多???(一)

林熙დ

@TOC

一、MQ的基本概念

1.MQ概述

MQ全称Message Queue(消息队列),是在消息的传输过程中保存消息的容器。多用于分布式系统之间进行通信。
常见的服务通信:
在这里插入图片描述
加入MQ后:
在这里插入图片描述

二、MQ的优势

1.应用解耦

服务与服务之间不再约定协议而对接接口,而是通过生产者/消费者的模式让中间件的MQ来对接两边的数据通信实现解耦合(扩展性更强)。
常见的服务通信:
(img-6bqQbeN2-1630732260464)(C:\Users\admin\AppData\Roaming\Typora\typora-user-images\image-20210904002931751.png)]加入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-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(交换器) 示意图如下:
Exchange(交换器) 示意图
生产者将消息发给交换器的时候,一般会指定一个 RoutingKey(路由键),用来指定这个消息的路由规则,而这个 RoutingKey 需要与交换器类型和绑定键(BindingKey)联合使用才能最终生效

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

Binding(绑定) 示意图:
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 有 fanoutdirecttopicheaders 这四种(AMQP规范里还提到两种 Exchange Type,分别为 system 与 自定义,这里不予以描述)。

① fanout

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

② direct

direct 类型的Exchange路由规则也很简单,它会把消息路由到那些 Bindingkey 与 RoutingKey 完全匹配的 Queue 中。
direct 类型交换器
以上图为例,如果发送消息的时候设置路由键为“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 中可以存在两种特殊字符串“*”和“#”,用于做模糊匹配,其中“*”用于匹配一个单词,“#”用于匹配多个单词(可以是零个)。
    topic 类型交换器
    以上图为例:
  • 路由键为 “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/o...,下载直接一键点安装

3.2 安装RabbitMQ(3.9.5)

https://github.com/rabbitmq/r...,·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/yygEwin...

六、源码分析

从简单的源码分析更深入的认知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接口。有些时候外观模式也被用在中间件层,对服务中的通用性复杂逻辑进行中间件层包装,让使用方可以只关心业务开发。

1.11 享元模式

在这里插入图片描述

享元模式,主要在于共享通用对象,减少内存的使用,提升系统的访问效率。而这部分共享对象通常比较耗费内存或者需要查询大量接口或者使用数据库资源,因此统一抽离作为共享对象使用。
通过各种方式将可重用的数据进行缓存整个对象,减少内存占用和查询次数
在活动秒杀的场景之下,活动的信息是不不变的,只有商品的库存在发生变换,每次从数据库种获取到的活动信息对象除了库存信息其它都是一致的,这个时候可以使用享元模式,将重复的部分缓存起来重复使用,这里使用了项元工厂,用map在初始化时从数据库缓存活动信息,库存信息由之后从redis种获取后拼接到活动信息中。

1.12 代理模式(没有细品)

在这里插入图片描述

代理模式有点像老大和小弟,也有点像分销商。主要解决的是问题是为某些资源的访问、对象的类的易用操作上提供方便使用的代理服务。而这种设计思想的模式经常会出现在我们的系统中,或者你用到过的组件中,它们都提供给你一种非常简单易用的方式控制原本你需要编写很多代码的进行使用的服务类。
大概就是:实现了代理之后的一些列封装设计。
代理模式的讲解我们采用了开发一个关于mybatis-spring中间件中部分核心功能来体现代理模式的强大之处,所以涉及到了一些关于代理类的创建以及spring中bean的注册这些知识点,可能在平常的业务开发中都是很少用到的,但是在中间件开发中确实非常常见的操作。
代理模式除了开发中间件外还可以是对服务的包装,物联网组件等等,让复杂的各项服务变为轻量级调用、缓存使用。你可以理解为你家里的电灯开关,我们不能操作220v电线的人肉连接,但是可以使用开关,避免触电。
代理模式的设计方式可以让代码更加整洁、干净易于维护,虽然在这部分开发中额外增加了很多类也包括了自己处理bean的注册等,但是这样的中间件复用性极高也更加智能,可以非常方便的扩展到各个服务应用中。

1.13 责任链

在这里插入图片描述

这个我熟,比较常用也比较简单的一种,责任链模式的核心是解决一组服务中的先后执行处理关系,就有点像你没钱花了,需要家庭财务支出审批,10块钱以下找闺女审批,100块钱先闺女审批在媳妇审批。你可以理解想象成当你要跳槽的时候被安排的明明白白的被各个领导签字放行。

        责任链模式
            1.核心思想
                链式有序执行,每一节点的执行都依赖于上一级节点的执行结果。
            2.结构划分
                抽象父类:Action
                    属性:Action action
                        用于存放指向下一结点的对象引用
                    抽象方法:start()
                        由实现的子类去定义当前节点具体的逻辑实现
                    方法:action()
                        结点执行判断分支,成功-进入下一节点的do执行,失败-执行完毕返回
                子类:openDeviceAction(等等多个子类节点)
                    重写start()方法实现具体的逻辑
                组装执行类:Call(封装好执行行为顺序、逻辑,哪里需要哪里用)
                    创建需要用到的节点,用setNext指定下一节点(执行顺序),调用第一个节点的action()启动
            3.特点、关键词
                链表数据结构,责任链的本质就是一种链表数据结构,通过节点指向下一节点来确保节点的执行顺序,(Next、Node)

1.14 命令模式

在这里插入图片描述
命令场景的核心的逻辑是调用方与不需要去关心具体的逻辑实现,在这个场景中也就是点餐人员只需要把需要点的各种菜系交个小二就可以,小二再把各项菜品交给各个厨师进行烹饪。也就是点餐人员不需要跟各个厨师交流,只需要在统一的环境里下达命令就可以。
其实我的理解就是这种模式就是一种行为的封装,下次想要用到这部分的代码就直接调方法,而不是写一长串的一条条代码。
这里的特点就是被调用方及行为被抽象到接口中了,在调用方可以利用多态调用用过被调用方的具体实现及行为方法
命令模式的使用场景需要分为三个比较大的块;命令、实现、调用者,而这三块内容的拆分也是选择适合场景的关键因素,经过这样的拆分可以让逻辑具备单一职责的性质,便于扩展。

1.15 迭代器模式(没有细品)

在这里插入图片描述
迭代器模式,常见的就是我们日常使用的iterator遍历。虽然这个设计模式在我们的实际业务开发中的场景并不多,但却几乎每天都要使用jdk为我们提供的list集合遍历。另外增强的for循环虽然是循环输出数据,但是他不是迭代器模式。迭代器模式的特点是实现Iterable接口,通过next的方式获取集合元素,同时具备对元素的删除等操作。而增强的for循环是不可以的。另外,迭代过程中是不允许删除元素的。
这种设计模式的优点是可以让我们以相同的方式,遍历不同的数据结构元素,这些数据结构包括;数组、链表、树等,而用户在使用遍历的时候并不需要去关心每一种数据结构的遍历处理逻辑,从让使用变得统一易用。

1.16 中介者模式(没有细品)

在这里插入图片描述
中介者模式要解决的就是复杂功能应用之间的重复调用,在这中间添加一层中介者包装服务,对外提供简单、通用、易扩展的服务能力。
这样的设计模式几乎在我们日常生活和实际业务开发中都会见到,例如;飞机🛬降落有小姐姐在塔台喊话、无论哪个方向来的候车都从站台上下、公司的系统中有一个中台专门为你包装所有接口和提供统一的服务等等,这些都运用了中介者模式。除此之外,你用到的一些中间件,他们包装了底层多种数据库的差异化,提供非常简单的方式进行使用。
个人理解就是为了解决复杂场景下的资源顺序调度问题。

1.17 备忘录模式(没有细品)

在这里插入图片描述
备忘录模式是以可以恢复或者说回滚,配置、版本、悔棋为核心功能的设计模式,而这种设计模式属于行为模式。在功能实现上是以不破坏原对象为基础增加备忘录操作类,记录原对象的行为从而实现备忘录模式。
个人理解就是在执行一段信息修改的同时,先将上一条消息通过缓存、存表之类的先记录起来,之后通过历史记录进行回滚到需要的配置信息。

1.18 观察者模式

在这里插入图片描述
简单来讲观察者🕵模式,就是当一个行为发生时传递信息给另外一个用户接收做出相应的处理,两者之间没有直接的耦合关联。
在这里插入图片描述

例如;狙击手、李云龙。以及许多框架中都会有的监听器,通过注解的方式,当监听的方式执行后,也会执行对应的监听方法(监听数据库库存发生变化,前端统计商品库存等也要发生改变)。还有MQ中的消费者模式,也是通过监听队列中的消息,然后再去消费,这也是一种观察者模式的思想,监听行为、订阅

1.19 状态模式

在这里插入图片描述
状态模式描述的是一个行为下的多种状态变更,比如我们最常见的一个网站的页面,在你登录与不登录下展示的内容是略有差异的(不登录不能展示个人信息),而这种登录与不登录就是我们通过改变状态,而让整个行为发生了变化。
收音机&放音机&磁带机
至少80后、90后的小伙伴基本都用过磁带放音机,它的上面是一排按钮,当放入磁带后,通过上面的按钮就可以让放音机播放磁带上的内容(listen to 英语听力考试),而且有些按钮是互斥的,当在某个状态下才可以按另外的按钮(这在设计模式里也是一个关键的点)。
不同状态下而展示的不同页面、能查询到的不同的数据,如果区级单位只看当前区,市级单位可以看所有区,根据状态、单位、某一个字段的不同以此逐级控制。

1.20 策略模式

在这里插入图片描述
策略模式也是用的最多也是最简单的一种设计模式了,常常用于替换多分支ifelse的抉择场景,前提改业务流程拥有不定未来扩展趋势,否则不符合使用场景。
如:当前系统需要做一个接入第三方支付的一个功能,这里可以使用策略者模式去创建不同支付方式分支的具体实现,就算暂时支持了:微信、支付宝、钱包等支付方式,但是随着业务量的发展和用户群体的激增,无法避免之后需要扩展加入支持银联支付等等的场景,这种时候使用策略模式较为合理。最后,策略模式的实现是通过在接口中去抽象多分支的行为方法,具体的实现由子类去定义。策略模式还需要一个策略控制类根据传入的对象利用多态去调用具体的实现。
ifelse-->策略接口、实现类、策略控制类(重点:切记当前业务是有扩展性的才去选择使用,要不然如果只是写死内容的两三个分支也去使用策略模式反而增加了内存消耗与管理成本)

1.21 模板模式(没有细品)

在这里插入图片描述

模板模式的核心设计思路是通过在,抽象类中定义抽象方法的执行顺序,并将抽象方法设定为只有子类实现,但不设计独立访问的方法。简单说也就是把你安排的明明白白的。
模版模式在定义统一结构也就是执行标准上非常方便,也就很好的控制了后续的实现者不用关心调用逻辑,按照统一方式执行。那么类的继承者只需要关心具体的业务逻辑实现即可。

1.22 访问者模式(没有细品)

在这里插入图片描述

访问者要解决的核心事项是,在一个稳定的数据结构下,例如用户信息、雇员信息等,增加易变的业务访问逻辑。为了增强扩展性,将这两部分的业务解耦的一种设计模式。

1.23 解释器模式

解释器模式(Interpreter Pattern)提供了评估语言的语法或表达式的方式,它属于行为型模式。这种模式实现了一个表达式接口,该接口解释一个特定的上下文。这种模式被用在 SQL 解析、符号处理引擎等。

    有点类似于代码生成器中,  用实际查询到的数据   "张三" 解释替换了 {name}表达式。

2.理解RabbitMQ与客户端的数据交互

3.带着问题去看代码

3.1 消息是如何入队的?

3.2 消息是如何被消费的?

3.3 客户端是如何建立连接的?

3.4 channel是什么?

3.5 RabbitMQ是如何实现异步的?

3.6 RabbitMQ如何确保消息不会丢失?Ack

3.7 为什么消费者在启动后会自动消费队列中的消息?

3.8 消费者接收到消费信息,停止运行消费者后,会继续执行消费行为?

4.核心思想

RabbitMQ实现MQ的核心思想是?其特点是?其中用到了什么设计模式?最有印象的是?

idea中下载源码,阅读。
在这里插入图片描述

七、参考:

Guide哥:https://github.com/Snailclimb...
小傅哥:https://bugstack.cn/itstack/i...
B站
百度
欢迎转载,请注明出处。

八、更新日志

  • 9-7
  • 修复了个别错别字
  • 添加了补充
  • 新增整体学习架构图,及第二节点(设计模式)内容

我是林熙,非常感谢大家的支持!一起学习,一起进步!

阅读 92
1 声望
0 粉丝
0 条评论
你知道吗?

1 声望
0 粉丝
宣传栏