Python学习路程-常用设计模式学习

本节内容

1. 设计模式介绍
2. 设计模式分类
3. 设计模式6大原则

1.设计模式介绍

设计模式（Design Patterns）

——可复用面向对象软件的基础

设计模式（Design pattern）是一套被反复使用、多数人知晓的、经过分类编目的、代码设计经验的总结。使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 毫无疑问，设计模式于己于他人于系统都是多赢的，设计模式使代码编制真正工程化，设计模式是软件工程的基石，如同大厦的一块块砖石一样。项目中合理的运用设计模式可以完美的解决很多问题，每种模式在现在中都有相应的原理来与之对应，每一个模式描述了一个在我们周围不断重复发生的问题，以及该问题的核心解决方案，这也是它能被广泛应用的原因。

2. 设计模式分类

经典的《设计模式》一书归纳出23种设计模式，这23种模式又可归为，创建型、结构型和行为型3大类

2.1．创建型模式

前面讲过，社会化的分工越来越细，自然在软件设计方面也是如此，因此对象的创建和对象的使用分开也就成为了必然趋势。因为对象的创建会消耗掉系统的很多资源，所以单独对对象的创建进行研究，从而能够高效地创建对象就是创建型模式要探讨的问题。这里有6个具体的创建型模式可供研究，它们分别是：

简单工厂模式（Simple Factory）；

工厂方法模式（Factory Method）；

抽象工厂模式（Abstract Factory）；

创建者模式（Builder）；

原型模式（Prototype）；

单例模式（Singleton）。

说明：严格来说，简单工厂模式不是GoF总结出来的23种设计模式之一。

2.2 结构型模式

在解决了对象的创建问题之后，对象的组成以及对象之间的依赖关系就成了开发人员关注的焦点，因为如何设计对象的结构、继承和依赖关系会影响到后续程序的维护性、代码的健壮性、耦合性等。对象结构的设计很容易体现出设计人员水平的高低，这里有7个具体的结构型模式可供研究，它们分别是：

外观模式（Facade）；

适配器模式（Adapter）；

代理模式（Proxy）；

装饰模式（Decorator）；

桥模式（Bridge）；

组合模式（Composite）；

享元模式（Flyweight）

2.3 行为型模式

在对象的结构和对象的创建问题都解决了之后，就剩下对象的行为问题了，如果对象的行为设计的好，那么对象的行为就会更清晰，它们之间的协作效率就会提高，这里有11个具体的行为型模式可供研究，它们分别是：

模板方法模式（Template Method）；

观察者模式（Observer）；

状态模式（State）；

策略模式（Strategy）；

职责链模式（Chain of Responsibility）；

命令模式（Command）；

访问者模式（Visitor）；

调停者模式（Mediator）；

备忘录模式（Memento）；

迭代器模式（Iterator）；

解释器模式（Interpreter）。

3. 设计模式的六大原则

1、开闭原则（Open Close Principle）

开闭原则就是说对扩展开放，对修改关闭。在程序需要进行拓展的时候，不能去修改原有的代码，实现一个热插拔的效果。所以一句话概括就是：为了使程序的扩展性好，易于维护和升级。想要达到这样的效果，我们需要使用接口和抽象类，后面的具体设计中我们会提到这点。

2、里氏代换原则（Liskov Substitution Principle）

里氏代换原则(Liskov Substitution Principle LSP)面向对象设计的基本原则之一。 里氏代换原则中说，任何基类可以出现的地方，子类一定可以出现。 LSP是继承复用的基石，只有当衍生类可以替换掉基类，软件单位的功能不受到影响时，基类才能真正被复用，而衍生类也能够在基类的基础上增加新的行为。里氏代换原则是对“开-闭”原则的补充。实现“开-闭”原则的关键步骤就是抽象化。而基类与子类的继承关系就是抽象化的具体实现，所以里氏代换原则是对实现抽象化的具体步骤的规范。—— From Baidu 百科

3、依赖倒转原则（Dependence Inversion Principle）

这个是开闭原则的基础，具体内容：真对接口编程，依赖于抽象而不依赖于具体。

4、接口隔离原则（Interface Segregation Principle）

这个原则的意思是：使用多个隔离的接口，比使用单个接口要好。还是一个降低类之间的耦合度的意思，从这儿我们看出，其实设计模式就是一个软件的设计思想，从大型软件架构出发，为了升级和维护方便。所以上文中多次出现：降低依赖，降低耦合。

5、迪米特法则（最少知道原则）（Demeter Principle）

为什么叫最少知道原则，就是说：一个实体应当尽量少的与其他实体之间发生相互作用，使得系统功能模块相对独立。

6、合成复用原则（Composite Reuse Principle）

原则是尽量使用合成/聚合的方式，而不是使用继承。

工厂模式

工厂模式（Factory Pattern）是 Java 中最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

意图：

定义一个用于创建对象的接口，让子类决定实例化哪一个类。Factory Method 使一个类的实例化延迟到其子类。

适用性：

当一个类不知道它所必须创建的对象的类的时候。

当一个类希望由它的子类来指定它所创建的对象的时候。

当类将创建对象的职责委托给多个帮助子类中的某一个，并且你希望将哪一个帮助子类是代理者这一信息局部化的时候。

简单工厂模式

+

优点：客户端不需要修改代码。
缺点： 当需要增加新的运算类的时候，不仅需新加运算类，还要修改工厂类，违反了开闭原则。　　

工厂方法模式

这个和简单工厂有区别，简单工厂模式只有一个工厂，工厂方法模式对每一个产品都有相应的工厂

　　好处：增加一个运算类（例如N次方类），只需要增加运算类和相对应的工厂，两个类，不需要修改工厂类。

　　缺点：增加运算类，会修改客户端代码，工厂方法只是把简单工厂的内部逻辑判断移到了客户端进行。

+

　　

抽象工厂模式

每一个模式都是针对一定问题的解决方案。抽象工厂模式与工厂方法模式的最大区别就在于，工厂方法模式针对的是一个产品等级结构；而抽象工厂模式则需要面对多个产品等级结构。

　　在学习抽象工厂具体实例之前，应该明白两个重要的概念：产品族和产品等级。

所谓产品族，是指位于不同产品等级结构中，功能相关联的产品组成的家族。比如AMD的主板、芯片组、CPU组成一个家族，Intel的主板、芯片组、CPU组成一个家族。而这两个家族都来自于三个产品等级：主板、芯片组、CPU。一个等级结构是由相同的结构的产品组成，示意图如下：

aaarticlea/png;base64,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" alt="" width="504" height="295" />

显然，每一个产品族中含有产品的数目，与产品等级结构的数目是相等的。产品的等级结构与产品族将产品按照不同方向划分，形成一个二维的坐标系。横轴表示产品的等级结构，纵轴表示产品族，上图共有两个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。

　　上面所给出的三个不同的等级结构具有平行的结构。因此，如果采用工厂方法模式，就势必要使用三个独立的工厂等级结构来对付这三个产品等级结构。由于这三个产品等级结构的相似性，会导致三个平行的工厂等级结构。随着产品等级结构的数目的增加，工厂方法模式所给出的工厂等级结构的数目也会随之增加。如下图：

那么，是否可以使用同一个工厂等级结构来对付这些相同或者极为相似的产品等级结构呢？当然可以的，而且这就是抽象工厂模式的好处。同一个工厂等级结构负责三个不同产品等级结构中的产品对象的创建。

　可以看出，一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。显然，这时候抽象工厂模式比简单工厂模式、工厂方法模式更有效率。对应于每一个产品族都有一个具体工厂。而每一个具体工厂负责创建属于同一个产品族，但是分属于不同等级结构的产品。

抽象工厂模式结构

　　抽象工厂模式是对象的创建模式，它是工厂方法模式的进一步推广。

　　假设一个子系统需要一些产品对象，而这些产品又属于一个以上的产品等级结构。那么为了将消费这些产品对象的责任和创建这些产品对象的责任分割开来，可以引进抽象工厂模式。这样的话，消费产品的一方不需要直接参与产品的创建工作，而只需要向一个公用的工厂接口请求所需要的产品。

　　通过使用抽象工厂模式，可以处理具有相同（或者相似）等级结构中的多个产品族中的产品对象的创建问题。如下图所示：

　　由于这两个产品族的等级结构相同，因此使用同一个工厂族也可以处理这两个产品族的创建问题，这就是抽象工厂模式。

　　根据产品角色的结构图，就不难给出工厂角色的结构设计图。

可以看出，每一个工厂角色都有两个工厂方法，分别负责创建分属不同产品等级结构的产品对象。

抽象工厂的功能是为一系列相关对象或相互依赖的对象创建一个接口。一定要注意，这个接口内的方法不是任意堆砌的，而是一系列相关或相互依赖的方法。比如上面例子中的主板和CPU，都是为了组装一台电脑的相关对象。不同的装机方案，代表一种具体的电脑系列。

由于抽象工厂定义的一系列对象通常是相关或相互依赖的，这些产品对象就构成了一个产品族，也就是抽象工厂定义了一个产品族。

　　这就带来非常大的灵活性，切换产品族的时候，只要提供不同的抽象工厂实现就可以了，也就是说现在是以一个产品族作为一个整体被切换。

在什么情况下应当使用抽象工厂模式

　　1.一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。

　　2.这个系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

　　3.同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。（比如：Intel主板必须使用Intel CPU、Intel芯片组）

　　4.系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

抽象工厂模式的起源

　　抽象工厂模式的起源或者最早的应用，是用于创建分属于不同操作系统的视窗构建。比如：命令按键（Button）与文字框（Text)都是视窗构建，在UNIX操作系统的视窗环境和Windows操作系统的视窗环境中，这两个构建有不同的本地实现，它们的细节有所不同。

　　在每一个操作系统中，都有一个视窗构建组成的构建家族。在这里就是Button和Text组成的产品族。而每一个视窗构件都构成自己的等级结构，由一个抽象角色给出抽象的功能描述，而由具体子类给出不同操作系统下的具体实现。

抽象工厂模式的优点

• 分离接口和实现

　　客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已。也就是说，客户端从具体的产品实现中解耦。

• 使切换产品族变得容易

　　因为一个具体的工厂实现代表的是一个产品族，比如上面例子的从Intel系列到AMD系列只需要切换一下具体工厂。

抽象工厂模式的缺点

• 不太容易扩展新的产品

　　如果需要给整个产品族添加一个新的产品，那么就需要修改抽象工厂，这样就会导致修改所有的工厂实现类。

+

　　

建造者模式

意图：

将一个复杂对象的构建与它的表示分离，使得同样的构建过程可以创建不同的表示。

适用性：

当创建复杂对象的算法应该独立于该对象的组成部分以及它们的装配方式时。

当构造过程必须允许被构造的对象有不同的表示时。

+

　　

单例模式

意图：

保证一个类仅有一个实例，并提供一个访问它的全局访问点。

适用性：

当类只能有一个实例而且客户可以从一个众所周知的访问点访问它时。

当这个唯一实例应该是通过子类化可扩展的，并且客户应该无需更改代码就能使用一个扩展的实例时。

+

　　

适配器模式

意图

将一个类的接口转换成客户希望的另外一个接口。Adapter 模式使得原本由于接口不兼容而不能一起工作的那些类可以一起工作。 
适用性：

你想使用一个已经存在的类，而它的接口不符合你的需求。

你想创建一个可以复用的类，该类可以与其他不相关的类或不可预见的类（即那些接口可能不一定兼容的类）协同工作

+

　　

桥接模式

参考:http://www.cnblogs.com/houleixx/archive/2008/02/23/1078877.html

生活中的一个例子:
    就拿汽车在路上行驶的来说。即有小汽车又有公共汽车，它们都不但能在市区中的公路上行驶，也能在高速公路上行驶。这你会发现，对于交通工具（汽车）有不同的类型，然而它们所行驶的环境（路）也在变化，在软件系统中就要适应两个方面的变化？怎样实现才能应对这种变化呢？
概述:
在软件系统中，某些类型由于自身的逻辑，它具有两个或多个维度的变化，那么如何应对这种“多维度的变化”？如何利用面向对象的技术来使得该类型能够轻松的沿着多个方向进行变化，而又不引入额外的复杂度？这就要使用Bridge模式。
意图:
　　　将抽象部分与实现部分分离，使它们都可以独立的变化。
                                                                    ——《设计模式》GOF

效果及实现要点：
1．Bridge模式使用“对象间的组合关系”解耦了抽象和实现之间固有的绑定关系，使得抽象和实现可以沿着各自的维度来变化。
2．所谓抽象和实现沿着各自维度的变化，即“子类化”它们，得到各个子类之后，便可以任意它们，从而获得不同路上的不同汽车。
3．Bridge模式有时候类似于多继承方案，但是多继承方案往往违背了类的单一职责原则（即一个类只有一个变化的原因），复用性比较差。Bridge模式是比多继承方案更好的解决方法。
4．Bridge模式的应用一般在“两个非常强的变化维度”，有时候即使有两个变化的维度，但是某个方向的变化维度并不剧烈——换言之两个变化不会导致纵横交错的结果，并不一定要使用Bridge模式。

适用性：
   在以下的情况下应当使用桥梁模式：
1．如果一个系统需要在构件的抽象化角色和具体化角色之间增加更多的灵活性，避免在两个层次之间建立静态的联系。
2．设计要求实现化角色的任何改变不应当影响客户端，或者说实现化角色的改变对客户端是完全透明的。
3．一个构件有多于一个的抽象化角色和实现化角色，系统需要它们之间进行动态耦合。
4．虽然在系统中使用继承是没有问题的，但是由于抽象化角色和具体化角色需要独立变化，设计要求需要独立管理这两者。
总结：
      Bridge模式是一个非常有用的模式，也非常复杂，它很好的符合了开放-封闭原则和优先使用对象，而不是继承这两个面向对象原则

+

应用设计模式:
       桥接模式（Bridge）来做(多维度变化);
       结合上面的例子,增加一个维度"人",不同的人开着不同的汽车在不同的路上行驶(三个维度);
       结合上面增加一个类"人",并重新调用.
代码实现:

+

　　

组合模式

意图：

将对象组合成树形结构以表示“部分-整体”的层次结构。C o m p o s i t e 使得用户对单个对象和组合对象的使用具有一致性。 
适用性：

你想表示对象的部分-整体层次结构。

你希望用户忽略组合对象与单个对象的不同，用户将统一地使用组合结构中的所有对象。

+

　　

外观模式

意图：

为子系统中的一组接口提供一个一致的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用。

适用性：

当你要为一个复杂子系统提供一个简单接口时。子系统往往因为不断演化而变得越来越复杂。大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但这也给那些不需要定制子系统的用户带来一些使用上的困难。Facade 可以提供一个简单的缺省视图，这一视图对大多数用户来说已经足够，而那些需要更多的可定制性的用户可以越过facade层。

客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade 将这个子系统与客户以及其他的子系统分离，可以提高子系统的独立性和可移植性。

当你需要构建一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点。如果子系统之间是相互依赖的，你可以让它们仅通过facade进行通讯，从而简化了它们之间的依赖关系。　　

+

　　

享元模式

意图：

运用共享技术有效地支持大量细粒度的对象。

适用性：

一个应用程序使用了大量的对象。

完全由于使用大量的对象，造成很大的存储开销。

对象的大多数状态都可变为外部状态。

如果删除对象的外部状态，那么可以用相对较少的共享对象取代很多组对象。

应用程序不依赖于对象标识。由于Flyweight 对象可以被共享，对于概念上明显有别的对象，标识测试将返回真值。

+

　　

代理模式

意图：为其他对象提供一种代理以控制对这个对象的访问。

主要解决：在直接访问对象时带来的问题，比如说：要访问的对象在远程的机器上。在面向对象系统中，有些对象由于某些原因（比如对象创建开销很大，或者某些操作需要安全控制，或者需要进程外的访问），直接访问会给使用者或者系统结构带来很多麻烦，我们可以在访问此对象时加上一个对此对象的访问层。

何时使用：想在访问一个类时做一些控制。

如何解决：增加中间层。

关键代码：实现与被代理类组合。

应用实例： 1、Windows 里面的快捷方式。 2、猪八戒去找高翠兰结果是孙悟空变的，可以这样理解：把高翠兰的外貌抽象出来，高翠兰本人和孙悟空都实现了这个接口，猪八戒访问高翠兰的时候看不出来这个是孙悟空，所以说孙悟空是高翠兰代理类。 3、买火车票不一定在火车站买，也可以去代售点。 4、一张支票或银行存单是账户中资金的代理。支票在市场交易中用来代替现金，并提供对签发人账号上资金的控制。 5、spring aop。

优点： 1、职责清晰。 2、高扩展性。 3、智能化。

缺点： 1、由于在客户端和真实主题之间增加了代理对象，因此有些类型的代理模式可能会造成请求的处理速度变慢。 2、实现代理模式需要额外的工作，有些代理模式的实现非常复杂。

使用场景：按职责来划分，通常有以下使用场景： 1、远程代理。 2、虚拟代理。 3、Copy-on-Write 代理。 4、保护（Protect or Access）代理。 5、Cache代理。 6、防火墙（Firewall）代理。 7、同步化（Synchronization）代理。 8、智能引用（Smart Reference）代理。

+

模板方法模式

在模板模式（Template Pattern）中，一个抽象类公开定义了执行它的方法的方式/模板。它的子类可以按需要重写方法实现，但调用将以抽象类中定义的方式进行。这种类型的设计模式属于行为型模式。

意图：定义一个操作中的算法的骨架，而将一些步骤延迟到子类中。模板方法使得子类可以不改变一个算法的结构即可重定义该算法的某些特定步骤。

主要解决：一些方法通用，却在每一个子类都重新写了这一方法。

何时使用：有一些通用的方法。

如何解决：将这些通用算法抽象出来。

关键代码：在抽象类实现，其他步骤在子类实现。

应用实例： 1、在造房子的时候，地基、走线、水管都一样，只有在建筑的后期才有加壁橱加栅栏等差异。 2、西游记里面菩萨定好的 81 难，这就是一个顶层的逻辑骨架。 3、Spirng 中对 Hibernate 的支持，将一些已经定好的方法封装起来，比如开启事务、获取 Session、关闭 Session 等，程序员不重复写那些已经规范好的代码，直接丢一个实体就可以保存。

优点： 1、封装不变部分，扩展可变部分。 2、提取公共代码，便于维护。 3、行为由父类控制，子类实现。

缺点：每一个不同的实现都需要一个子类来实现，导致类的个数增加，使得系统更加庞大。

使用场景： 1、有多个子类共有的方法，且逻辑相同。 2、重要的、复杂的方法，可以考虑作为模板方法。

+

　　

责任链模式

意图：

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

适用性：

有多个的对象可以处理一个请求，哪个对象处理该请求运行时刻自动确定。

你想在不明确指定接收者的情况下，向多个对象中的一个提交一个请求。

可处理一个请求的对象集合应被动态指定。

+

观察者模式

意图：

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

适用性：

当一个抽象模型有两个方面, 其中一个方面依赖于另一方面。将这二者封装在独立的对象中以使它们可以各自独立地改变和复用。

当对一个对象的改变需要同时改变其它对象, 而不知道具体有多少对象有待改变。

当一个对象必须通知其它对象，而它又不能假定其它对象是谁。换言之, 你不希望这些对象是紧密耦合的。

+

　　

策略模式

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

主要解决：在有多种算法相似的情况下，使用 if...else 所带来的复杂和难以维护。

何时使用：一个系统有许多许多类，而区分它们的只是他们直接的行为。

如何解决：将这些算法封装成一个一个的类，任意地替换。

关键代码：实现同一个接口。

应用实例： 1、诸葛亮的锦囊妙计，每一个锦囊就是一个策略。 2、旅行的出游方式，选择骑自行车、坐汽车，每一种旅行方式都是一个策略。 3、JAVA AWT 中的 LayoutManager。

优点： 1、算法可以*切换。 2、避免使用多重条件判断。 3、扩展性良好。

缺点： 1、策略类会增多。 2、所有策略类都需要对外暴露。

使用场景： 1、如果在一个系统里面有许多类，它们之间的区别仅在于它们的行为，那么使用策略模式可以动态地让一个对象在许多行为中选择一种行为。 2、一个系统需要动态地在几种算法中选择一种。 3、如果一个对象有很多的行为，如果不用恰当的模式，这些行为就只好使用多重的条件选择语句来实现。

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50

#_*_coding:utf-8_*_ __author__ = 'Alex Li'       class TravelStrategy(object):     '''     出行策略     '''       def travelAlgorithm(self):         pass   class AirplaneStrategy(TravelStrategy):     def travelAlgorithm(self):         print("坐飞机出行....")   class TrainStrategy(TravelStrategy):     def travelAlgorithm(self):         print("坐高铁出行....")     class CarStrategy(TravelStrategy):     def travelAlgorithm(self):         print("自驾出行....")   class BicycleStrategy(TravelStrategy):     def travelAlgorithm(self):         print("骑车出行....")     class TravelInterface(object):     def __init__(self,travel_strategy):         self.travel_strategy = travel_strategy       def set_strategy(self,travel_strategy):         self.travel_strategy = travel_strategy     def travel(self):         return self.travel_strategy.travelAlgorithm()       #坐飞机 travel = TravelInterface(AirplaneStrategy())   travel.travel()   #改开车 travel.set_strategy(TrainStrategy()) travel.travel()