软件工程的23种设计模式的UML类图.docx

软件工程的23种设计模式的UML类图.docx

《软件工程的23种设计模式的UML类图.docx》由会员分享，可在线阅读，更多相关《软件工程的23种设计模式的UML类图.docx（14页珍藏版）》请在冰豆网上搜索。

软件工程的23种设计模式的UML类图

二十三种设计模式

0引言

谈到设计模式，绝对应该一起来说说重构。

重构给我们带来了什么.除了作为对遗留代码的改良的方法，另一大意义在于，可以让我们在写程序的时候可以不需事先考虑太多的代码组织问题，当然这其中也包括了应用模式的问题。

尽管大多数开发者都已经养成了写代码前先从设计开场的习惯，但是，这种程度的设计，涉及到到大局、到总体架构、到主要的模块划分我觉得就够了。

换句话说，这时就能写代码了。

这就得益于重构的思想了。

如果没有重构的思想，有希望获得非常高质量的代码，我们就不得不在开场写代码前考虑更多其实并非非常稳定的代码组织及设计模式的应用问题，那开发效率当然就大打折扣了。

在重构和设计模式的合理应用之下，我们可以相对较早的开场写代码，并在功能尽早实现的同时，不断地通过重构和模式来改善我们的代码质量。

所以，下面的章节中，在谈模式的同时，我也会谈谈关于常用的这些模式的重构本钱的理解。

重构本钱越高意味着，在遇到类似的问题情形的时候，我们更应该提前考虑应用对应的设计模式，而重构本钱比拟低则说明，类似的情形下，完全可以先怎么方便，怎么快怎么写，哪怕代码不是很优雅也没关系，回头再重构也很容易。

1创立型

1.1FactoryMethod

思想：

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

场景：

典型的应用场景如：

在*个系统开发的较早阶段，有*些类的实例化过程，实例化方式可能还不是很确定，或者实际实例化的对象〔可能是需要对象的*个子类中的一个〕不确定，或者比拟容易变化。

此时，如果直接将实例化过程写在*个函数中，则一般就是if-else或select-case代码。

如果，候选项的数目较少、类型根本确定，则这样的if-else还是可以承受的，一旦情形变得复杂、不确定性增加，更甚至包含这个构造过程的函数所在的类包含几个甚至更多类似的函数时，这样的if-else代码就会变得比拟不则容易维护了。

此时，应用本模式，可以将这种复杂情形隔离开，即将这类不确定的对象的实例化过程延迟到子类。

实现：

该模式的典型实现方法就是将调用类定义为一个虚类，在调用类定义一个专门用于构造不确定的对象实例的虚函数，再将实际的对象实例化代码留到调用类的子类来实现。

如果，被构造的对象比拟复杂的话，同时可以将这个对象定义为可以继承、甚至虚类，再在不同的调用类的子类中按需返回被构造类的子类。

重构本钱：

低。

该模式的重构本钱实际上还与调用类自己的实例化方式相关。

如果调用类是通过Factory方式〔此处“Factory方式〞泛指对象的实例化通过FactoryMethod或AbstractFactory这样的相对独立出来的方式构造〕构造的，则，重构本钱相对就会更低。

否则，重构时可能除了增加调用类的子类，还要将所有实例化调用类的地方，修改为以新增的子类代替。

可能这样的子类还不止一个，那就可以考虑迭代应用模式来改善调用类的实例化代码。

1.2AbstractFactory

思想：

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

场景：

最典型的应用场景是：

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

实现：

该模式的实现是比拟清晰简单的，如上图，就是定义创立和返回各种类对象实例的工厂类。

在最复杂而灵活的情形，无论工厂类本身还是被创立的对象类都可能需要有一个继承体系。

简单情形其实可以只是一个工厂类和需要被创立的对象类。

不一定非要像上图中构造则完备〔累赘〕。

重构本钱：

中。

如果一开场所有的对象都是直接创立，例如通过new实例化的，而之后想重构为AbstractFactory模式，则，很自然的我们需要替换所有直接的new实例化代码为对工厂类对象创立方法的调用。

考虑到像Resharper这样的重构工具的支持，找出对*个方法或构造函数的调用位置这样的操作相对还是比拟容易，重构本钱也不是非常高。

同时，重构本钱还和被创立对象的构造函数的重载数量相关。

您需要根据实际情况考虑，是否工厂类要映射被创立对象的所有重载版本的构造函数。

1.3Builder

思想：

将一个类的创立过程和他的主体局部别离。

场景：

该模式的典型的应用场景是：

一个类的创立过程可能比拟复杂，或者创立过程中的*些阶段可能会容易变化；或者多个类的创立过程比拟类似，但是主体不同。

实现：

在以上提到的两种场景中，我们就可以取出一个类的创立过程的代码，定义一个专门的Builder类，而在原来创立类对象实例的地方，将这个Builder类的实例作为参数传入。

还有第二个重点，就是Builder类可以将将整个创立过程分为几个阶段，每个阶段不必在类中直接实现，而可以通过继承体系在子类中实现，或者通过子类的方法过载来修改创立过程中的*个阶段，但是重用其他的阶段。

可以发现，该模式将一个对象的复杂创立过程重用到非常高的层次。

这正是它的意义所在。

重构本钱：

低。

该模式的重构本钱我觉得是非常低的，因为一般来讲，创立过程的代码本来也就应该在原来的类的构造函数中，把它E*tract出来就好了。

如果发现多个类的创立过程有比拟多的代码重复或类似，则就可以重用这些提取出来的Builder类或者Builder类中的*些阶段。

1.4Prototype

思想：

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

场景：

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

实现：

这里将的实现主要之实现的表现形式，而不是如何用具体的语言来实现。

因此，只要为需要Clone能力的类定义一个Clone方法就行。

当然，一般，主流的程序语言框架都已经定义了通用的Clone接口〔当然也可以自己定义〕，继承并实现该接口和方法就好。

重构本钱：

极低。

不多解释了吧。

1.5Singleton

思想：

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

场景：

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

实现：

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

重构本钱：

极低。

2构造型

2.1Adapter

思想：

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

场景：

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

实现：

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

重构本钱：

低。

2.2Bridge

思想：

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

场景：

该模式的典型应用场景是：

一个类的抽象定义已经确定，但是，其实现代码甚至原理可能会不同。

比方：

我们最熟悉的图形界面中的window的实现，无论在什么操作系统，什么平台的机器上，一个window应具有的抽象定义根本上是一致的，但是，其实现代码肯定会因为平台不同，机器的代码指令不同而不同。

此时，如果希望您写的window类能跨平台，应用Bridge模式就是一个好主意。

实现：

该模式的实现方法很简单，就是除了定义类的抽象定义之外，将一个类的所有实现代码独立出一个实现类。

这样一来，无论是抽象定义还是实现类都能分别修改和重用，但只要两局部的交互接口不变，还是可以方便的互相组装。

当然，实际上也没有必要隔离出“所有实现代码〞，只需要隔离需要的局部就行了。

因此，也可以说，从代码构造来看，Builder模式是一种变种的Bridge模式的。

也经常有人将Bridge模式和接口相比拟，如果隔离出所有的实现，则确实接口的方式也能做到抽象定义和实现别离，但是，Bridge有其优势如下：

一、终究隔离多少代码到Bridge类中可以灵活确定，二、减少了总的类的数目，三、允许被隔离出来的Bridge类被其它的类直接共享使用。

重构本钱：

中。

将所有的〔或很大局部〕实现代码别离开来总还是一件不大，但是，也不小的事。

所以标个“中〞在这里。

：

〕

2.3posite

思想：

将对象组合成树形构造以表示“局部-整体〞的层次构造，使得用户对单个对象和组合对象的使用具有一致性。

场景：

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

实现：

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

重构本钱：

高。

2.4Decorator

思想：

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

场景：

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

实现：

该模式的实现主要就是定义一个物理上的新的子类，但是，它只是包含要附加职责的类，传递外部对一样接口的调用，在这个传递调用的通道上附加额外的功能。

突然想到，Decorator模式是不是一定程度上也能代替DynamicPro*y模式，从而成为一种AOP实现的方案呢.

重构本钱：

低。

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

2.5Facade

思想：

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

场景：

当你要为一个复杂子系统提供一个简单接口时。

子系统往往因为不断演化而变得越来越复杂。

大多数模式使用时都会产生更多更小的类。

这使得子系统更具可重用性，也更容易对子系统进展定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。

Facade可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过Facade层。

客户程序与抽象类的实现局部之间存在着很大的依赖性。

引入Facade将这个子系统与客户以及其他的子系统别离，可以提高子系统的独立性和可移植性。

当你需要构建一个层次构造的子系统时，使用Facade模式定义子系统中每层的入口点。

如果子系统之间是相互依赖的，你可以让它们仅通过Facade进展通讯，从而简化了它们之间的依赖关系。

〔这里直接引用了"设计模式迷你手册"，因为觉得它确实已经说得很明了了，下面类似的情形我直接引用原文的就不再注明了，这里先说明一下，感谢"手册"作者的这些优秀总结。

当然，本文的绝大多数文字都是Teddy本人的原创看法，绝非抄袭，您可以比拟本文和"手册"，同时也会提供本文的Word版本下载。

〕

实现：

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

重构本钱：

高。

要修改所有直接对子系统的地调用为对Façade层的调用还是有很多事情要做的。

不过，现代IDE中，如果我们删除调用层对子系统的程序集引用，则所有这些我们需要修改的调用都能标示出来，因为编译不能通过了嘛，因此，重构的风险还不算特别大，只是工作量着实不小。

2.6Flyweight

思想：

说Flyweight可能有的朋友第一次看到想象不到是什么样子，其实说他就是一个Pool，你可能就明白了。

也就是由一个FlyweightFactory来管理一族一定数目逻辑上经常需要构建和销毁的细颗粒对象，例如我们常见的数据库连接池。

在Factory部，并不物理销毁这些对象，而在接到实例化请求时返回这些被关系对象的实例，从而减少创立销毁这些细颗粒对象的开销。

场景：

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

实现：

实现的底层方式可以千变万化，在接口上就是如上图所示，把戏不多。

这里就不多解释。

重构本钱：

低。

2.7Pro*y

思想：

前面在Decorator模式中也提到了Pro*y模式了。

它是通过逻辑上继承一个已有类的子类，从而扩展原有的子类的功能。

场景：

需要注意体会他和Decorator的需别。

Pro*y是继承需要修饰的类，而Decorator用的是包含的方式。

Pro*y模式，或者准确地说DynamicPro*y模式，是现代AOP框架实现中的一种常用方式。

典型的实现如Spring，oss以及CastleProject中的Aspect*。

实现：

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

重构本钱：

低。

3行为型

3.1Interpreter

思想：

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

场景：

其实，从物理构造上，该模式的代码架构看起来可能和posite模式一模一样，致使其针对的逻辑语义不同。

posite模式描述一种一般的整体和局部使用接口上的一致性，而Interpreter模式则侧重于语言解释器的实现构架。

实现：

如上图，根本同posite模式。

重构本钱：

高。

3.2Iterator

思想：

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

场景：

访问一个聚合对象的容而无需暴露它的部表示。

支持对聚合对象的多种遍历。

为遍历不同的聚合构造提供一个统一的接口（即,支持多态迭代）。

实现：

其实就是定义一个逻辑上类似一个指针的迭代类。

专门用于这种迭代工作。

如果对C++STL火锅功夫学习的朋友一定不会陌生啦。

实际使用过一下就明白了。

除了功能之外，他给我最大的感受就是他让我熟悉的for（inti=0;i

^-^

重构本钱：

中。

3.3Mediator

思想：

用一个中介对象来封装一系列的对象交互。

中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

场景：

该模式主要用来进展降低一组相互关联调用的对象间的耦合度。

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

实现：

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

重构本钱：

中。

3.4Memento

思想：

用在不破坏封装性的前提下，捕获一个对象的部状态，并在该对象之外保存这个状态。

这样以后就可将该对象恢复到原先保存的状态。

场景：

该模式主要用来实现类似我们在常见的编辑器中经常执行的Undo〔Ctrl+Z〕操作。

实际上就是在外部保持一组对象的*一时刻的状态，并在需要的另一个时候将这组对象回复到之前的状态。

实现：

该模式其实主要是一种对象状态的暂存和回复的思想。

上面的UML图是一种比拟典型的实现方式——定一个专门用于保存类状态的类，为被保存状态的类定义返回当前状态类实例，和根据状态类实例回复对象状态的接口。

实际上也不必太拘泥于这个实现，简单情形下，我们完全可以利用任何的已有的对象持久化或者序列化机制来用一个字符串暂存对象的当前完整状态。

重构本钱：

低。

3.5TemplateMethod

思想：

定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。

TemplateMethod使得子类可以不改变一个算法的构造即可重定义该算法的*些特定步骤。

场景：

该模式实际上是一种非常直观和可理解的OO思想下的代码重用的实现。

只需一次性实现一个算法的不变的局部，并将可变的行为留给子类来实现。

各子类中公共的行为应被提取出来并集中到一个公共父类中以防止代码重复。

模板方法只允许在特定点计算法的*个阶段被过载，这样也就只允许在这些点进展扩展。

实现：

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

重构本钱：

低。

3.6ChainofResponsibility

思想：

使多个对象都有时机处理请求，从而防止请求的发送者和接收者之间的耦合关系。

将这些对象连成一条链，并沿着这条链传递该请求，直到有一个对象处理它为止。

场景：

该模式实际上是对人们常会不自觉地去做的一种代码组织方式的总结而已。

有的时候一条消息需要被处理，我们当然可以在一个雷的一个方法中对他进展所有需要的处理。

但是，如果要做的处理很复杂的情形，甚至能够按照一定的逻辑醒来分类所有这些处理，则不要在一个雷一个函数里处以一切会更好，我们可以定义多个处理类类表示逻辑上的不同的处理，然后一个个处理类的传递这个消息对象，让希望处理该消息的类自己决定是不是要处理。

这样，就能将一个难以维护的复杂处理过程，分解为一系列简单明了，易于维护的类了。

实现：

上图是实现方式之一。

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

重构本钱：

中。

3.7mand

思想：

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

场景：

该模式在很多时候非常有用，它使得我们对逻辑上已经激发的行为进展优化成为可能，我们不仅可以根据需要改变一组逻辑上以经济法的活动的顺序，消冗余操作，撤销不必要的操作等。

也可以把活动和操作视为资源一样来管理和重用。

同时该模式也是许多事务处理机制的根底。

实现：

实现很简单，只是定义一些能够通过指定接口被激发的对活动进展封装的类，然后我们按照需要管理这些类，并在需要的时候激发这些活动。

您还是应该更多地去体会，为什么他是事务处理机制的根底，当我们可以这样来管理一组活动的时候，可以对这些活动进展那些有趣的控制。

重构本钱：

高。

3.8Observer

思想：

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

场景：

上面描述该模式思想的文字可能显得有些拗口，实际上你也不用想得过于复杂。

只要你写过任何的基于图形界面的程序，则实际上您对他是一点也不该陌生的。

它就是我们每一次鼠标键盘敲击都在我们的程序部流转着的事件机制的根底。

当一个事件发生，则通知订阅该事件的对象。

实现：

上面的UML图看似复杂，实际上，去理解它的最好的方法就是试着思考和使用任何一种OO语言来定义一个拥有事件机制的类。

比方，.Net下，你只要好好去看看关于delegate的文档，尝试着根据MSDN写写看一个最简单的自定义事件。

则，上面的UML图，我敢保证你能很轻易的看明白。

重构本钱：

高。

3.9State

思想：

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

场景：

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

实现：

将表述一个类的*些操作该做什么，该怎么做的信息保存到其state中。

即用一个包含更多信息，甚至执行逻辑的state类实例来代替一个简单数据类型的state属性。

重构本钱：

中。

3.10Strategy

思想：

定义一系列的算法,把它们一个个封装起来,并且使它们可相互替换。

本模式使得算法可独立于使用它的客户而变化。

场景：

该模式实际上也可以理解为一种Bridge模式的变种。

只是它突出的是，一般当我们把一个类或者一组类的一些代码独立成一个Strategy类的时候，我们可能会为同样接口的这些算法定义多个接口一致，但是实现方法不同的版本，并在需要的时候灵活的替换这些算法。

实现：

实现方式同Bridge模式。

重构本钱：

中。

3.11Visitor

思想：

表示一个作用于*对象构造中的各元素的操作。

它使你可以在不改变各元素的类的前提下定义作用于这些元素的新操作。

场景：

其实你不用去理解上面这句话。

该模式其实又是一个在代码的物理构造上和Bridge模式很相似的模式。

但是，其语义，其目的，在逻辑上又是不同的。

如果说Bridge，以及上述我称为可视为Bridge扩展的模式中，作为参数的Bridge类，是作为调用类的被访问对象的话，Visitor，在大多数情形下，如其英文含义，它在语义上是完全相反的。

不是他被调用的类处理，更大程度上它处于主动状态，是它去访问，去处理调用它的类。

调用它的类，把自己对别人隐藏起来的东西，暴露给Visitor品尝，任君蹂躏〔这个，这个~~千万别想歪了;-〕〕。

另一方面，即使逻辑上没有这种Visitor主动去访问调用类的语义，只要Visitor类中的操作，是依赖于调用类的具体实现类〔它本身或他*个层次的子类〕的*些状态或者方法的，则，就可以应用该模式来别离出这样的可重用的操作。

实现：

类似Bridge模式。

重构本钱：

中。