设计模式在框架构建以及框架核心流程中的应用原创

好，大家好，我是林声教育的迈克老师，这节课呢，迈克老师跟大家聊一聊一聊设计模式，但是呢，我们讲的设计模式呢，可能跟大家所了解到的设计模式呢，会有一点点差异，因为呢，我们是从框架构建以及框架核心流程的一个组织出发来看设计模式的应用，好那么首先呢，迈克老师跟大家介绍一下，这节课迈克老师从哪几个角度跟大家来进行讲解，第一个呢，我们首先要了解这个设计模式，它是具体的定义，它是怎么产生的，它到底解决了什么问题，以及我们在工作当中应该怎么去应用它，好，这是第一个维度，第二个维度呢，我们来跟大家介绍一下设计原则，设计原则是什么，我们怎么遵循设计原则啊，第三个维度呢，跟大家来介绍我们框架当中，它到底符合哪些设计原则。好，以及怎么去符合这个设计原则。好第四个维度呢，会跟大家介绍啊，我们面试当中经常问到的策略模式，责任链模式以及装饰器模式，它们之间的区别。好第五个维度呢，跟大家介绍一下engineing的核心流程，它到底采用了一个怎样的一个模式，我们的open在endings上。

的构建，它到底是怎么来符合这个设计模式的好，那么呢，我们主要从这五个维度跟大家介绍，那么首先我们还是从这一个设计模式的定义出发。好，带大家来了解一下设计模式到底是什么。好，我们先来看一下这个定义啊，大家可以看到这个呢是我们设计模式的作者给我们的设计模式呢所下的一个定义，设计模式呢是指软件开发过程当中经过验证的，用于解决特定环境下重复出现特定问题的解决方案。好，大家从这一个定义当中，大家可以发现出来，就是我们的设计模式呢，它好像限定词特别的多，也就是说明我们在应用它的过程当中，大家不能够随意的去使用，它是有前提条件的，有适用领域的，有一些限定条件的，我们才可以使用。

好，这个能听明白的朋友呢，帮马克老师二一，我们呢，先把这个截个图。好，那么这个设计模式这个概念如何来理解呢？好，麦克老师跟大家介绍一下，就是在软件开发过程当中呢，我们经常首先能够默认的就是我们的软件开发呢，它是比较复杂的，它的复杂的点在哪里呢？是指我们软件的具体的业务好它的变化的。变化比较多。好，那么我们的设计模式它到底是怎么产生的呢？好，大家看到在针对于我们这种环境下，复杂的业务变化比较多的时候呢，我们前辈就是我们以往进行程序开发的这些开发者呢，他就总结了很多的设计原则，首先大家需要注意它的产生首先是由设计原则来产生的。

设计原则就是我们去做开发的时候呢，啊，我们比如说一个公司制定了一些几几个规则啊，我们都开发的时候呢，去遵循这些规则好，那么这些规则呢，就是我们的设计原则好，那么基于这个设计原则呢，我们到底设计模式它是来解决一个什么问题呢？啊大家看到，因为我们的设计实际开发过程当中，主要设计模式主要要解决的问题呢，就是去应对业务变化。好，这个能听明白的朋友帮麦克老师阿姨，就是我们到底解决了什么问题，它主要解决了我们业务变化的问题，就是希望我们遵循这个设计模式之后呢，这个变化是一个可控的状态，好，如果我们没有使用设计模式的话呢，那么业务变化多了以后，我们总是要推翻重新写，或者是呢，我们每一次要修改很多的代码，才能够把我们的业务跑起来，而我们的设计模式呢，就是每次业务发生变化的时候呢，我们只需要改动少量的代码，就能让我们的这一个，呃，具体代码呢，能够接着来跑。

好，这个能听明白的朋友呢，帮马克老师二一好，那么具体我们怎么去应用它呢？好，那么具体怎么应用，首先我们从上面麦克老师跟大家分析的过程当中，大家应该都知道，首先我们呢，需要遵循在设计开发过程当中呢，首先要遵循一些常用的设计原则啊，那么第二步呢，我们需要干什么呢？好是第二个，我们需要把业务的变化点给列出来啊。好，那么根据这个业务变化方向呢，我们再去抽象看它适合哪一种设计模式好，这个能听明白的朋友帮马克老师阿姨，我们是模式设计模式是怎么产生的好，它的背景是呢？我们的软件开发过程当中，好它是复杂的啊，业务方向变化呢是比较多的，那么它怎么产生的呢？基于这种环境我们呢，总结了一些设计原则啊，基于这些原则呢，我们要总结的一些套路啊，这个套路呢，就是指我们的设计模式啊，那么它具体解决了什么问题呢？它主要是解决我们业务软件开发过程当中业务变化比较多的这种，怎么去解决这个变化的问题啊，那么它具体怎么应用呢？那么显然是从我们刚刚的分析角度出发，首先我们开发的过程当中要遵循一些设计原则，好根据设计原则呢，把这些变化列出来，列出来之后去选择我们的设计模式。

好，那么我相信呢，这一个麦克老师应该讲的非常清楚了，好那么我们呢，来简单了解几个设计原则对不对，因为我们第一步就要去了解这个设计原则对不对？好那么麦克老师呢，来跟大家来看一下。几个设计原则。好，我们前辈呢，就是我们以往的开发的程序员呢，总结了这么一些设计原则啊，总共有这么多好，第一个是依赖导致，第二个呢，就是开放封闭，开放封闭是什么意思呢？好对扩展开放，对扩展开放好对修改关闭好大家需要注意的，我们的设计原则都是来应对。

都是应对变化的好，那么我们来看一下它到底是怎么应对变化呢？好开放和封闭，开放的是对扩展，开放就是对变化，变化开放好对什么封闭呢？对修改就是让我们不要去呃过多的去呃一修改一个地方呢，修改。的地方呢，才不要去修改过多的地方，去应对我们的变化啊，那么还有一个呢，就是面对接口编程，让我们尽量不要呃去关注这些数据对不对，我们应该关注封装数据后的接口，接口对不对，好，还有就呢，封装变化点好，单一职责，单一职责呢也是针对的一个变化，什么变化呢？就是我们的某一个类或者是一个对象呢，它的变化方向呢，应该是单一的，而不是有多种变化方向，如果有多种变化方向呢，那么我们牵一发动全身对不对，引起其他的联动变化，所以呢，我们尽量封装的时候。

满足单一职责好，大家现在不懂没关系，那老师呢，会带领大家看代码的方式呢，来了解这些设计原则好，那么还有一个呢，就是理事替换，理事替换呢，也是指的我们刚刚的对扩展开放的时候好，对扩展开放，因为扩展呢有两种方式，好马老师写一下。好，通常我们应对变化的有两种方式，就是去扩展它，怎么扩展呢？第一个啊，通过继承的方式去扩展，好，第二种呢，通过组合的方式来进行扩展我们的功能。啊，这个是我们常见的一种扩展方式啊，那么还有一个呢，就是这个理式替换呢，它主要是说的继承，就是我们进行类继承的时候，我们子类的接口应该要覆盖完全实现我们父类的接口的职责，好这个就叫理事替换，好那么还有一个呢，就是接口隔离，不要暴露客户不需要的接口给对方。

好，那么先大家整体了解一下好，那么这个就是组合优于继承好，因为呢，我们的继承它的耦合度强一些，组合呢，它的耦合度低一些，对不对啊，主要是从耦合度的角度出发来设计的一个设计原则，好，那么这些设计原则呢，大家呃，我。带领大家简单的看一下依赖导致原则，为什么要跟大家介绍依赖导致原则呢？因为我们大多数的框架，它需要好遵循我们的依赖导致原则，而且我们某一些类的设计呢，也需要依赖这个依赖导致原则。好，我们来跟大家介绍一下依赖导致原则。好，什么是依赖导致原则呢？迈克老师在这里呢，跟大家举了一个例子，就是我们假设呢，我们现在呢，有三个公司，比如说本田，丰田，宝马好，那么这三个公司呢，他们都有，因为随着现在我们对这个高科技的需求越来越高，对不对？我们希望我们的车子呢，有一个自动驾驶的系统，好，那么我们本身呢。

因为我们主要是做这种制造业的，对不对，制造业的这种高科技呢，我们可能需要把这些技术呢，委派给第三方公司来做好假设呢，我们现在有一个自动驾驶系统这样的一个公司，好，那么我们呢，所有的这一些大的平台呢，都像我们的这种。自动驾驶公司呢，来，呃，提出这样的需求，实现我们相对应的功能，就是比如说我们的本田，我们希望基于我们本田目前的这一个生态和系统，呃，来构建一个自动驾驶的系统，好，那么我们丰田呢，也会提出这样的需求，宝马呢也会提出这样的需求，那么这些需求如果我们作为啊自动驾驶系统的这个公司出发，我们不可能为每一个公司都去构建一个这样的系统，对不对？如果我们每一个都构建这样的一个系统的话，那么我们这个公司可能会需要很多的好，需要很多的团队，对不对，因为我们汽车厂商是很多的，对不对？好，那么我们希望怎么解决好这一个问题呢？好，那么我们可以在中间来构建一个标准，这个标准呢，就是我们自动驾驶系统，我们也是依照这一个标准，好，我们所有的其他的汽车厂商也是依赖于这一个标准。

好，那么就是我们根据这一个标准标准去提供一些接口对不对，提供一些接口好，那么我们自动驾驶系统呢，根据这一个标准呢，去制定相应相应的软件系统，对不对，供应一些软件系统好，那么呢，我们的软件系统呢，只应对于这一个标准啊，我们的这些接口呢，也是针对于这些标准，那么这样子的话呢，我们的软件就可以直接作用于啊，不同的我们的这些汽车厂商，那么就跟汽车厂商无关了，好，这个能听明白的朋友呢，帮麦克老师一就是这一个标准，能听明白的朋友帮麦克老师阿，好，那么现在我们知道了这个中间。

从这一个角度出发呢，刚刚马克老师又跟大家说了，我们去分析事件模式的时候，首先去找变化点对不对，好，那么我们现在来看一下，从这一个事件出发，我们来分析一下这里面的变化点是不是我们的变化点，第一个是这一个对象对不对，我们可能会产生多个对象，好，第二个呢，就是我们会每一个。为每一个对象去构建这种方法呢，这个也是动态变化的，对不对？那么我们应该要把这种稳定的东西呢，抽象出来，对不对，让变化的地方呢，在有限范围内变化好，那么我们应该怎么做呢？好，那么我们这种高层的应用，不要去依赖我们的底层的这些内容，好不不应该依赖底层这一些不同平台的啊差异去做抽象对不对？好，那么我们的底层呢，也不能因为比如说某某一些功能，这种自动驾驶的系统呢，它完成不了，那么呢，我们。

本田或者丰田要根据他的自己去做一些事情，这样呢也是不行的，对不对？好，那么我们不能够互相依赖，而应该呢，我们都去依赖这一个标准，对不对？好这个呢，就是我们的依赖导致原则的呃，一个描述，那么跟我们的这种框架有什么关系呢？好，跟我们的框架有什么关系呢？好，通常我们框架它要解决的问题就是去做一些底层抽象，好就是根据这个底层抽象去实现这一个功能，对不对，去实现它的功能，那么上层应用呢，好，我们根据底层抽象呢，去做一些不同的应用，比如说大家可能做个QT，对不对，好做QT那么不同的，我们都是用QT，但是呢，我们基于QT上面的实现的业务五花八门，对不对，好，有做金融的，有做其他行业的，做各各行各业的都有，对不对，我们是基于这个QT的框架做了不同的应用，对不对，好，那么也就是说我们的这种不同的应用呢，它是高层，好我们的底层抽象呢，显然我们也不会依赖上层的应用，对不对，我们只会实现我们中间抽象的这个标准，好，这个能听明白的朋友帮麦老师阿姨好，那么大家可能只是这个QT的具体的例子呢，还不足以说服大家对这个依赖导致的理解好，那么麦克老师呢，跟大家来举一个例子。

啊，就是框架构建符合我们的这一个。依赖导致到底怎么来理解好，那么麦克老师呢，跟大家举一个例子，那么举一个什么样的框架呢？当然呢，我们是因为我们的铃声学院主要是做西和西之家啊后台开发的，对不对？那么呢，麦克老师跟大家举一个后台开发的这样的一个框架。

好，那么我们马克老师呢，跟大家举一个scan的例子。An。好，我首先呢，把我们的整体原理图呢先发给大，呃呃，把这个图截出来给大家看一下，好，我们举的例子呢是scan。好，这个呢，是我们的scanner呢底层的一个原理图啊，大家看到这个呢，就是我们的scanner的底层原理图，那么我们的scanner它到底是就是我们中间的这个抽象层是什么呢？好，麦老师跟大家介绍一下，我们中间的这个自动驾驶的这个标准，它到底是什么呢？马克老师跟大家介绍一下，好，我们的scanner呢，它主要做了这么一些事情。好，它因为它是一个阿的并发模型，好，所以呢，我们最主要抽象的几个，就是第一个我们抽象的一种阿的一种方式，好阿呢是什么呢？阿是一个抽象的进程。就是我们用户层抽象的一个进程，好用户层抽的一个进程，我们的这个并发模型，并发是指什么呢？并发是为了我们的这些抽象的进程，他们可以进行并发执行带，因为呢，我们会根据CPU的核心数啊，我们的这个线啊，工作线程池。

好，它是根据它的数量，数量是。CPU的核心数。好，就是为了充分利用CPU，那么我们的这个线程数呢，它会就有CPU的核心数的个数是一样的，好，那么我们的这个CPU的核心数呢的这些线程呢，它就会去调度，调度这一些活跃的阿，那么也就是说我们有多少个线程，那么同时就会有多少个阿在同时运行，这个能听明白的不帮麦克老师阿姨，就是我们的阿并发模型是什么意思？好，就是我们抽象的一个进程，好并且呢，我们为了充分利用CPU，那么我们呢，给他一种并发的一种调度，那么并发的调度怎么实现呢？那么我们开启了跟CPU核心数相同的工作线程数量，好那么呢，他们去调度这些活跃的阿，什么叫活跃的阿，就是我们这些有消息的阿，好，那么呢，我们同时可能有工作线程数量的阿，在同时运行啊。

我们主要是实现了一个这样的一个框架，好，那么我们首先跟大家介绍，就是我们中间的抽象层是什么呢？抽象层是第一个是阿好，那么第二个呢，就是我们的消息好，第三个呢是我们的携程好，那么这一个抽象它到底是怎么来做的呢？好，大家注意啊，马克老师此时跟大家讲的是我们的这个底层的抽象。好，底层的抽象。好，也就是我们的低层的抽象对不对，刚刚我们是不是有三个接口对不对，还有一个高层的抽象，好高层的抽象呢，就是我们用户的抽象，因为呢，我们可能基于scan呢，会实现不同不同的我们的业务，对不对？好，这个是我们用户层的抽象，好那么我们来经过这种方式呢，来跟大家来了解一下我们的这一个，呃。

依赖导致原则是怎么来，就是我们这种框架是怎么依依赖这个依赖导致原则来进行构建的啊，那么我们首先来看一下这个底层抽象，我们底层抽象呢，刚刚迈克老师刚才说了对不对，我们是有一个阿好，我们要抽象一个阿这样的一个并发模型，对不对？好那么这种并发模型它是怎么来实现的呢？好，那么我们的阿这里会有几个问题阿是怎么运行的？啊。好阿，是怎么进行交互的？啊，进行沟通的好，以及我们。

好，麦克老师一个一个跟大家来解释，好，首先阿是怎么运行的呢？好，大家看到这里就是我们的阿，阿当中呢，每一个阿当中都会有这种消息队列，消息队列，那么我们的阿呢，它会包含一个消息队列，用来存储我们阿之间发送消息，或者是呢，我们网络当中给他发送消息呢，用来存储这些消息，那么大家可以看出来，阿是怎么运行的呢？阿就是通过。啊。回调函数好，加上它的参数呢，就是我们的这个消息通过这种方式呢，来运行我们的阿，好那么阿是怎么进行沟通的呢？好，显然我们阿呢是通过消息的方式来进行沟通的，那么大家看到，因为我们会有一个消息队列，为什么需要消息队列呢？因为我们这些消息发送到这个阿的时候呢，它会要有一个先后处理的顺序，对不对？好所以呢，我们会用一个消息队列来进行存储。

好，那么我们大家都知道了，就是基于这一种，我们要抽象这种模型呢，我们实现了一些内容，比如说我们实现了一个线程池，用来去调度具体的阿，对不对，好，我们用了这一个全局的工作队列呢，用来去组织这些活跃的阿，好让我们呢去调度这些活跃的act，好，那么我们还抽象了一些，比如说我们会把这种工作，就是网络线程当中的消息呢，发送过来呢，我们会把这些消息好，把这些事件好，把它抽象为具体的消息，对不对，好，还有呢，就是我们具体的定时任务呢，我们也会把这些任务抽象成消息。好，我们把这里面做的事情呢跟大家说一下，就是第一个网络性网络事件。好，抽象成消息啊，以及我们会把定时任务好啊，这个具体的任务抽象成消息好，那么大家可以看出来，我们底层其实做到的一个事情呢，就是。

好将我们因为我们要实现这样的三个关键字，对不对，Act消息好，那么呢，所以呢，我们就基于这一块的内容呢，就是把这些网络的消息和或者是定时的消息呢，去封装成消息，对不对，好把这些具体的阿呢啊，我们会用一个lor虚拟机来进行实现，好这里呢阿是luva虚拟机。好，那么我们简单的就是底层的抽象呢，我们已经了解了，就是这些，这个就是我们底层的抽象，那么我们再来看一下我们用户层的抽象是什么呢？好，我们用户层的抽象是什么呢？好，我们的用户层就是如何去调度我们的阿，好怎么去如何去抽象我们的阿。好，什么叫如何去抽象阿呢？好，就是我们怎么去将我们业务当中的对象去映射成阿。

好，这句话怎么来理解呢？好，那么我们scan呢，常用有这么几种用法，比如说我们一个阿专门用来实现某一个玩家的数据啊，或者是一个用户的数据，对不对，我们这一个用户都只往这一个阿当中进行操作啊，比如说我们玩一个游戏，某一个游戏当中的一个房间，房间数据好，我们用一个阿去好，这个呢，就是我们用户层的抽象，这个能听明白的朋友帮马克老刷一好，我们用户层的不同的抽象就构建出来了不同的基于SKY的应用。好，就是这个就是呢，我们的一个依赖导致原则，在我们具体框架构建的时候的一种应用。

好，依赖导致原则，好，这个能听明白的朋友帮忙看声音好。那么我们的构建的标准是什么呢？我们高构建的标准就是这个阿模型对不对？好，那么我们的上一层高层的应用是在做什么呢？我们高层应用怎么来做呢？好，就是怎么去抽象阿，因为我们已经构建出来一个这样的基于阿的一个系统，那么我们要做的就是将业务当中的一些对象把它抽象成阿。好，这个呢，就是我们的依赖导致原则。好，那么我们跟大家介绍完依赖导致原则之后呢？啊，麦克老师来跟大家介绍一个简单的设计模式，我们来看一下设计模式。它是怎么由设计原则好过渡过来的？好，通过几个例子来跟大家来介绍。好，首先呢，麦克老师跟大家来举一个案例来帮助大家来理解。

好，那么我们首先呢，来看一个这样的一个背景。好，首先我们来看一下这个背景，我们来看一下怎么用我们的设计原则构建设计模式。好，首先呢，我们来看一下，就是某一个品牌动物园，它有一套呢固定的表演流程，有一套固定的表演流程，但是呢，其中有若干个表演子流程呢，可以创新啊，替换啊，以尝试迭代更新表演流程。好，那么大家刚刚麦克老师跟大家说了，我们怎么去应用我们的设计模式啊，首先呢，我们应该写代码的时候遵循设计原则，好，那么我们呢，需要做的呢，就是把业务变化给列举出来，对不对，好那么迈克老师把这个呢内容呢写的更加详细一点，就是我们怎么应用设计模式啊，就是将需求。

我们首先呢，需要把这个列举出来啊，就是把我们的需求当中的稳定点和变化点给列举出来，我们实际上呢，做我们的设计模式的时候呢，首先就是要把我们当中的变化点和稳定点变化，把它列举出来好，那么大家需要跟大家介绍的是什么叫变化点，什么叫稳定点呢？稳定点就是它不会变化的点好，变化点呢，就是我们业务的变化的方向有哪些好，我们把这些东西呢给列举出来，好，那么大家可以看马克老师的这一个描述，我们看到固定的，那么大家可以看出来了，固定的表演流程，那么说明呢，此时这一个流程它是一个稳定的。

它是一个稳定的，那么变化的点是什么呢？就是这一些流程当中的节点啊，子流程它是变化的，对不对啊，我们可能会发生变化，好那么我们呢，把这个变化点跟稳定点列举出来之后呢，我们才能够去探索设计模式，好那么麦克老师呢，也在这里跟大家介绍一下，如果变化点啊，就是某一个项目只有变化点。好，只有变化的，没有稳定的地方好，不能够用使用设计模式好，如果只有稳定点呢，也是不需要设计模式的好，只有既有变化点又有稳定点的时候，我们才能够使用设计模式，这个能听明白的朋友帮麦老师阿姨就是如果只有一个，那么呢，我们设计模式根本是用不到的。好，那么我们刚刚麦克老师也跟大家说了，我们的设计模式呢，主要是它的作用呢，就是主要作用在这个变化点，就是怎么去应对变化，对不对，我们的设计模式的作用就是怎么应对变化。

好，那么呢，我们来看一下。基于这一套，我们看一下怎应该怎么来实现。好，那么麦克老师呢，提前在这里边已经准备了代码，好后，大家看到这个呢，是我们的第一个版本，第一个版本我们是不使用设计模式的情况下，不使用设计模式的下，我们是怎么来实现这个功能的？首先呢，我们会有一个棕兽对不对？有一个动物园的表演，那么我们用一个类呢，把它进行封装，那么这个动物园的封装，我们要封装它的具体的流程对不对，我们要把这一个固定的流程把它给封装，对不对，有一个固定的表演流程，那么这个表演流程当中呢，有子的表演流程好，比如说兽灵，兽一兽二，兽三好有不同的表演流程，好，那么麦克老师呢，为在这里为了跟大家介绍这个理事替换，那么呢，马克老师在这个受灵的这个地方呢，加上了一个play games，好，这个呢就相当于中场的游戏环节，中场的游戏环节就是我们动物园里面有很多的表演，比如说有猴子骑单车，还有呢，我们的比如说狗熊踩钢丝，对不对？

啊，它有不同的环节，那么在第一个节目完成之后啊，如果没有超时，我们在这里呢，跟大家举个例子啊，如果超时了啊，如果没有超时。好，那么呢，我们就会进行一个游戏。啊，如果超时了，我们直接进进入下一个环节。好，那么大家可以看出来，马克老师在我们的这个租售封装的时候呢，大家可以看出来，Public当中啊，除了这个构造函数，只有这一个接口，只有这一个接口好，为什么马克老师不在这里面把其他的接口全部给列举出来的啊，如果我们在这里面写一个public，把这种兽灵，兽一兽二跟兽三全部用public来进行修饰的时候，这个时候呢，他就不满就满。

好，他就不满足我们的接口隔离原则，这个能听明白的朋友帮忙看到刷一什么叫接口隔离呢？就是不要让用户去选择他们不需要的接口，好那么大家需要注意我们的动物园的表演呢，是必须这四个流程都需要跑道对不对？好如果我们在这里面写一个public，那么对于用户而言，对于用户而言，就是我们调用这个类的用户而言，它呢会自由的选择，比如说我们会只掉兽灵，好只掉兽一，好只掉兽二，这个能听明白的朋友帮马卡刷一，首先呢，我们需要考虑。接口隔离原则，这个接口隔离原则能够听明白的朋友帮马就是我们在这里面把用户不需要用到的接口，我们应该用private把它进行隔离出来，好，不要让它去选择他们不需要的接口，好这个呢是我们的接口隔离原则好那么满足接口隔离原则之后呢，我们首先来看一下我们是不是要考虑一个对扩展。

好，还有一个呢，就是对扩展开放，对修改关闭是什么意思呢？好开辟原则。对扩展开放。对，修改关闭。好，我们来看一下。因为我们会进行一个迭代，对不对？大家思考一下，刚刚麦克老师跟大家说，我们的这个电话点就是我们的子演表演子流程，它随时可以会进行创新和替换，对不对？所以呢，我们真正的变化点就是这里面的小环节，对不对？好，那么这些小环节如何来让他进行变化呢？对不对，如何让它进行变化呢？好，那么按照我们普通人的想法呢，我们就在这里面通过这个构造函数传一个参数，好这个参数呢，来代表着我们每一次的迭代创新，好比如说我们的兽灵啊，比如说我们的兽医，我们现在第一次的创新，比如说type，等于一第一次创新的时候，那么呢，我们就给他。

创新的内容在这里面好，比如说我们的第二次创新，我们就写在这里面，好，第三次创新呢，我们就写在这里面，对不对，好，以此类推，比如说我们的第一次创新，除了在受理兽医当中，我们还要在受三当中进行创新，那么呢，我们就在这里面写它相对应的逻辑，好这个能听明白的朋友帮忙，老师阿音，那么大家思考一下我们这种方式，它。好不好呢？那么他触犯了我们通常的设计原则的哪一个呢？好，那么大家思考一下，其实我们是不是触犯了我们的刚刚所说的开辟原则，因为呢，我们。

总是去修改这一个的接口，其实呢，他去修改了我们的类的内部的本身，其实我们是不是对对修改开放了，对不对，我们通过这个可以不断的去修改它的。修改里面的具体的实现，这个能听明白的朋友帮马老师刷一好，那么我们如果要对修改关闭的话，那么我们不应该把这个参数呢给传进来，那么我们应该是通过扩展的方式呢，去去扩展我们的新的功能，好这个能听明白的朋友巴巴可。啊，看不懂CC加没有关系，看不懂这个跟我们的Java呢差不多，对不对，跟Java或者是其他的Python呢，这些语言都差不多，只要是这种面向对象的语言呢，它本质上呢是没什么，就是我们大部分的这些思想呢，都是可以应用的，对不对，好那么我们来看一下这个呢，是基于这种我们不使用设计模式的时候。啊，大家可以看出来，它不满足我们的开闭原则对不对，好但是呢，它满足我们的接口隔离原则对不对，我们用户不会随意任意调用我们不需要的接口，好那么我们基于这一个的基础上呢，我们来怎么来？

去满足我们的开闭原则对不对？好，我们怎么去开辟的原则呢？好，首先呢，我们应该把这个修改关闭掉，也就是我们不要传舱来修改我们里面的数据，对不对？好，那么我们应该让他通过扩展的方式呢，来进行扩展它的功能，好扩展的方式呢，麦克老师又跟大家说了，扩展有两种，第一个呢是通过继承的方式，第二个呢，是通过我们组合的方式，对不对，好那么现在呢，我们来看一下怎么来进行扩展。好，麦克老师呢，在这里面使用扩展的方式呢，采用继承的方式，为什么采用继承的方式呢？因为我们还可以，因为我们只是对若干的流程进行扩展，对不对？好，那么我们现在呢，还需要来进行一个优化，因为呢，我们如果通过继承的方式呢，那么这一些接口都应该是一些虚函数，对不对，好，这样呢，我们子类的时候才可以去扩展这些接口，这个能听明白的朋友帮忙11好，那么子类需要去访问这一些接口的话，那么这几个呢，方法呢，应该要是我们的虚函数对不对，好，这个是虚函数，那么现在我们。

写这个鸡类的时候呢，我们同样的要考虑这个接口隔离原则，对不对？接口隔离原则，也就是说让用户不要选择他们不需要的接口，好那么所以呢，我们在这里面为什么使用protected，为什么要使用这个限定词，知道的朋友把刷一我们刚刚是不是在这里写的是private限定词，现在我们为什么要改成protected。好，我们为什么要改成这个接口，而不是用private？好，如果我们用的话，那么大家思考一下，它的子类能不能够访问到呢？

好，所以呢，我们在这里面必须要改成因为private我们子类访问不到，子类访问不到，我们怎么去扩展你的功能呢，对不对，我们怎么去扩展你的功能对不对？所以呢，我们在这里面需要修改为protected好受保护的状态，受保护的状态呢，我们此类就可以访问了。好，这个能听明白的朋友帮帮朋友刷一。好，那么现在呢，我们大体的流程知道了之后，我们主要来看一下怎么去扩展，因为呢，我们的设计模式主要解决的设计模式主要解决的问题是什么，解决的是怎么好把这个变化点给封装，对不对，变化点封装，让我们的变化点呢，在我们可预期的范围内呢去变动，好那个老师呢，把这个找变化点呢，用一个通俗的例子跟大家来举一下例子，让大家理解这个变化点到底是什么意思，我们设计模式到底是怎么解决这一个变化点呢？好，那么呢，大家可以把它想象成大家我们现在有一个干净的房间，有一个干净整洁的房间。

好，那么我们在这个干净的整洁房间当中呢，有一个好动的猫。好，那么大家可以看出来，这个整洁的房间呢，肯定是一个稳定点房间是稳定点，对不对？好，那么现在这个好动的猫，好，这个好动的猫它是一个变化点，对不对？好，它是一个变化点，因为它可能在这个房间当中到处乱动，对不对？好，到处乱动呢，它就会去影响我们这个干净整洁，好现在呢，我们设计模式呢，其实要解决的问题呢，就是跟我们现在要解决的问题是一模一样的，现在里面有稳定点，也有变化点，那么我们设计模式要做的事情是什么呢？我们设计的模式的重点是让这一个猫在有限范围内变化，所以呢，我们在这里面需要使用一个猫的笼子啊，就是猫笼，把这个猫呢放在这个笼子里面，好让它在有限范围内活动，而不至于影响我们整个房间的整洁，好这个能听明白的朋友帮忙卡刷一好我们设计模式要解决的问题。其实。

就是给它加个笼子，也就是我们把这个变化点给封装起来。好，那么我们现在知道这个之后呢，我们来看一下，现在我们是通过扩展的方式来解决这一个啊变化的好，我们的变化点呢，都已经封装了，对不对，用虚函数，用虚函数已经封装好了，并且呢，用protected，用protected呢，就是我们用户用户访问不到它，访问不到这几个接口，好子类可以访问它，就是我们子类对象可以访问到它，好用户用户只能访问protect public对不对，用户只能去访问public，好private跟protected呢，用户是访问不了的，好此类呢，我们可以访问这个public，也可以访问这个protected，对不对？好，受保护的字段我们是可以访问的，好那么基于这些封装之后，接下来呢，我们就来扩展这一个变化点，怎么扩展呢？好，假设我们现在呢。

对兽灵跟兽二来进行了一次封装啊，进行了一次迭代创新，好，那么我们把这个具体这个活动呢，把它进行了一个修改啊，进行了一个修改。好，那么接下来的问题来了，刚刚马克老师跟大家说了，我们为什么马克老师在这里面加上一个这个少林好，再加上一个play game呢？好，因为呢，马克老师要跟大家介绍一个理事替换的。好理事替换的概念，什么叫理事替换呢？好理事替换就是我们在继承的过程当中，刚刚麦克老师跟大家说了，我们做这一个扩展有两种方式，继承和组合，对不对，好，那么我们对于组合的扩展而言，我们需要关注一个点，好，对于。

啊，对于继承的扩展。好，需要满足理事替换。好，那么什么叫理式替换呢？就是我们负呃子类的接口，大家看到我们受零子类的接口，要实现父类接口的职责。好，子类接口。需要实现父类接口的。啊，负类。负类接口的职责，职责就是功能好，那么我们来看一下我们的这个负类的职责是什么呢？负类的职责是。如果我们的兽灵这个活动超时了的话，好，那么我们就啊，没有超时的话，我们就会去玩这个play game好，如果超时了，我们就直接进入兽医好，直接进行兽医好，这个能听明白的朋友帮班老师刷一，这是他的职责，职责能理解的朋友帮麦老师刷一，好我们理解了这个职责之后呢，那么我们呢，在这里面应该要去实现他的职责，也就是说我们在这里面应该要做相同的判断，而不是现在像这样的直接return出，直接return出呢，就是我默认你没有超时好，这个呢，如果只有一个return出，那说明没有满足负类接口的职责。

好，这个能听明白的朋友帮麦克声音，所以呢，我们子类替换的时候一定要实现父类的职责，好这个就是他的职责。这个就是我们的理事替换的这个设计原则的概念，好，麦克老师也跟大家说了，他是在什么场景下，是在我们做设计模式的当中的这个继承扩展的时候啊，就是我们扩展方式使用继承的这种方式的时候，我们需要满足理事替换原则。

好，这个扩展可能大家又不记得了，那麦克老师跟大家说一下开辟原则，开辟原则就是对扩展。开放，对。修改关闭。好，那么大家应该知道这个对修改关闭是什么意思了，对不对？修改关闭呢，只会让我们原来稳定的也变得不稳定，好所以呢，我们应该去扩展它，好那么扩展有两种方式，继承和组合，好如果我们使用继承的扩展方式，那么我们需要满足理事替换原则，好，这个逻辑应该很通的吧，对不对？好，那么呢，我们还可以，如果我们要对兽一跟兽二进行扩展，那么呢，我们只需要去覆盖它的接口就行了，好比如说我们兽一兽三兽四好那么我们相对应的实现它的接口就行了。好那么我们用户去使用的时候，那么我们只需要去选择相应的迭代版本的这一个类好，用这个鸡类等于用这一个我们迭代版本的这一个类，然后呢，再去售就行了，对不对。

好，那么我们满足设计原则之后，这个是我们满足设计原则后，好重新设计的我们的这一个接口，好，那么大家需要注意的是我们这一个设计的套路。好，满足设计原则后的套路，它就是我们的模板方法类就是我们的模板方法。好，这是我们的今天的设计模式，设计模式当中的模板方法，这个能听明白的朋友帮忙刷一。好，那老师呢，也给大家看一下这个模板方法的定义，模板方法的定义是定义一个操作算法的骨架，将这些步骤延值到子类当中去实现，好那么我们呢，通过扩展这个股价当中的子算法，好那么呢，我们就可以重新定义该算法的特定步骤。

啊，这个能听明白的朋友帮忙刷一。好，这个呢，就是我们如果这个算法的股价它是固定的，那么它这个呢，就是稳定点，变化点是什么呢？变化点就是我们的这些子流程，好把这些子流程我们是可以扩展，我们可以通过虚函数覆盖的方式呢，来实现这个啊子方法的扩展。好，这个就是我们常用的模板方法。好，那么大家刚刚是不是可以看出来，我们的设计模式它是怎么应用的？好，刚刚麦克老师跟大家说的，我们是怎么应用的，好就是在迭代中在满足。设计原则的基础上。好慢慢迭代出来的，对不对。好，我们用红色的把关键字写出来，好。

今天呢，我们就跟大家说了一个这个模板方法对不对？模板方法呢，是最能够体现我们设计模式的的一种方法，好那么麦克老师呢，等一下还会跟大家介绍一下其他的设计模式，好那么接下来呢，我们来跟大家说一个我们在面试的过程当中经常问到的啊，这个呢，也是我们去年有一个字节跳动的啊，学员去面试的过程当中问到的一个问题啊，就是策略模式，责任链模式，装饰器模式，它们之间的区别。好，那么我们来跟大家介绍一下这几个模式的区别。好，那么大家有没有听说过这些设计模式？听说过的朋友帮麦克老师刷个一，没有听说过的朋友呢？帮麦克老师刷个二好吗？好，听说过的刷个一，没有听说过的刷个二，好，那mark克老师呢？依次跟大家来进行解释一下这几个设计模式到底是什么含义？好，首先跟大家介绍一下策略模式，好，如果我们的马克老师直接像刚刚那样给大家几个定义呢？可能说服不了大家对不对？好，那么我们以具体的例子来跟大家来介绍。

好，那么假设呢，我们现在做一个假设，假设现在那克老师呢，需要从我们以一个简单的例子跟大家来出发，好，假设好，那克老师好，现在呢，要从长沙去啊，去深圳找我们的这位贿赂朋友。啊非好，我们假设呢，我们要去找这一位朋友，去深圳去找这位朋友，那么我们应该怎么去找呢？好，那么我们来看一下这几种设计模式是怎么查找的，怎么去找它的，好那么我们来跟大家来画一个图，假设呢这个是长沙，好这边呢是深圳。

好，那么大家知道我们从长沙去深圳呢，有多种方式，有哪几种方式呢？好，第一种途径我们可以。好，最土鳖的一种方式，我们就是去骑行，过去假设迈克老师呢，现在非常的闲，那么我们呢，就采用骑行的方式去。好，那么第二种呢，我们还可以去采用通过自驾啊，因为麦克老师呢，啊也是有驾照的，对不对，那么麦克老师可以通过自驾的方式呢，去深圳找他。啊，也就是八个小时对不对啊，八八到十个小时就可以到深圳啊，那么还有一个呢，我们可以坐高铁对不对啊，我们也可以通过去高铁的方式呢去深圳。当然我们也可以坐飞机对不对啊，我们长沙呢有黄花机场，可以从黄花机场呢，直接去我们的深圳对不对。好，那么呢，我们也可以坐飞机过去。

好，那么我们的这个策略模式是怎么来形容我们的这个事情的呢？好，假设呢，现在。马克老师已经到达了深圳，已经到达了深圳，那么我们的这位贿赂朋友呢，就会跟马克老师说，他说你。啊，我们还没有去，麦克老师重新描述一遍，就是我要去这个深圳，然后呢，我们的惠乐朋友呢，就给麦克老师打了一个电话，他说嗯，麦克老师，你打算采用哪一种方式，采用哪一种方式到深圳呢，对不对，好就是也就是说我们通常呢，有多种方式去实现这一个呃功能，但是呢，我们只会按照我们所需要的去选择一种方法，这个呢，就是策略模式，好，这个能听明白的朋友帮马老师刷个一，就是有几种方式去。好。

好，你选择的是哪一种方式对不对。好，这个能听明白的朋友帮麦刷一好，如果我们换一句我们程序的思呃的话来说呢，就是有多种方法实现。好，那么呢，按需选择一种方式实现方式。好，这个能听明白的朋友帮帮他声音就是我们要实现一个功能，对不对，我们有多种算法去实现这一种功能，那么呢，我们把这些算法呢，都把它抽象出来，好，那么我们在这里的变化点跟稳定点是什么呢？好，变化点就是我们还可能继续增加不同的，呃，从长沙到深圳的这些途径对不对？好那么这些途径呢，我们可能也是未来我们选择的一种方式，对不对啊，这个呢，就是我们的变化点，这个能听明白的朋友帮马刷一，这个呢就是策略模式，我们按照需要去选择一种实现方式。

那么大家注意重点呢，我们是有多种方法去实现好，这个是策略，策略模式好，那么还有一个呢，就是责任链模式。好，那么什么是责任链模式呢？那么我们同样的也是以这个例子，我们也是从长沙到深圳。好，假设呢，我们依然是从长沙。依然呢，是从深圳。啊，从长沙到深圳，那么现在呢，我们可能呢，同样的我们也有这四种的交通方式，对不对，但是呢，马克老师所住的地方好，马克老师呢，打算用这四种方式呢，去深圳，也就是说马克老师现在先骑行好走到先回家对不对，现在迈克老师在公司里面对不对？好我先呢，需要回家一趟，好先去我自己的家里面，自家里面呢，我们先在做好自己开车，自己开车呢，呃，到我们的某一个。

好到达我们的高铁站对不对，高铁站，然后我把车呢放在高铁站，然后我接着呢就去坐高铁，好坐高铁好坐完高铁呢，我们是到，比如说我们坐高铁到，呃到哪里好呢？好假设呢，我们到广州，坐完广州之后呢，马老师又坐飞机，坐飞机呢好到达深圳好这个能听明白的朋友帮马克老师阿姨，大家都先不不用去考虑他的合理性，现在呢，马克老师就是要采用这四种方式呢，去去我们的深圳好，这个呢就是我们责任链模式，我现在呢有多种。有多种交通方式到达我们的这个深圳，并且呢，我是按这按照这一个次序过去好，那么呢，我们在这里面有一个责任链模式，有一个很大的不同，就是好，一旦满足有一个不满足条件呢，我们就去打断去深圳的流程，好什么意思呢？就是比如说迈克师自驾到达高铁站的时候，发现高铁站没有车了，好已经晚点了，好到达晚上了，那么呢，马克老师就不去了，马上又回去啊，马上回去好，那么还有一种呢，就是我坐了高铁到达广州之后，发现飞机已经晚点了好，那么呢，那克老师也不去了，那么现在呢，又回去啊。

麦克老师还是把这个图给大家画一下，麦克老师呢，总共要去采取四种方式好。假设马克老师呢，要采用四种方式去到达深圳。好，那么现在呢，就是我们任意一个，我们可能在任意一个阶段呢，就好直接返回。好，也就是把我们的这个整个流程打断了啊，这个能听明白的朋友帮老师阿。啊，就是。有多种方式。

嗯。啊，有多种方式按顺序。啊，按顺序。好，按顺序到达目的地。好，什么情况呢。你就不去了，好，这个呢是我们的这句话的意思就是大家看到我们有多种方式呢，并且我们需要按照这个顺序呢，去到达某一个地点，好，那么可能呢，由于一些原因呢，我们就可能就不去了，一中途的某一个环节不满足条件呢，我们就打断了整个行程，好这个呢就是我们的责任链啊，如果我们用几个关键字来描述的话，就是它有多个步骤，好那么这些步骤呢，是顺序的好按顺序。好，他需要按顺序去传递我们的这一个步骤。

啊，并且呢，我们可以打断。好，这个能听明白的朋友帮帮他刷一就是我的目的地是深圳，但是呢，我们不一定要一定要去深圳，好，我们按照这几个步骤呢，好依次去尝试去，好如果中途我们啊坐高铁的时候，发现是飞机已经晚点了，我们就不去了，好这是一种方式啊，这是这种打可以打断的这种方式，好这个呢就是责任链模式，好有多个步骤，并且呢，它是有顺序的啊，那么我们呢，是可以打断的啊，这个呢就是我们的这个责任链模式。好，那么为了跟大家来比较这三种，那么接下来呢，马克老师再跟大家介绍这个装饰器模式。好，装饰器模式呢，同样的，我们是从呃长沙到深圳，但是呢，麦克老师到达深圳的时候呢，我们的贿赂朋友呢，就问马克老师啊，你做了哪几种交通工具过来的好用一句话就是啊，马克老师做哪种做哪几种。

好，那么呢，它跟我们的责任链呢，有一点点类似，好什么类似呢？就是我们也是采用多种方式呢过来的，好，但是呢，我们并不要求顺序，从这个话大家应该可以看出来，你是做哪几种交通工具过来的，我们并没有让你说出是按什么顺序过来的，对不对，好，我们的责任链呢，它是有顺序的，好，那么我们的这个装饰器呢，它是没有顺序的，但是呢，它也是多种步骤的，对不对，多种步骤到达我们的深圳的好，这个能听明白的朋友帮忙，大老师阿姨，就是我们同样的也是从长沙到深圳，同样的呢，我们也用采用了这四种交通方式到达了我们的深圳，但是呢，我们这里面不要求顺序，你只需要说出你是采用哪几种方式过去的，好，就是我们不要求顺序，我们只要求最终的结果就是你到达深圳了对不对，好我们的责任链呢，它是并没有到达，就是不一定到达深圳了，他可能在中途呢，就被打断了。

好，那么我们的这个长沙到深圳的策略模式呢，就是啊，必须采它也到达了，但是呢，它只采用了一种方式到达的，好这个能听明白的朋友帮忙看刷一，那么这个呢，就是长沙到深圳，如果我们用一句话来总结的话，那么就是好。多个步骤，好无序的，我们只强调最终的结果，对不对？好，只强调最终的结果。好，当然呢，它是不能打断的，就是我们一定要到达到达深圳对不对。

好，这个能听明白的朋友，巴巴卡衰，就是我们这不同的几个设计模式，策略模式呢，我们是按照一个方法呢到达了深圳，但是呢，我们有多种选择，我们是按照我们自己的需求呢，选择出了一种方式去到达深圳，责任链呢，就是我们在这里面呢，有多种方式好有多种方式到达深圳，但是呢，我们是按照多个步骤好按照步骤依次到达我们的深圳，但是呢，我们每一个步骤它都有一个打断的条件，就是有一个打断的条件就是我不去了，就是我不去深圳了，好，每一个步骤我都有一个条件，我不去了。好，那么呢，我们的装饰器模式呢，就是我们从长沙到深圳，我们总共采取了几种方式，比如说我们先骑行，然后再坐飞机，然后再呃，然后再我们的骑呃自驾，然后呢再坐高铁也是可以的，那么这个顺序呢，是无所谓的，我们只强调最终的结果就是你到达了深圳。

好，这个呢，就是我们不同模式的一种区别，那么大家如果在面试的过程当中，如果把它用一个很形象的例子把它理解之后呢，那么大家自然而然就知道怎么去知道他们的区别的回答对不对，好，那么接下来呢，麦克老师来跟大家介绍一下。Engines的核心流程是什么样的模式？是采用的什么设计模式。那么我们的op它在。And的上面，它是如何来进行构建的？好，我们来跟大家介绍一下第五个。好，那么首先呢，我们需要来了解engines的核心流程是什么，好engines呢，它是一个呃，静态外部服务器，对不对，好，那么呢，同时呢，它也是我们的。

好，他经常做我们的反向代理对不对，反向代理服务器对不对，好，那么我们的这个核心流程是什么呢？核心流程就是我们需要把我们把这个应用图呢，跟大家画一下啊，这个呢是我们的请求方。请求方这个呢，是我们中间呢，是我们的ending代对不对，好，那么后面呢，就是我们后端的外部服务器对不对，好后端的外部服务器，那么我们通常呢。将我们的客户的请求，然后呢，经由我们的endings把它路由到相对应的外部服务器当中，对不对，静态外部服务器当中。好，静态外部服务器呢，我们首先需要解决的一个问题就是要去解析协议对不对，那么我们通常需要解析的协议呢，就是我们的HTTP请求对不对？好HTTP请求好，那么这个HTP请求是怎么进行转发的呢？好，那麦克老师跟大家介绍一下我们engines是怎么来做的，好engines呢，本身它会呢，基于一个对HTTP的请求。

好设置了啊，11个阶段，那么我们。好，我们对HTTP的处理请求呢，设置了11个阶段，好，那么我们根据这11个阶段呢，然后再处理我们的这整个HTTP请求，好那么HTTP的请求包含哪些部分呢？好，大家可以思考一下，首先。我们是不是要处理接收来自客户端的连接，对不对？第一个我们肯定要处理客户端的连接。好，那么这个客户端的连接我们通常是怎么进行处理的呢？大家我相信大家应该做过网络编程的朋友应该都知道，首先接收连接的时候，我们需要一个client，然后呢，通过接收对不对？好，Address跟size对不对？好，那么我们通过这一个接口呢，就可以接收这个客端的连接，那么接收这个客户端的连接，我们能够做哪些事情呢？大家思考一下，好IJ跟size，它能够帮我们做什么？J跟size就是我们客户端的来源的IP地址跟端口，好就是它的它是从哪一个IP，以及它是从哪一个端口过来的，我们可以通过跟size呢，算出来这个东西对不对，算出IP跟port啊，那么大家可以跟。

大家可以看到这个客户端连接的时候，我们能做什么事情呢？是不是我们可以做黑白名单对不对？我们根据客户端的IP地址，他过来的IP地址，我们可以做一些黑白名单对不对？假设我们现在对HP的功能，这一个转发功能，我们现在要加一个黑名单的功能，那么是不是在客户端连接的这个地方，我们就可以把这个，如果他在我们的黑名单当中，我们是不是直接可以把这条链接掉，这个能听明白的朋友帮麦老师刷一，我们是不是可以在这一个步骤当中直接把这个客户端的链接踢掉，对不对？好，那么接下来接收客户端的链接之后，我们是不是要开始解协议了，好，解协议。

嗯。好，现在我们要解协议了解协议呢，我们的HT大家都知道有二，有body对不对，有头和我们的具体的content对不对，具体的content的内容对不对？好，那么大家来看一下我们的头和我们具体的包体，包体内容，那么我们根据头当中，大家如果做过我们的nu开发的朋友应该都知道，在我们的头部是不是有通常有token相关的，对不对，他在token呢？它是要放在我们的这个号当中的，对不对？好，那么大家思考一下，这个token又能帮助我们干什么呢？好好，你就是基于open rusty开发的，对不对，好，那么我们来跟大家来看一下，那么这个token它用来干什么的呢？

好，那么基于这个token大家可以干什么？是不是可以做一些登录验证？对不对，我们根据这个token就可以做登录验证，那么大家思考一下，如果我们的这个token它是一个错误啊，对，身份信息对不对？那么如果这个token它是一个错误的信息，那么我们是不是如果我们找到了根据这个token，那么是不是我们直接可以把这个链接踢掉，对不对，直接把这个，因为它验证都没通过，那么我们显然就可以直接把它给踢掉，所以呢，我们还有没有去必要去解这个下面的body呢？对不对，好body底就没必要了，对不对，好body底里面呢，就是具体的业务处理了，对不对？好，业务处理当中呢，可能又会有多种流程，这里面肯定有多种业务流程，对不对？因为我们多体当中会有不同的请求的一些字段，对不对，有一些请求的字段，我们可以根据这些字段呢，再去做一些相对应的业务逻辑，如果相对应的业务逻辑不满足条件，我们是不是又可以退出啊。

好，那么剩下的全部满足的情况下，全部满足的情况下，是不是就转发到我们的后端外部服务器了，这个能听明白的朋友帮麦克刷一，知道这个流程的朋友帮刷一，好那么大家根据这个流程，大家思考一下，我们现在是符合这里面的设计模式的哪一种是属于测定模式呢？还是责任链模式呢？还是装饰器模式？啊，对我们的贿赂朋友呢，说的非常棒，那么呢，显然我们在这里面应该要使用责任链模式。好，那么这个责任链模式它具体的具体具体是怎么来应用的呢？好，那么马克老师来通过带领大家看一下源码的方式呢？我看一下我们endings到底是怎么实现的责任链模式，好，那么责任链模式呢，我们使用，那么大家还带着一个问题，我们是怎么。大家思考一下我们平常是怎么使用设计模式的，就是不是我们通常项目当中已经有了设计模式，对不对？好，那么作为普通的开发人员而言，我们是怎么使用设计模式的呢？是不是我们应该要知道这个设计模式是怎么扩展的？好，我知道，就是我们现在有变化点，我们是怎么来添加变化点，基于现在已有的设计模式，我们怎么添加变化点，这个能听明白的朋友帮马刷阿一，那么等一会儿大家呢，就带着这一个点去看我怎么使用。

这个设计模式啊，我希望等一下看源码的过程当中。啊，大家呢，思考一下我怎么来用这个设计模式。什么叫我怎么用这个设计模式呢？就是现在我们增加一个新的变化点，我怎么在它的基础上加代码，这个能听明白的朋友帮麦克老师阿姨好，就是我怎么去用它。好，那么大家呢，我等一下呢，带领大家看源码的时候呢，大家就带着这个思路呢，去看去思考，好那么接下来呢，麦克老师给大家看一个源码。

好，稍微等一下我们。等一下我找一下代码。好，稍微等一下麦克老师呢，先来找一下代码。上一集。好，麦克老师已经找到了。好，那么现在呢，那克老师已经找到了一个啊，我们的opty大家没关系，我们的opty呢，它是基于我们的ending的，所以呢，我们直接看ending的源码啊，直接看op的源码呢是可以的啊，那么首先呢，我们来找到这个。

这个的实现好，因为我们刚刚是基于11个阶段的，大家能听明白的朋友巴麦克老师阿姨，刚刚麦克老师跟大家说了，我们的HTTP的请求，它是在11个阶段当中处理的，对不对？首先呢，我们就需要来理解我们的这一个阶段，它是怎么来定义的，好这个呢，就是我们的一个阶段的定义，我们先把它进行截图啊，边看源码的时候呢，我们先把它的逻辑关系呢，把它捋清楚啊，这个呢是我们的责任链啊，这是我们不是责任链，是我们的这一个11个阶段的定义，对不对。好，11个阶段的定义，那么我们的阶段定义当中呢，我们再来跑到这里面来进去看对不对，看它到底看是一个什么样的类型啊，我们把它的图呢也截下来。

好，那么呢，现在我们的11个阶段呢，大概就是这个样子，好，我们看一下是不是11个阶段。好，大家可以看到这里面呢，它是等于十的十加上一，那么显然是11个阶段，对不对，11个阶段，那么我们每一个阶段呢，每一个阶段又是它这个类型对不对？每一个阶段是这个类型，那么大家看到每一个阶段当中，它是hands，好，Hands马克老师跟大家介绍一下，Hands的里面全是这种回调函数，Call back回调函数，大家呢？呃，对于CC加，大家可以把它抽象为具体的接口，或者是某一个类的抽象接口都是可以的，好。这个是error，也就是说我们在这里面，这个error呢，是数组的意思，好，那么这一个呢，又是数组的意思，那么大家猜测一下，我们的这一个11个阶段，它到底是一个什么样的结构，是不是一个二维数组，能听懂的朋友帮麦克刷，一能听懂的朋友帮麦卡刷。

好，那么呢，它是一个二维数组，那么麦克老师呢，简单的把这个二维数组呢，先简单的画一下，好，这个呢，是一个二维数组。好，那么呢，这个二维数组呢，第一层它有11个对不对，好我们点点点一下，好点点点一下，那么呢，这里有11个。好，二维数组呢，说明我们下面每一个当中呢，它又是我们的数组。好，这个数组呢，大家需要注意的是。它里面存放的内容呢，是我们的hands hands呢是一些回调函数，好就是一些函数指针，函数指针呢，大家可以把它理解为，如果我们用C加去封装它呢，肯定在这里面会去抽象一些，好啊，抽象一些接口对不对啊。好，那么我们接下来看一下我们怎么去初始化它，好，那么现在呢，我们在HTTP的处理流程当中呢，需要去初始化我们的这一个呃阶段，对不对？我们来看一下怎么来初始化这个阶段，初始化阶段马克老师简单的跟大家介绍一下我们的engineings，它初始化阶段的时候呢，它需要去根据我们engineings当中的那个配置，好就是endings can feed，好，那么一些配置文件当中的一些信息呢，我们需要进行一些定制，因为我们可能会根据这个配置文件去去定义我们不同阶段的行为，这个能听明白的朋友帮马卡刷，就是因为我们engines它提供的这种配置语言，我们可以在配置语言当中去写，去写什么呢？去写一些我们不同阶段处理的逻辑流程，它有一个简单的脚本语言来供我们进行开发。我们的相对应的。

好，那么呢，我们需要根据这个配置文件呢，去初始化我们的这些。阶段的处理好，那么我们来看一下。我们现在先了解一下，大家看到这里有一个PDRR，大家都注意注意了，PT这里都是函数指针，H跟PH都是函，就是函数指针好，包括我们的这个check，它都是函数指针好，那么知道这个之后呢，我们来看一下如何来进行初始化。

好，首先第一步呢，大家看到four，好一直到11对不对，一直到11，我们把里面的这个二维数组里面的方法大家注意了，这个phrase hand.an element是指这个an element呢是指我们这里的个数，好二维数组这个啊，这一维里面有多少个元素，就是这个n element有多少个元素，这个N呢，就是算出来我们所有的元素，这个能听明白的朋友帮老师刷一好，这个呢是N，是算出所有的元素。啊，所有的方法的个数。什么叫所有方法的个数呢？就是大家看这是一个，这是两个，这是三个，这是四个，这是五个啊，六个，七个八个是这样子的，我们这个二维数组有多少个我们的，因为他们都是回调函数，我们把这里面的所有的回调函数的个数呢，全部统计一下，好就是这个N的意思，好统计所有的方法之后呢，我们就来去构造一个这样的一个一维数组，一维数组的大小是什么呢？一维数组的大小是这个N，这个能听明白的朋友帮帮老师刷一，就是我们在这里面总共有多些。

多少这些函数，我们总共有多少这些回调函数好，因为它是个二维数组，我们把二维数组呢，是不是相当于把这个二维数组展开成一维数组好，那么大家需要注意的是，我们在这里面呢，实际上去初始化的一个一维数组的长度好，这个是一维数组的一个结构体啊，啊一个对象。好，那么我们来看一下怎么来初始我们的阶段。首先从零开始，从零开始好，那么我们取出我们二维数组当中的元素，这里面呢，有一些元素对不对，它有个二维数组，我们把每一个元素都取出来，好把每一个元素都取出来，取出来呢，就是这个HH呢，是我们的具体的扣back函数啊，它是扣back函数，好然后呢，我们还会去设置这个track函数，那个呢，我们在这里面都会去设置这个track函数。

好，这个不同的阶段大家注意了，这个就是我们不同的阶段好，这个是阶段一好，Rewrite重定向的阶段对不对，重定向的阶段好，这呢就是查找配置的阶段好，以及这里呢，重定向刚刚是server重定向，这个呢是重定向对不对，好以及呃，Post重定向，还有呢，Access访问对不对，还有post。啊等等，这里面呢，还有content content呢，麦克老师跟大家介绍一下content阶段呢，就是啊，我们发送HTP请求过来，到content阶段呢，就是我们把这里面所有处理的数据呢，在这里面进行一个组装，组装完之后呢，我们就会转发到客户端了，好接下来下一个阶段就是日志阶段了，就是打日志的阶段了啊。

这个是倒数第二个阶段，倒数第二个阶段。好，那么这里面呢，我们就是去初始化这些选择不同的方法对不对，显然我们在这里初始化的时候。就是去初始化。这些方。这些方法好，那么麦克老师跟大家介绍一下，就是我们把这个二维数组展开成一维数组。好，前面是二维数组，现在呢，我们展开成一维数组。啊，这里呢，展开成一维数组啊，一直有很多，显然呢，它会有很长很长的。啊，展开成这里的中间呢，就点点点了。好，那么我们接着来看它的逻辑，好这个下面的呢，都是设置，设置这种具体的回调我们就不需要看了，好那么我们接下来看这一块。

上面设置回调之后呢，我们再看这一块。好，实际上看这一块的时候呢，大家可以看出来，我们每一次计算呢，我们都会计算一个NN呢是记录下一个，大家注意了，这一个I好，下一个的elements的长度好，加上它就是我们大家看这里面原来二维数组，这里面的个数，我们统计完之后，如果我们把这个N这里面所有的都加起来，其实就是下一个阶段的指针啊，索引指针，这个能听明白的朋友帮麦老师阿，好，就是下一个阶段的索引指针。好，那么假设呢，这里面前三个是第一个阶段的好，我们用绿色的来画一下，假设呢，这个原来绿色的部分是第一个阶段的好，这里三个呢，是第二个阶段的，第二个阶段呢，我们用。蓝色的啊，这个是第二个阶段的。

好，这个能听明白的朋友帮帮他刷，就是N加上这个，其实呢，我们的这个N是它的N，就是下一阶段的索引是不是。是不是就是这个N啊，这个应该很容易理解，好那么我们来看一下，设置完这个check，然后呢，每一个handle的回调函数呢，设置完，设置完之后呢，设置给每一个指针呢，设置下一个的索引，好那么我们这里面呢，相当于是什么意思呢？相当于它。用黑色的。他呢也指向下一个阶段。啊，他指向下一个阶段。好，这里面第二个元素呢，也指向第二个阶段。好，那第三个呢的下一个也是。指向的下一个阶段，这个能听明白的朋友帮忙看刷好，那么这里呢，就指向下一个阶段好，这个呢也指向下一个阶段，这个也指向下一个阶段，就是我们里面的每一个阶段里面的子流程都指向下一个阶段好，那么大家呢，现在可以思考一下我们为什么这么设计。

好，以及呢，我们把这个责任链的。几个特殊点呢，就是它的关键点，把它放到这里来，大家可以来进行比较分析。好，它是多个步骤的，按顺序传递的，好按顺序呢大家可以理解了，因为我们这里是一个数组，显然它是顺序的，对不对？好顺序传递呢，我们肯定是因为我们里面每一个节点都指向了下一个阶段的指针，对不对，它的这个数组的索引对不对，都指向了下一个索引的，那么我们传递的过程当中，是不是我们任意可以传递到下一阶段，好比如说我们在这里面呢，执行两步的时候，我们就传递给下一个阶段，好比如说我们执行第三步的时候，再执行下一个阶段，那么这个传递的流程呢，我们也实现了，对不对，好，那么接下来我们可以打断怎么来实现呢？

好，接下来我们来看一下怎么来实现这个打断的功能，我们现在这个多步骤按顺序传递呢，我们都已经实现了，关键是这个打断是怎么实现的，好我们来看一下它具体的调度执行11个阶段是怎么实行的，好我们把这个图呢又截一下。好。这个是执行阶段。好，执行11个阶段，我们来看一下怎么来做。好，那么显然呢，我们会从这一个free，它默认刚开始是零，对不对，刚开始是零，好，这个track呢，就是从一个阶段一个阶段的进行执行，对不对？好，大家看到我们在这个执行的过程当中呢，我们会进行传递，先把这一个阶段的事情做完，做完之后呢，我们就去执行下一个阶段，好执行下一个阶段呢，我们又去执行下一个阶段，当我们等于engineings OK的时候，等于等于engines OK的时候，那么我们直接return出去了，大家可以看到这个return是直接返回了，它不会去走下一个阶段了，刚刚麦克老师跟大家说了，我们的责任链呢，它是可以打断的，对不对？好，当我们的ending是OK。

当我们的这个处理结果等于NOK的时候，它就直接打断我们的流程了。好，怎么实现传递呢？传递是我们的这个free handle，它往里面加，加的时候去传递我们的处理方法，好，传递我们的处理方法，传递我们的处理方法，当我们等于ends OK，我们就开始打断流程。这个能听明白的朋友帮忙打个声音。好，这个呢，就是我们的一个责任链的实现，那么大家思考一下。刚刚麦克老师说。看源码的过程当中，我怎么来用这个设计模式？好，怎么试用这个设计模式呢？大家思考一下。

好，那么马克老师首先跟大家介绍一下，大家先还可以继续带着这个问题，继续带着这个问题，马克老师先跟大家介绍一下，我们N克在啊，Open restty在engines上到底做了什么东西。好，那么马克老师跟大家介绍一下，就是它嵌入了一层撸啊。好，那么大家需要注意的是，我们open rest里面的，比如说那些stream，每一个虚拟机它都对应着一个，Lur虚拟机它都对应着一个，啊虚拟机好，我们每一个请求，每一个HTTP请求都会对应着我们。Lur当中的一个携程啊，都会对应lur的一个携程，那么显然呢，我们的open它只是在engines上扩展功能。

什么叫扩展功能呢？好，当我们在open里面的ending can can里面，你不做任何Lu相关的事情，如果在里面不做任何lur相关的事情，好，它本质上又是endings，那是什么意思呢？也就是说我们的open没有影响endings原有的功能，它只是在上面增加了功能，这个能听明白的朋友帮麦克老师阿，它只是在上面增加功能，好。那么我们在上面增加功能，实际上就是在这个在这个责任链模式上去增加功能，那么大家思考一下。怎么不影响我们engines的功能。那么大家思考一下，我们。他是在每一个阶段切入了好。

在每一个阶段。好，嵌入了撸回调。好，那么大家是不是我们的每一个阶段当中是不是都是这些函数指针呢？这些都是函数指针对不对？好，我们open rest只是在上面加了一个Lu啊呃，加上了一个Lu啊回调这个能听明白的朋友帮麦克，麦克老师阿姨，我们在每一个阶段当中嵌入了Lu啊回调，好这个能听明白的朋友帮慢搞声音，那么我们是不是扩展这个，其实就是在这个链条链表当中加方法对不对？好，在这个每一个阶段当中加方法，那么大家思考一下，我们是在前面加呢？还是在我们的这个责任每一个阶段的后面加呢，大家思考一下。好在每一个阶段当中的前面加还是在后面加。

能听懂的朋友帮麦克老师。好，大家需要注意了，我们只是扩展功能。没有影响in的功能，没有影响N的功能，那么我们是在后面加还是在前面加？那么大家思考一下，我们在这个责任链当中，每一个阶段加方法，我们是加在前面呢，还是加在后面？有没有知道的朋友？好，显然呢，是加在后面对不对。对了，我们应该要加在后面，这样呢。一我们在engines can当中没有涉及open rest这些lur的方法的时候，它跟我们的engineings是一模一样的，对不对，它是跟engineing一模一样的啊，那么我们加在后面呢？就是原来NS上有的功能我们可以复用。好，我们open原来上有的功能，我们可以去复用它，但是呢，我们怎么扩展它，那么我们在这个每一个阶段的最后面给你补充一个lur方法，好，那么这样子呢，我们就没有修改ends，只是扩展在你的基础上扩展功能了。

好，这个能听明白的朋友帮麦老师阿姨好，那么我们呢。我是如何在上面构建的呢？就是我们在我们的阶段处理流程当中，好符合我们的责任链模式的基础上，给一个责任链的每一个阶段处理当中增加一个回调方法就行了，这个回调回调方法对于我们的设计，如果你是用CC家开发的话，是不是就增加一个接口，但是呢，这个接口的顺序是在每一个接接阶段处理的最末尾。好，这个能听明白的朋友把麦克老师阿姨，那么这一节课呢，麦克老师就跟大家介绍了这个设计模式，好，从框架构建到框架核心流程当中的应用，好框架构建呢，主要是跟大家来理解一下我们的依赖导致原则就是。

依赖导致原则，依赖导致原则呢，能够帮助我们去分析一个框架，就是它底层怎么分析呢？就是它底层抽象的什么好，它到底构建了一个什么，那么我们的用户层到底是怎么来使用，对不对？好，那么如果我们把它分析清楚了之后，我们就知道对于这种scan而言，我们使用的是怎么去抽象阿，怎么把我们的业务对象，怎么把业务对象去抽象成这一个阿，好，那么它底层实现了什么呢？好，底层实现了阿，怎么运转？怎么运转？好，那么我们是怎么来使用。我们是怎么来使用这些设计模式的呢？好，那特老师跟大家讲了一个模板模式，模板模板模式是怎么过来的呢？我们先通过。符合设计原则，我们首先要把设计原则搞清楚，我们先写代码，符合设计原则好，那么符合设计原则的时候呢，考虑这种变化对不对，好，那么呢，我们就慢慢去。

好就会找到我们相对应的设计模式，好先去符合设计原则，然后呢，再迭代出，迭代出设计模式啊为什么呢？啊，因为我们的具体的软件开发它是复杂的，它的变化点不是那么容易马上找到的啊，我们随着慢慢迭代的过程当中。我们很快就能够找到相对应的设计模式，好，那么前面我们找不出来怎么办？找不出来你写代码首先满足设计原则，因为呢，我们的设计模式是由设计原则推导过来的，所以呢，你满足它，等一会儿以后，需求清晰了之后，变化点清晰了之后，你再去转化为设计模式的时候，只需要修改少量的代码，只需要修改少量的代码。好，就能够去符合一个设计原则啊，设计模式说错了啊，那么啊，麦克老师呢，跟大家举了个例子，怎么。

迭代的过程，好，那么还有一个呢，就是跟大家介绍了这种。啊，三种设计模式的区别，那么我们不要去想里面的具体的你在工作当中的那种复杂的应用，你应该呢，在脑袋里面应该是这种啊，比较清晰的清啊通俗易懂的例子，在脑袋里面形成这种通俗易懂的例子，那么以后你应用的过程当中，你只要符合这种精髓，符合它的符合这种原理的精髓，那么呢，你自然而然它就是相对应的设计模式啊，大家千万不要去记它的概念，千万不要去背它的概念，那你要做什么呢？你应该用一个通俗的例子去理解这个东西，它到底是解决了一个什么问题，对不对？好，那么自然而然，你在工作当中就知道怎么用了。好，第五个呢，我们就跟大家介绍了一个ending的流程，跟大家介绍endingx流程，它的核心流程呢，使用了一个责任链模式，好，那么责任电模式它是怎么构建的，麦克老师呢，也把图给大家画出来了，给大家看了，好它是怎么进行传递的，怎么进行传递的，因为我们。

它有几个重点，第一个它是有一个多个步骤来完成的，这个步骤呢是有顺序的，好我们还需要有一个传递的算法，对不对，好而且呢可以打断好可以打断，我们知道这几个点呢，大家就可以看出来，我们这里面呢，它的11个阶段，我们就知道它具体是怎么实现的，好那么我们呢，由此了解了op它到底在干什么，Op它是在扩展Ning功能，大家注意了，扩展它的功能，我们的接口不能够放在我们的这个接段处理的前面，放在前面我们可能打弹出去了，如果打弹出去了，那么影响了原来的endingx的流程，我们放在后面是先运行endingx的流程，Endingx流程运行完之后，再附加的来运行我们撸瓦的流程，这个能听明白的朋友帮马老师阿一就是如果我们放在前面，它因为我们责任链模式它是允许打断的，如果允许打断，那么我们会。

影响engines原来的流程我们放在后面，是前面的流程运行完了之后，我们附加的来运行一下我们的luva流程，好，这个就是我们open restty，它的一个职责就是他在上面扩展功能，没有影响你原来的功能。好，那么我们这节课呢，就跟大家介绍到这，那么如果大家呢，呃，因为我们大家可以看出来，我们的总结这些知识点呢，其实基于一个目的，就是我们去学习知识的时候呢，形成一个知识体系，因为我们的所要学习的，大家到我们新家后台开发的要学习的知识呢，特别特别的多啊，我们呢，经过几位讲师呢啊，总共从11个维度跟大家总结了我们后端开发常用的一些知识体系，如果大家没有在脑袋当中形成这种形象的思维，好，以及我们具体的怎么去抽象的知识点是怎么抽象的啊。

这种抽象你没有想过这条路的话，你如果你想在工作当中慢慢摸索出这一个结果的话，那会需要花很长时间，那么我们老师呢，都已经工作十年或者十十十年以上了，那么呢，我们已经摸索出来这些东西了，那么我们不希望学员呢再走弯路，希望大家呢，在我们的肩膀上，能够在职业生涯走得更远，对不对，在我们的肩膀上，因为我们尽量的把这些案例讲的通俗又易懂，把这些知识点呢构成一个知识知识题，呃，就是我们的。思维导图啊，或者是具体的图像啊，啊，通过一些具体生动的案例呢，让大家形成，让这些知识呢，更加容易吸收，更加容易形成一个体系，好这样呢，呃，能够让大家少少走弯路，对不对？好那么我还是跟大家介绍一下我们的知识体系呢，有哪几个部分构成，第一个就是我们的数据结构和算法，就是我们C加。

后端开发当中常用的这些算法，包括红黑数，B数，B加数啊，还有个lsm数，还有呢，我们的哈希布隆过滤器这些的使用好，那么还有一个呢，设计模式。以及我们C加新特性，以及我们的Linux在Linux环境下的一些工具的使用啊，Make make，以及c make，还有呢，我们的版本控制工具等等，还有一些命令的使用啊，这个呢是第一个维度是一些常用的基础部分，第二个维度呢，就是网络编程。好，网络编程呢，我们也是从。最底层的我们的IO跟IO多路复用，IO操作跟IO多路复用来展开跟大家进行讲解，然后呢，跟大家讲解我们怎么去封装IO操作跟IO，就是IO检测，那么呢，我们会跟大家介绍react的网络模型，好那么基于react的网络模型呢，我们需要带领大家去实现一些网络编程常用的一种方式，第一个基于react去实现协议，好基于这个react网络模型呢去实现。

而实现具体的我们的比如说呃，单react好，就是单线程的reactor，多线程的react好，再跟大家介绍一个携程，就是我们携程去解决我们网络编程当中常常出现的这些回调，怎么把这些回调呢去处去除掉。好，那么还会跟大家介绍呢，我们网络编程当中Linux内核协议站的主要工作原理，那么这个呢，也是大堂。面试的过程当中常用的一些东西啊，那么我们还会跟大家介绍一些呢，呃，携程。好，携程的实现，以及我们的用户态协议站好，手撕用户态协议站好，刚刚是讲的Linux内核协议站的原理好，这个呢，就是把另内核协议站呢，放到我们的用户层来实现一遍。

好，第三个维度，第二个维度呢，主要是网络相关的，由底层到应用啊，由底层到应用到封装，这个呢讲的特别的透彻，好，那么还有一个呢，就是我们组件，组件呢。线程时，那么大家注意了，线程时呢，大家可能脑袋里面形成的都是一些固定的思考的方式，那么我们的课程当中会跟大家介绍不同的变化方向。就是基于。啊线程池，那么基于线程池呢，我们会有很多的框架跟大家去讲解我们的这里面的队列的应用好以及这些线程池的调度啊，这里面其实呢，线程池的调度有很多种方式，这种队列的使用呢，也有很多的花样啊，那么分别呢，通过不同开源框架的讲解呢，大家就会知道怎么去使用我们的队列，怎么使用我们的线程值的调度。

好，那么呢，还有一个就是内存池，还有异步请求池，还有我们的MYSQL连接池，以及一些相对应的高性能的锁，无锁队列，这些东西怎么实现，还有定时器，还有我们的解决工作当中的死锁检测啊，还有内存泄露啊，还有就是我们相对应的分布式锁啊，好，还有一些开源框架的应用，比如说Li went liv，还有呢，我们的异步日志库，好那么这一些呢，我们基础组件部分呢，通常它是构建框架的一些非一些必要的环一必要的技术点就是我们框架的一些必要的技术点。好，那么还有一个呢，就是第四个维度，前面呢都是讲我们基于后端开发，就是我们我们的服务器本身的开发，那么还有一个呢，我们服务器呢，还需要引入一些其他的东西辅助我们完成功能，比如说一些中间键，什么叫中间键呢？比如说my red mango，好，还有呢，TDB啊，以及rocks DB。

等等，就是这些数据库相关的，还有呢，会跟大家介绍详细的介绍ins里面的实现原理。啊，以及这些中间键，那么还有一个呢，就是开源框架scanner，一个游基于游戏服务器框架，还有呢，Task就是基于我们的分布式微服务，七家的分布式微服务啊，腾讯的，那么还有一个呢，就是DBDK啊，用户态协议站啊，这个呢，就是有有一个商业，呃，就是相当于一个开源的非常强大的一个用户态，实现用户态协议站的一个组件。啊，一个框架好，那么还有一个呢，就是跟大家介绍一些ru语言，以及我们做一些性能分析，分布式架构相关的好，那么分布式架构呢，马克老师跟大家介绍一下，这里面呢，有分布式解决分布式当中啊服务之间通讯的问题，比如说啊消息队列，还有RBC。

啊RBC，还有呢，就是我们的分布式当中的，我们的注册服务中心，就是做一些配置共享啊，还有就是我们的服务发现啊，集群监控啊，Leader选举啊等等，那么呢，我们还需要跟大家介绍一些这种注册中心etcd，好，以及我们还会跟大家介绍一个API网关，那么基于我们刚刚讲的open rest open restty，那么呢是基于open restty的二次开发控。好。这样的一个框架，好，那么还会跟大家介绍呢，我们的分布式的存储跟容器，呃，像我们的分布式的文件，呃，分布式的存储，还有呢，分布式的拓容器。好，那么还有一个就是两个不同的项目，第一个呢，图床项目这里面呢，也有一个分布式的，分布式的文件系统。

好，那么还有一个就是我们的微服务及时通讯有两个项目，如果大家呢，不是从事我们的CC加R的啊，现在是从事客户端开发的，那么呢，根据这两个项目呢，了解我们的后端开发的一个完整的流程。好，那么适合人群呢，主要适合第一个我们开发多年，很多技术呢都听过，但是呢，不知道没有深入了解过的这些工程师啊，比如说还有从事嵌入式啊，客户端呢等等开发的，想从事互联网，因为这些方向的他涨工资比较难，对不对，想走互联网，那么呢，我们可以考虑我们的课程，还有呢，就是做一些算法岗。跟我或者是运维啊测试相关的啊，还有就是工作当中没有挑战自己，学习比较慢啊，知道技术名词，但是不知道里面的实践细节啊，想进大厂的在校生啊这些呢，是我们适合学习我们课程的人群，好那么我们今天的课程呢，先讲到这好那么需要资料的朋友呢，加一下我们的秋江老师，那么我们呃这份文档需要的朋友呢，啊，这个需要的朋友加一下我们肖江老师的微信啊QQ好那么我们现在呢，讲到这儿，谢谢大家。