设计模式带类图

二十三种设计模式

2009年05月27日 星期三 13:15

二十三种设 计模式

0 引言

谈到设计模式，绝对应该一起来说说重构。重构给我们带来了什么？除了作为对遗留代码的改进的方法，另一 大意义在于，可以让我们在写程序的时候可以不需事先考虑太多的代码组织问题，当然这其中也包括了应用模式的问题。尽管大多数开发者都已经养成了写代码前先 从设计开始的习惯，但是，这种程度的设计，涉及到到大局、到总体架构、到主要的模块划分我觉得就够了。换句话说，这时就能写代码了。这就得益于重构的思想 了。如果没有重构的思想，有希望获得非常高质量的代码，我们就不得不在开始写代码前考虑更多其实并非非常稳定的代码组织及设计模式的应用问题，那开发效率 当然就大打折扣了。在重构和设计模式的合理应用之下，我们可以相对较早的开始写代码，并在功能尽早实现的同时，不断地通过重构和模式来改善我们的代码质 量。所以，下面的章节中，在谈模式的同时，我也会谈谈关于常用的这些模式的重构成本的理解。重构成本越高意味着，在遇到类似的问题情形的时候，我们更应该 提前考虑应用对应的设计模式，而重构成本比较低则说明，类似的情形下，完全可以先怎么方便，怎么快怎么写，哪怕代码不是很优雅也没关系，回头再重构也很容 易。

1 创建型

1.1 Factory Method

 

思想： Factory Method 的主要思想是使一个类的实例化延迟到其子类。

场景： 典 型的应用场景如：在某个系统开发的较早阶段，有某些类的实例化过程，实例化方式可能还不是很确定，或者实际实例化的对象（可能是需要对象的某个子类中的一 个）不确定，或者比较容易变化。此时，如果直接将实例化过程写在某个函数中，那么一般就是 if-else 或 select-case 代 码。如果，候选项的数目较少、类型基本确定，那么这样的 if-else 还是可以接受的，一旦情形变 得复杂、不确定性增加，更甚至包含这个构造过程的函数所在的类包含几个甚至更多类似的函数时，这样的 if-else 代 码就会变得比较不那么容易维护了。此时，应用本模式，可以将这种复杂情形隔离开，即将这类不确定的对象的实例化过程延迟到子类。

实现： 该模式的典型实现方法就是将调用类定义为一个虚类，在调用类定义一个专门用于构造不确定的对象实例的虚函数，再将实际的对象实例化代码 留到调用类的子类来实现。如果，被构造的对象比较复杂的话，同时可以将这个对象定义为可以继承、甚至虚类，再在不同的调用类的子类中按需返回被构造类的子 类。

重构成本： 低。该模式的重构成本实际上还与调用类自己的实例化方式相关。如果调用类是通过 Factory 方 式（此处“ Factory 方式”泛指对象的实例化通过 Factory Method 或 Abstract Factory 这样的相对独立出来的 方式构造）构造的，那么，重构成本相对就会更低。否则，重构时可能除了增加调用类的子类，还要将所有实例化调用类的地方，修改为以新增的子类代替。可能这 样的子类还不止一个，那就可以考虑迭代应用模式来改善调用类的实例化代码。

1.2 Abstract Factory

思想： 不直接通过对象的具体实现类，而是通过使用专门的类来负责一组相关联的对象的创建。

场景： 最典型的应用场景是：您只想暴露对象的接口而不想暴露具体的实现类，但是又想提供实例化对象的接口给用户；或者，您希望所有的对象能够 集中在一个或一组类（通常称作工厂类）来创建，从而可以更方便的对对象的实例化过程进行动态配置（此时只需要修改工厂类的代码或配置）。

实现： 该模式的实现是比较清晰简单的，如上图，就是定义创建和返回各种类对象实例的工厂类。在最复杂而灵活的情形，无论工厂类本身还是被创建 的对象类都可能需要有一个继承体系。简单情形其实可以只是一个工厂类和需要被创建的对象类。不一定非要像上图中结构那么完备（累赘）。

重构成本： 中。如果一开始所有的对象都是直接创建，例如通过 new 实例化的， 而之后想重构为 Abstract Factory 模式，那么，很自然的我们需要替换所有直接的 new 实 例化代码为对工厂类对象创建方法的调用。考虑到像 Resharper 这样的重构工具的支持，找出对 某个方法或构造函数的调用位置这样的操作相对还是比较容易，重构成本也不是非常高。同时，重构成本还和被创建对象的构造函数的重载数量相关。您需要根据实 际情况考虑，是否工厂类要映射被创建对象的所有重载版本的构造函数。

1.3 Builder

思想： 将一个类的创建过程和他的主体部分分离。

场景： 该模式的典型的应用场景是：一个类的创建过程可能比较复杂，或者创建过程中的某些阶段可能会容易变化；或者多个类的创建过程比较类似， 但是主体不同。

实现： 在 以上提到的两种场景中，我们就可以取出一个类的创建过程的代码，定义一个专门的 Builder 类， 而在原来创建类对象实例的地方，将这个 Builder 类的实例作为参数传入。还有第二个重点，就是 Builder 类 可以将将整个创建过程分为几个阶段，每个阶段不必在类中直接实现，而可以通过继承体系在子类中实现，或者通过子类的方法过载来修改创建过程中的某个阶段， 但是重用其他的阶段。可以发现，该模式将一个对象的复杂创建过程重用到非常高的层次。这正是它的意义所在。

重构成本： 低。该模式的重构成本我觉得是非常低的，因为一般来讲，创建过程的代码本来也就应该在原来的类的构造函数中，把它 Extract 出 来就好了。如果发现多个类的创建过程有比较多的代码重复或类似，那么就可以重用这些提取出来的 Builder 类 或者 Builder 类中的某些阶段。

1.4 Prototype

思想： 克 隆一个已有的类的实例（大家相比都用过甚至写过类的 Clone 实现，应该很容易理解了）。

场景： 应 用 Clone 的场景应该说非常多，理想情况下我当然希望任何类都能 Clone ， 需要的时候就能 Clone 一份一模一样的出来。

实现： 这 里将的实现主要之实现的表现形式，而不是如何用具体的语言来实现。因此，只要为需要 Clone 能力 的类定义一个 Clone 方法就行。当然，一般，主流的程序语言框架都已经定义了通用的 Clone 接 口（当然也可以自己定义），继承并实现该接口和方法就好。

重构成本： 极低。不多解释了吧。

1.5 Singleton

思想： 保证一个类只有一个唯一的实例。

场景： 生活中有些对象就是只要一个就好了，我们的代码中为什么要每次都为这样的对象生成一个实例呢？

实现： 最 简单的实现方式就是使用一个 static 型的类实例，每次对该对象的创建请求都返回这个 static 的 唯一实例就行。

重构成本： 极低。

2 结构型

2.1 Adapter

思想： 将一个类的接口转换成另外一个接口，使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。

场景： 该 模式的应用场景太多了，很多需要的功能模块的接口和我们需要的不完全一致或者有多余或不足，但是需要和我们的系统协同工作，通过 Adapter 把 它包装一下就能让使它接口兼容了。

实现： 定 义一个 Adapter 类，包含需要包装的类，实现需要的其它接口，调用被包装的类的方法来实现需要 的接口。

重构成本： 低。

2.2 Bridge

思想： 将一个类的抽象定义和具体实现解耦。

场景： 该 模式的典型应用场景是：一个类的抽象定义已经确定，但是，其实现代码甚至原理可能会不同。比如：我们最熟悉的图形界面中的 window 的 实现，无论在什么操作系统，什么平台的机器上，一个 window 应具有的抽象定义基本上是一致的， 但是，其实现代码肯定会因为平台不同，机器的代码指令不同而不同。此时，如果希望您写的 window 类 能跨平台，应用 Bridge 模式就是一个好主意。

实现： 该 模式的实现方法很简单，就是除了定义类的抽象定义之外，将一个类的所有实现代码独立出一个实现类。这样一来，无论是抽象定义还是实现类都能分别修改和重 用，但只要两部分的交互接口不变，还是可以方便的互相组装。当然，实际上也没有必要隔离出“所有实现代码”，只需要隔离需要的部分就行了。因此，也可以 说，从代码结构来看， Builder 模式是一种变种的 Bridge 模 式的。也经常有人将 Bridge 模式和接口相比较，如果隔离出所有的实现，那么的确接口的方式也能 做到抽象定义和实现分离，但是， Bridge 有其优势如下：一、究竟隔离多少代码到 Bridge 类 中可以灵活确定，二、减少了总的类的数目，三、允许被隔离出来的 Bridge 类被其它的类直接共享 使用。

重构成本： 中。将所有的（或很大部分）实现代码分离开来总还是一件不大，但是，也不小的事。所以标个“中”在这里。：）

2.3 Composite

思想： 将 对象组合成树形结构以表示“部分 - 整体”的层次结构，使得用户对单个对象和组合对象的使用具有一致 性。

场景： 该 模式的应用场景极其类似，比如像图形系统，如电路设计、 UML 建模系统，或者像 web 的 显示元素等，都是那种需要整体和部分具有使用接口上的一定的一致性的需求的结构，实际上，我觉得这样的系统如果不使用 Composite 模 式将会是惨不忍睹的。

实现： 该模式的实现主要就是要表示整体或部分的所有类都继承自同一的基类或接口，从而拥有使用接口上一定的一致性。

重构成本： 高。

2.4 Decorator

思想： 为一个对象已有的子类添加一些额外的职责。

场景： 该模式的使用场景，主要是有的时候我们不愿意定义逻辑上新的子类，因为没有新的逻辑含义上的子类概念，而只是想为一个已存在的子类附加 一些职责。

实现： 该 模式的实现主要就是定义一个物理上的新的子类，但是，它只是包含要附加职责的类，传递外部对相同接口的调用，在这个传递调用的通道上附加额外的功能。突然 想到， Decorator 模式是不是一定程度上也能代替 DynamicProxy 模 式，从而成为一种 AOP 实现的方案呢？

重构成本： 低。定义一个 Decorator 和一个已有类的逻辑上的子类，物理 表现形式上都是一个子类，重构也确实不是难事。

2.5 Facade

思想： 为子系统中的一组接口提供一个一致的界面，这个接口使得这一子系统更加容易使用。

场景： 当 你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性， 也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。 Facade 可 以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过 Facade 层。 客户程序与抽象类的实现部分之间存在着很大的依赖性。引入 Facade 将这个子系统与客户以及其他 的子系统分离，可以提高子系统的独立性和可移植性。当你需要构建一个层次结构的子系统时，使用 Facade 模 式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过 Facade 进行通 讯，从而简化了它们之间的依赖关系。（这里直接引用了《设计模式迷你手册》，因为觉得它确实已经说得很明了了，下面类似的情形我直接引用原文的就不再注明 了，这里先说明一下，感谢《手册》作者的这些优秀总结。当然，本文的绝大多数文字都是 Teddy 本 人的原创看法，绝非抄袭，您可以比较本文和附件《手册》，附件同时也会提供本文的 Word 版本下 载。）

实现： 该 模式的实现需要定义一个新的系统构架上的 Layer ，该层向上提供一组新的接口，向下调用子系统原 有的接口。

重构成本： 高。要修改所有直接对子系统的地调用为对 Façade 层的调用还是 有很多事情要做的。不过，现代 IDE 中，如果我们删除调用层对子系统的程序集引用，那么所有这些我 们需要修改的调用都能标示出来，因为编译不能通过了嘛，因此，重构的风险还不算特别大，只是工作量着实不小。

2.6 Flyweight

思想： 说 Flyweight 可 能有的朋友第一次看到想象不到是什么样子，其实说他就是一个 Pool ，你可能就明白了。也就是由一 个 Flyweight Factory 来管理一族一定数目逻辑上经常需要构建和销毁的细颗粒对象， 例如我们常见的数据库连接池。在 Factory 内部，并不物理销毁这些对象，而在接到实例化请求时 返回这些被关系对象的实例，从而减少创建销毁这些细颗粒对象的开销。

场景： 基 本上所有的需要 Pool 这个概念的环境都能应用。

实现： 实现的底层方式可以千变万化，在接口上就是如上图所示，花样不多。这里就不多解释。

重构成本： 低。

2.7 Proxy

思想： 前 面在 Decorator 模式中也提到了 Proxy 模 式了。它是通过逻辑上继承一个已有类的子类，从而扩展原有的子类的功能。

场景： 需 要注意体会他和 Decorator 的需别。 Proxy 是 继承需要修饰的类，而 Decorator 用的是包含的方式。 Proxy 模 式，或者准确地说 DynamicProxy 模式，是现代 AOP 框 架实现中的一种常用方式。典型的实现如 Spring ， JBoss 以 及 Castle Project 中的 Aspect# 。

实现： 继承，并在过载方法中添加需要的修饰功能。

重构成本： 低。

3 行为型

3.1 Interpreter

思想： 当 有一个语言需要解释执行 , 并且你可将该语言中的句子表示为一个抽象语法树时，定义一个解释器，这 个解释器使用该表示来解释语言中的句子。

场景： 其 实，从物理结构上，该模式的代码架构看起来可能和 Composite 模式一模一样，致使其针对的逻 辑语义不同。 Composite 模式描述一种一般的整体和部分使用接口上的一致性，而 Interpreter 模 式则侧重于语言解释器的实现构架。

实现： 如 上图，基本同 Composite 模式。

重构成本： 高。

3.2 Iterator

思想： 提 供一种方法顺序访问一个聚合对象中各个元素 , 而又不需暴露该对象的内部表示。

场景： 访 问一个聚合对象的内容而无需暴露它的内部表示。支持对聚合对象的多种遍历。为遍历不同的聚合结构提供一个统一的接口 ( 即 , 支持多态迭代 ) 。

实现： 其 实就是定义一个逻辑上类似一个指针的迭代类。专门用于这种迭代工作。如果对 C++ STL 火锅功夫 学习的朋友一定不会陌生啦。实际使用过一下就明白了。除了功能之外，他给我最大的感受就是他让我熟悉的 for(int i = 0; i < list.Count; i++) 语句，变长了好多。 ^-^

重构成本： 中。

3.3 Mediator

思想： 用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

场景： 该模式主要用来进行降低一组相互关联调用的对象间的耦合度。如果您发现您的系统的某部分的一组对象间调用极其频繁的坏味道的话，可能您 需要考虑使用该模式来进行一些解耦，否则，这些对象中的任何一个的修改，都将可能导致其他对象许多地方的修改，可维护性就降低了。

实现： 定义一个专门的中介对象来封装和传递一组对象间的调用。

重构成本： 中。

3.4 Memento

思想： 用在不破坏封装性的前提下，捕获一个对象的内部状态，并在该对象之外保存这个状态。这样以后就可将该对象恢复到原先保存的状态。

场景： 该 模式主要用来实现类似我们在常见的编辑器中经常执行的 Undo （ Ctrl+Z ） 操作。实际上就是在外部保持一组对象的某一时刻的状态，并在需要的另一个时候将这组对象回复到之前的状态。

实现： 该 模式其实主要是一种对象状态的暂存和回复的思想。上面的 UML 图是一种比较典型的实现方式——定一 个专门用于保存类状态的类，为被保存状态的类定义返回当前状态类实例，和根据状态类实例回复对象状态的接口。实际上也不必太拘泥于这个实现，简单情形下， 我们完全可以利用任何的已有的对象持久化或者序列化机制来用一个字符串暂存对象的当前完整状态。

重构成本： 低。

3.5 Template Method

思想： 定 义一个操作中的算法的骨架，而将一些步骤延迟到子类中。 Te m p l a t e M e t h o d 使 得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

场景： 该 模式实际上是一种非常直观和可理解的 OO 思想下的代码重用的实现。只需一次性实现一个算法的不变的 部分，并将可变的行为留给子类来实现。各子类中公共的行为应被提取出来并集中到一个公共父类中以避免代码重复。模板方法只允许在特定点计算法的某个阶段被 过载，这样也就只允许在这些点进行扩展。

实现： 见上图，太简单了，就不多说了。

重构成本： 低。

3.6 Chain of Responsibility

思想： 使多个对象都有机会处理请求，从而避免请求的发送者和接收者之间的耦合关系。将这些对象连成一条链，并沿着这条链传递该请求，直到有一 个对象处理它为止。

场景： 该模式实际上是对人们常会不自觉地去做的一种代码组织方式的总结而已。有的时候一条消息需要被处理，我们当然可以在一个雷的一个方法中 对他进行所有需要的处理。但是，如果要做的处理很复杂的情形，甚至能够按照一定的逻辑醒来分类所有这些处理，则不要在一个雷一个函数里处以一切会更好，我 们可以定义多个处理类类表示逻辑上的不同的处理，然后一个个处理类的传递这个消息对象，让希望处理该消息的类自己决定是不是要处理。这样，就能将一个难以 维护的复杂处理过程，分解为一系列简单明了，易于维护的类了。

实现： 上图是实现方式之一。即，使所有可能处理该请求的对象继承自一个基类，实际上，只要逻辑语义上我们保持这样一种让每个处理类自己决定何 时处理，并传递请求的思想，实现方式也可以千变万化，无论是用接口代替，或者甚至只是简单的定义相同结构的处理函数而通过反射机制来调用处理函数和传递处 理请求，都是可选的方案。

重构成本： 中。

3.7 Command

思想： 将一个动态的执行过程封装成一个对象，可以像处理数据来处理和管理这样的对象，在需要的时候激发该对象的方法就能执行被封装的执行过 程。

场景： 该模式在很多时候非常有用，它使得我们对逻辑上已经激发的行为进行优化成为可能，我们不仅可以根据需要改变一组逻辑上以经济法的活动的 顺序，消冗余操作，撤销不必要的操作等。也可以把活动和操作视为资源一样来管理和重用。同时该模式也是许多事务处理机制的基础。

实现： 实现很简单，只是定义一些能够通过指定接口被激发的对活动进行封装的类，然后我们按照需要管理这些类，并在需要的时候激发这些活动。您 还是应该更多地去体会，为什么他是事务处理机制的基础，当我们可以这样来管理一组活动的时候，可以对这些活动进行那些有趣的控制。

重构成本： 高。

3.8 Observer

思想： 定 义对象间的一种一对多的依赖关系 , 当一个对象的状态发生改变时 , 所 有依赖于它的对象都得到通知并被自动更新。

场景： 上面描述该模式思想的文字可能显得有些拗口，实际上你也不用想得过于复杂。只要你写过任何的基于图形界面的程序，那么实际上您对他是一 点也不该陌生的。它就是我们每一次鼠标键盘敲击都在我们的程序内部流转着的事件机制的基础。当一个事件发生，则通知订阅该事件的对象。

实现： 上 面的 UML 图看似复杂，实际上，去理解它的最好的办法就是试着思考和使用任何一种 OO 语 言来定义一个拥有事件机制的类。比如， .Net 下，你只要好好去看看关于 delegate 的 文档，尝试着根据 MSDN 写写看一个最简单的自定义事件。那么，上面的 UML 图， 我敢保证你能很轻易的看明白。

重构成本： 高。

3.9 State

思想： 允许一个对象在其内部状态改变时改变它的行为。

场景： 实 际上该模式在作为重构的目的是，绝大多数情况我们做的事情是将对一个类的 state 进行 if-else 或 者 select-case ，决定该执行什么操作的过程解耦的过程。

实现： 将 表述一个类的某些操作该做什么，该怎么做的信息保存到其 state 中。即用一个包含更多信息，甚至 执行逻辑的 state 类实例来代替一个简单数据类型的 state 属 性。

重构成本： 中。

3.10 Strategy

思想： 定 义一系列的算法 , 把它们一个个封装起来 , 并 且使它们可相互替换。本模式使得算法可独立于使用它的客户而变化。

场景： 该 模式实际上也可以理解为一种 Bridge 模式的变种。只是它突出的是，一般当我们把一个类或者一组 类的一些代码独立成一个 Strategy 类的时候，我们可能会为同样接口的这些算法定义多个接口一 致，但是实现方法不同的版本，并在需要的时候灵活的替换这些算法。

实现： 实 现方式同 Bridge 模式。

重构成本： 中。

3.11 Visitor

思想： 表 示一个作用于某对象结构中的各元素的操作。它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

场景： 其 实你不用去理解上面这句话。该模式其实又是一个在代码的物理结构上和 Bridge 模式很相似的模 式。但是，其语义，其目的，在逻辑上又是不同的。如果说 Bridge ，以及上述我称为可视为 Bridge 扩 展的模式中，作为参数的 Bridge 类，是作为调用类的被访问对象的话， Visitor ， 在大多数情形下，如其英文含义，它在语义上是完全相反的。不是他被调用的类处理，更大程度上它处于主动状态，是它去访问，去处理调用它的类。调用它的类， 把自己对别人隐藏起来的东西，暴露给 Visitor 品尝，任君蹂躏（这个，这个 ~~ 千 万别想歪了 ;- ））。另一方面，即使逻辑上没有这种 Visitor 主 动去访问调用类的语义，只要 Visitor 类中的操作，是依赖于调用类的具体实现类（它本身或他某 个层次的子类）的某些状态或者方法的，那么，就可以应用该模式来分离出这样的可重用的操作。

实现： 类 似 Bridge 模式。

重构成本： 中。