设计模式简要介绍

叁歲伎倆 2022-09-12 10:53 255阅读 0赞

### 设计模式简要介绍 ###

*  23种主要设计模式简介
 *   *  23种设计模式的分类和功能
 *  创建型模式
 *   *  单例模式
     *  原型模式
     *  工厂模式
     *  抽象工厂模式
     *  建造者模式
 *  结构型模式
 *   *  代理模式
     *  适配器模式
     *  桥接模式
     *  装饰者模式
     *  外观模式
     *  享元模式
     *  组合模式
     *  过滤器模式
 *  行为型模式
 *   *  模板方法模式
     *  策略模式
     *  命令模式
     *  责任链模式
     *  状态模式
     *  观察者模式
     *  中介者模式
     *  迭代器模式
     *  访问者模式
     *  备忘录模式
     *  解释器模式
     *  空对象模式
 *  J2EE 模式
 *   *  \[MVC 模式\](https://www.runoob.com/design-pattern/mvc-pattern.html)
     *  业务代表模式
     *  组合实体模式
     *  数据访问对象模式
     *  前端控制器模式
     *  拦截过滤器模式
     *  服务定位器模式
     *  传输对象模式

# 23种主要设计模式简介 #

## [23种设计模式的分类和功能][23] ##

1.  单例（Singleton）模式：某个类只能生成一个实例，该类提供了一个全局访问点供外部获取该实例，其拓展是有限多例模式。
2.  原型（Prototype）模式：将一个对象作为原型，通过对其进行复制而克隆出多个和原型类似的新实例。
3.  工厂方法（Factory Method）模式：定义一个用于创建产品的接口，由子类决定生产什么产品。
4.  抽象工厂（AbstractFactory）模式：提供一个创建产品族的接口，其每个子类可以生产一系列相关的产品。
5.  建造者（Builder）模式：将一个复杂对象分解成多个相对简单的部分，然后根据不同需要分别创建它们，最后构建成该复杂对象。
6.  代理（Proxy）模式：为某对象提供一种代理以控制对该对象的访问。即客户端通过代理间接地访问该对象，从而限制、增强或修改该对象的一些特性。
7.  适配器（Adapter）模式：将一个类的接口转换成客户希望的另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类能一起工作。
8.  桥接（Bridge）模式：将抽象与实现分离，使它们可以独立变化。它是用组合关系代替继承关系来实现，从而降低了抽象和实现这两个可变维度的耦合度。
9.  装饰（Decorator）模式：动态的给对象增加一些职责，即增加其额外的功能。
10. 外观（Facade）模式：为多个复杂的子系统提供一个一致的接口，使这些子系统更加容易被访问。
11. 享元（Flyweight）模式：运用共享技术来有效地支持大量细粒度对象的复用。
12. 组合（Composite）模式：将对象组合成树状层次结构，使用户对单个对象和组合对象具有一致的访问性。
13. 模板方法（TemplateMethod）模式：定义一个操作中的算法骨架，而将算法的一些步骤延迟到子类中，使得子类可以不改变该算法结构的情况下重定义该算法的某些特定步骤。
14. 策略（Strategy）模式：定义了一系列算法，并将每个算法封装起来，使它们可以相互替换，且算法的改变不会影响使用算法的客户。
15. 命令（Command）模式：将一个请求封装为一个对象，使发出请求的责任和执行请求的责任分割开。
16. 职责链（Chain of  
    Responsibility）模式：把请求从链中的一个对象传到下一个对象，直到请求被响应为止。通过这种方式去除对象之间的耦合。
17. 状态（State）模式：允许一个对象在其内部状态发生改变时改变其行为能力。
18. 观察者（Observer）模式：多个对象间存在一对多关系，当一个对象发生改变时，把这种改变通知给其他多个对象，从而影响其他对象的行为。
19. 中介者（Mediator）模式：定义一个中介对象来简化原有对象之间的交互关系，降低系统中对象间的耦合度，使原有对象之间不必相互了解。
20. 迭代器（Iterator）模式：提供一种方法来顺序访问聚合对象中的一系列数据，而不暴露聚合对象的内部表示。
21. 访问者（Visitor）模式：在不改变集合元素的前提下，为一个集合中的每个元素提供多种访问方式，即每个元素有多个访问者对象访问。
22. 备忘录（Memento）模式：在不破坏封装性的前提下，获取并保存一个对象的内部状态，以便以后恢复它。
23. 解释器（Interpreter）模式：提供如何定义语言的文法，以及对语言句子的解释方法，即解释器。

# 创建型模式 #

这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。

## [单例模式][Link 1] ##

单例模式确保一个类只有一个实例，并提供一个全局的访问点。  
单例模式（Singleton Pattern）是 Java 中最简单的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。  
这种模式涉及到一个单一的类，该类负责创建自己的对象，同时确保只有单个对象被创建。这个类提供了一种访问其唯一的对象的方式，可以直接访问，不需要实例化该类的对象。  
注意：  
1、单例类只能有一个实例。  
2、单例类必须自己创建自己的唯一实例。  
3、单例类必须给所有其他对象提供这一实例。

## [原型模式][Link 2] ##

当创建给定类的实例的过程很复杂的时候可以使用原型模式。  
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。  
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。

## [工厂模式][Link 3] ##

工厂模式定义了一个创建对象的接口，但由子类决定要实例化的类是哪一个，工厂方法让类把实例化推迟到子类。  
工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。  
在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

## [抽象工厂模式][Link 4] ##

抽象工厂模式提供一个接口，用于创建相关或者依赖对象的家族，而不需要明确指定具体类。  
抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。  
在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

## [建造者模式][Link 5] ##

建造者模式封装一个产品的构造过程，并允许按步骤构造。  
建造者模式（Builder Pattern）使用多个简单的对象一步一步构建成一个复杂的对象。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。  
一个 Builder 类会一步一步构造最终的对象。该 Builder 类是独立于其他对象的。

# 结构型模式 #

这些设计模式关注类和对象的组合。继承的概念被用来组合接口和定义组合对象获得新功能的方式。

## [代理模式][Link 6] ##

代理模式为一个对象提供一个替身或者占位符以控制对这个对象的访问。  
在代理模式（Proxy Pattern）中，一个类代表另一个类的功能。这种类型的设计模式属于结构型模式。  
在代理模式中，我们创建具有现有对象的对象，以便向外界提供功能接口。

## [适配器模式][Link 7] ##

适配器模式将一个类的接口，转换成客户希望的另外一个接口。适配器模式将原本接口不兼容的类可以合作无间。  
适配器模式（Adapter Pattern）是作为两个不兼容的接口之间的桥梁。这种类型的设计模式属于结构型模式，它结合了两个独立接口的功能。  
这种模式涉及到一个单一的类，该类负责加入独立的或不兼容的接口功能。举个真实的例子，读卡器是作为内存卡和笔记本之间的适配器。您将内存卡插入读卡器，再将读卡器插入笔记本，这样就可以通过笔记本来读取内存卡。  
我们通过下面的实例来演示适配器模式的使用。其中，音频播放器设备只能播放 mp3 文件，通过使用一个更高级的音频播放器来播放 vlc 和 mp4 文件。

## [桥接模式][Link 8] ##

桥接模式不只改变你的实现，也改变你的抽象。  
桥接（Bridge）是用于把抽象化与实现化解耦，使得二者可以独立变化。这种类型的设计模式属于结构型模式，它通过提供抽象化和实现化之间的桥接结构，来实现二者的解耦。  
这种模式涉及到一个作为桥接的接口，使得实体类的功能独立于接口实现类。这两种类型的类可被结构化改变而互不影响。

## [装饰者模式][Link 9] ##

装饰者模式动态的将责任附加到对象身上，若要拓展功能，装饰者提供了比继承更有弹性的替代方案。  
装饰器模式（Decorator Pattern）允许向一个现有的对象添加新的功能，同时又不改变其结构。这种类型的设计模式属于结构型模式，它是作为现有的类的一个包装。  
这种模式创建了一个装饰类，用来包装原有的类，并在保持类方法签名完整性的前提下，提供了额外的功能。  
我们通过下面的实例来演示装饰器模式的用法。其中，我们将把一个形状装饰上不同的颜色，同时又不改变形状类。

## [外观模式][Link 10] ##

外观模式提供了一个统一的接口，用来访问子系统中的一群接口。外观定义了一个高层接口，让子系统更容易使用。  
外观模式（Facade Pattern）隐藏系统的复杂性，并向客户端提供了一个客户端可以访问系统的接口。这种类型的设计模式属于结构型模式，它向现有的系统添加一个接口，来隐藏系统的复杂性。  
这种模式涉及到一个单一的类，该类提供了客户端请求的简化方法和对现有系统类方法的委托调用。

## [享元模式][Link 11] ##

享元模式（Flyweight Pattern）主要用于减少创建对象的数量，以减少内存占用和提高性能。这种类型的设计模式属于结构型模式，它提供了减少对象数量从而改善应用所需的对象结构的方式。  
享元模式尝试重用现有的同类对象，如果未找到匹配的对象，则创建新对象。

## [组合模式][Link 12] ##

组合模式允许你将对象组合成树形结构来表现“整体/部分”层次结构。组合能让客户以一致的方式处理个别对象以及对象组合。  
组合模式（Composite Pattern），又叫部分整体模式，是用于把一组相似的对象当作一个单一的对象。组合模式依据树形结构来组合对象，用来表示部分以及整体层次。这种类型的设计模式属于结构型模式，它创建了对象组的树形结构。  
这种模式创建了一个包含自己对象组的类。该类提供了修改相同对象组的方式。

--------------------

## [过滤器模式][Link 13] ##

过滤器模式（Filter Pattern）或标准模式（Criteria Pattern）是一种设计模式，这种模式允许开发人员使用不同的标准来过滤一组对象，通过逻辑运算以解耦的方式把它们连接起来。这种类型的设计模式属于结构型模式，它结合多个标准来获得单一标准。

--------------------

# 行为型模式 #

这些设计模式特别关注对象之间的通信。

## [模板方法模式][Link 14] ##

模板方法模式在一个方法中定义一个算法骨架，而将一些步骤延迟到子类中。模板方法使得子类在不改变算法结构的情况下，重新定义算法中的某些步骤。  
在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

## [策略模式][Link 15] ##

策略模式定义了算法族，分别封装起来，让他们之间可以互相替换，此模式让算法的变化独立与使用算法的客服。  
在策略模式（Strategy Pattern）中，一个类的行为或其算法可以在运行时更改。这种类型的设计模式属于行为型模式。  
在策略模式中，我们创建表示各种策略的对象和一个行为随着策略对象改变而改变的 context 对象。策略对象改变 context 对象的执行算法。

## [命令模式][Link 16] ##

命令模式将请求封装成对象，以便使用不同的请求、队列或者日志参数化其他对象。命令模式也支持可撤销的操作。  
命令模式（Command Pattern）是一种数据驱动的设计模式，它属于行为型模式。请求以命令的形式包裹在对象中，并传给调用对象。调用对象寻找可以处理该命令的合适的对象，并把该命令传给相应的对象，该对象执行命令。

## [责任链模式][Link 17] ##

责任链模式可以让一个以上的对象有机会能够处理某个请求。  
顾名思义，责任链模式（Chain of Responsibility Pattern）为请求创建了一个接收者对象的链。这种模式给予请求的类型，对请求的发送者和接收者进行解耦。这种类型的设计模式属于行为型模式。  
在这种模式中，通常每个接收者都包含对另一个接收者的引用。如果一个对象不能处理该请求，那么它会把相同的请求传给下一个接收者，依此类推。

## [状态模式][Link 18] ##

状态模式允许对象在内部状态改变的时候改变它的行为，对象看起来好像修改了它的类。  
在状态模式（State Pattern）中，类的行为是基于它的状态改变的。这种类型的设计模式属于行为型模式。  
在状态模式中，我们创建表示各种状态的对象和一个行为随着状态对象改变而改变的 context 对象。

## [观察者模式][Link 19] ##

观察者模式定义了对象之间的一对多的依赖，这样一来，当一个对象改变时，他的所有依赖者都会收到通知并自动更新。  
当对象间存在一对多关系时，则使用观察者模式（Observer Pattern）。比如，当一个对象被修改时，则会自动通知依赖它的对象。观察者模式属于行为型模式。

## [中介者模式][Link 20] ##

用中介者模式来集中相关对象之间复杂的沟通和控制方式。  
中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

## [迭代器模式][Link 21] ##

迭代器模式提供一种方法顺序访问一个聚合对象中的各个元素，而又不暴露其内部的表示。  
迭代器模式（Iterator Pattern）是 Java 和 .Net 编程环境中非常常用的设计模式。这种模式用于顺序访问集合对象的元素，不需要知道集合对象的底层表示。  
迭代器模式属于行为型模式。

## [访问者模式][Link 22] ##

当想要为一个对象的组合增加新的能力，且封装不重要时，可以使用访问者模式。  
在访问者模式（Visitor Pattern）中，我们使用了一个访问者类，它改变了元素类的执行算法。通过这种方式，元素的执行算法可以随着访问者改变而改变。这种类型的设计模式属于行为型模式。根据模式，元素对象已接受访问者对象，这样访问者对象就可以处理元素对象上的操作。

## [备忘录模式][Link 23] ##

备忘录模式让对象返回之前的状态。  
备忘录模式（Memento Pattern）保存一个对象的某个状态，以便在适当的时候恢复对象。备忘录模式属于行为型模式。

## [解释器模式][Link 24] ##

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

--------------------

## [空对象模式][Link 25] ##

在空对象模式（Null Object Pattern）中，一个空对象取代 NULL 对象实例的检查。Null 对象不是检查空值，而是反应一个不做任何动作的关系。这样的 Null 对象也可以在数据不可用的时候提供默认的行为。  
在空对象模式中，我们创建一个指定各种要执行的操作的抽象类和扩展该类的实体类，还创建一个未对该类做任何实现的空对象类，该空对象类将无缝地使用在需要检查空值的地方。

--------------------

# J2EE 模式 #

这些设计模式特别关注表示层。这些模式是由 Sun Java Center 鉴定的。

## [MVC 模式][MVC] ##

MVC 模式代表 Model-View-Controller（模型-视图-控制器） 模式。这种模式用于应用程序的分层开发。

*  Model（模型） - 模型代表一个存取数据的对象或 JAVA POJO。它也可以带有逻辑，在数据变化时更新控制器。
 *  View（视图） - 视图代表模型包含的数据的可视化。
 *  Controller（控制器） - 控制器作用于模型和视图上。它控制数据流向模型对象，并在数据变化时更新视图。它使视图与模型分离开。

## [业务代表模式][Link 26] ##

业务代表模式（Business Delegate Pattern）用于对表示层和业务层解耦。它基本上是用来减少通信或对表示层代码中的业务层代码的远程查询功能。在业务层中我们有以下实体。

*  客户端（Client） - 表示层代码可以是 JSP、servlet 或 UI java 代码。
 *  业务代表（Business Delegate） - 一个为客户端实体提供的入口类，它提供了对业务服务方法的访问。
 *  查询服务（LookUp Service） - 查找服务对象负责获取相关的业务实现，并提供业务对象对业务代表对象的访问。
 *  业务服务（Business Service） - 业务服务接口。实现了该业务服务的实体类，提供了实际的业务实现逻辑。

## [组合实体模式][Link 27] ##

组合实体模式（Composite Entity Pattern）用在 EJB 持久化机制中。一个组合实体是一个 EJB 实体 bean，代表了对象的图解。当更新一个组合实体时，内部依赖对象 beans 会自动更新，因为它们是由 EJB 实体 bean 管理的。以下是组合实体 bean 的参与者。

*  组合实体（Composite Entity） - 它是主要的实体 bean。它可以是粗粒的，或者可以包含一个粗粒度对象，用于持续生命周期。
 *  粗粒度对象（Coarse-Grained Object） - 该对象包含依赖对象。它有自己的生命周期，也能管理依赖对象的生命周期。
 *  依赖对象（Dependent Object） - 依赖对象是一个持续生命周期依赖于粗粒度对象的对象。
 *  策略（Strategies） - 策略表示如何实现组合实体。

## [数据访问对象模式][Link 28] ##

数据访问对象模式（Data Access Object Pattern）或 DAO 模式用于把低级的数据访问 API 或操作从高级的业务服务中分离出来。以下是数据访问对象模式的参与者。

*  数据访问对象接口（Data Access Object Interface） - 该接口定义了在一个模型对象上要执行的标准操作。
 *  数据访问对象实体类（Data Access Object concrete class） - 该类实现了上述的接口。该类负责从数据源获取数据，数据源可以是数据库，也可以是 xml，或者是其他的存储机制。
 *  模型对象/数值对象（Model Object/Value Object） - 该对象是简单的 POJO，包含了 get/set 方法来存储通过使用 DAO 类检索到的数据

## [前端控制器模式][Link 29] ##

前端控制器模式（Front Controller Pattern）是用来提供一个集中的请求处理机制，所有的请求都将由一个单一的处理程序处理。该处理程序可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。以下是这种设计模式的实体。

*  前端控制器（Front Controller） - 处理应用程序所有类型请求的单个处理程序，应用程序可以是基于 web 的应用程序，也可以是基于桌面的应用程序。
 *  调度器（Dispatcher） - 前端控制器可能使用一个调度器对象来调度请求到相应的具体处理程序。
 *  视图（View） - 视图是为请求而创建的对象。

## [拦截过滤器模式][Link 30] ##

拦截过滤器模式（Intercepting Filter Pattern）用于对应用程序的请求或响应做一些预处理/后处理。定义过滤器，并在把请求传给实际目标应用程序之前应用在请求上。过滤器可以做认证/授权/记录日志，或者跟踪请求，然后把请求传给相应的处理程序。以下是这种设计模式的实体。

*  过滤器（Filter） - 过滤器在请求处理程序执行请求之前或之后，执行某些任务。
 *  过滤器链（Filter Chain） - 过滤器链带有多个过滤器，并在 Target 上按照定义的顺序执行这些过滤器。
 *  Target - Target 对象是请求处理程序。
 *  过滤管理器（Filter Manager） - 过滤管理器管理过滤器和过滤器链。
 *  客户端（Client） - Client 是向 Target 对象发送请求的对象。

## [服务定位器模式][Link 31] ##

服务定位器模式（Service Locator Pattern）用在我们想使用 JNDI 查询定位各种服务的时候。考虑到为某个服务查找 JNDI 的代价很高，服务定位器模式充分利用了缓存技术。在首次请求某个服务时，服务定位器在 JNDI 中查找服务，并缓存该服务对象。当再次请求相同的服务时，服务定位器会在它的缓存中查找，这样可以在很大程度上提高应用程序的性能。以下是这种设计模式的实体。

*  服务（Service） - 实际处理请求的服务。对这种服务的引用可以在 JNDI 服务器中查找到。
 *  Context / 初始的 Context - JNDI Context 带有对要查找的服务的引用。
 *  服务定位器（Service Locator） - 服务定位器是通过 JNDI 查找和缓存服务来获取服务的单点接触。
 *  缓存（Cache） - 缓存存储服务的引用，以便复用它们。
 *  客户端（Client） - Client 是通过 ServiceLocator 调用服务的对象。

## [传输对象模式][Link 32] ##

传输对象模式（Transfer Object Pattern）用于从客户端向服务器一次性传递带有多个属性的数据。传输对象也被称为数值对象。传输对象是一个具有 getter/setter 方法的简单的 POJO 类，它是可序列化的，所以它可以通过网络传输。它没有任何的行为。服务器端的业务类通常从数据库读取数据，然后填充 POJO，并把它发送到客户端或按值传递它。对于客户端，传输对象是只读的。客户端可以创建自己的传输对象，并把它传递给服务器，以便一次性更新数据库中的数值。以下是这种设计模式的实体。

*  业务对象（Business Object） - 为传输对象填充数据的业务服务。
 *  传输对象（Transfer Object） - 简单的 POJO，只有设置/获取属性的方法。
 *  客户端（Client） - 客户端可以发送请求或者发送传输对象到业务对象。

--------------------

注：仅供学习交流之用，不当之处还请指正

[23]: http://c.biancheng.net/view/1320.html
[Link 1]: https://www.runoob.com/design-pattern/singleton-pattern.html
[Link 2]: https://www.runoob.com/design-pattern/prototype-pattern.html
[Link 3]: https://www.runoob.com/design-pattern/factory-pattern.html
[Link 4]: https://www.runoob.com/design-pattern/abstract-factory-pattern.html
[Link 5]: https://www.runoob.com/design-pattern/builder-pattern.html
[Link 6]: https://www.runoob.com/design-pattern/proxy-pattern.html
[Link 7]: https://www.runoob.com/design-pattern/adapter-pattern.html
[Link 8]: https://www.runoob.com/design-pattern/bridge-pattern.html
[Link 9]: https://www.runoob.com/design-pattern/decorator-pattern.html
[Link 10]: https://www.runoob.com/design-pattern/facade-pattern.html
[Link 11]: https://www.runoob.com/design-pattern/flyweight-pattern.html
[Link 12]: https://www.runoob.com/design-pattern/composite-pattern.html
[Link 13]: https://www.runoob.com/design-pattern/filter-pattern.html
[Link 14]: https://www.runoob.com/design-pattern/template-pattern.html
[Link 15]: https://www.runoob.com/design-pattern/strategy-pattern.html
[Link 16]: https://www.runoob.com/design-pattern/command-pattern.html
[Link 17]: https://www.runoob.com/design-pattern/chain-of-responsibility-pattern.html
[Link 18]: https://www.runoob.com/design-pattern/state-pattern.html
[Link 19]: https://www.runoob.com/design-pattern/observer-pattern.html
[Link 20]: https://www.runoob.com/design-pattern/mediator-pattern.html
[Link 21]: https://www.runoob.com/design-pattern/iterator-pattern.html
[Link 22]: https://www.runoob.com/design-pattern/visitor-pattern.html
[Link 23]: https://www.runoob.com/design-pattern/memento-pattern.html
[Link 24]: https://www.runoob.com/design-pattern/interpreter-pattern.html
[Link 25]: https://www.runoob.com/design-pattern/null-object-pattern.html
[MVC]: https://www.runoob.com/design-pattern/mvc-pattern.html
[Link 26]: https://www.runoob.com/design-pattern/business-delegate-pattern.html
[Link 27]: https://www.runoob.com/design-pattern/composite-entity-pattern.html
[Link 28]: https://www.runoob.com/design-pattern/data-access-object-pattern.html
[Link 29]: https://www.runoob.com/design-pattern/front-controller-pattern.html
[Link 30]: https://www.runoob.com/design-pattern/intercepting-filter-pattern.html
[Link 31]: https://www.runoob.com/design-pattern/service-locator-pattern.html
[Link 32]: https://www.runoob.com/design-pattern/transfer-object-pattern.html