Design Pattern

设计模式介绍

什么是模式\软件设计模式

舒适窗户位置的模式

  1. 能舒适坐下来
  2. 能朝向光线

人们在自己的环境中不断发现问题和寻找问题的解决方案的时候,发现一些问题及其解决方案不断变换面孔重复出现,但在这些不同的面孔背后有着共同的本质,这些共同的本质就是模式。

特定问题 -> 解决方案 -> 抽象提炼公共要素 -> 模式 -> 相似问题的解决方案 = 举一反三

模式是建筑行业的延伸

模式是指从某个具体的形式中得到的一种抽象,在特殊的非任意性的环境中,该形式不断地重复出现。

模式 != 某个问题的答案

软件设计模式

  • 面向对象软件的开发设计得经验总结
  • 一个重要的可重现的面向对象设计方案的命名、解释和评价
  1. 关注在特定设计环境中重复出现的设计问题,并为它提供一个解决方案
    如MVC模式关注问题是支持用户界面的可变性
    解决方案-严格区分职责,将应用程序的核心功能从其用户界面中分离出来

  2. 用文档记录下来的设计经验,来重用设计知识

    这种设计经验是现已存在,经过充分考验的,不是人工发明或者创造

  3. 是类和实力层次之上的抽象
    一个模式描述几个组件、类和对象,并详细说明他们的职责和关系以及它们之间的合作
    所有组件共同解决模式关注的问题,而且通常比单个组件更有效
    例如,MVC模式描述了三个合作组件的三元组,每个MVC三元组叶童其他的MVC三元组合作

  4. 提供一种设计原则的公共词汇和理解
    模式名称是对问题及方案需求的简洁描述

设计模式的历史

设计模式的分类

设计原则

设计模式目录

创建性模式(create pattern)

封装动态产生对象的过程和所使用的类的信息,解决系统在创建对象时,抽象化类的实例化过程:

基本原理:

  • 怎样创建对象
  • 创建哪些对象
  • 如何组合和表示这些对象

使系统不依赖于对象的创建过程,只了解抽象类定义的对象接口

- 封装要创建的具体类的信息
- 隐藏这些类(类的实例)被创建和组合的过程

两种创建模式:
类的创建模式 - 使用继承关系,把类的创建延迟到子类
对象的创建模式 - 把对象的创建过程动态地委派给另一个对象

- 封装要创建的具体类的信息
- 隐藏这些类被创建和组合的过程

结构性模式(structural patterns)

考虑如何将组合类和对象构成较大的结构

  1. 结构性类模式: 使用继承来组合接口和实现
  2. 结构性对象模式:对象合成实现新功能

对象合成:可以在运行时改变组合
类组合:只能实现静态组合

行为性模式

主要解决算法和对象之间的责任分配

行为模式描述了:
对象或类的模式
它们之间的通信模式

创建性模式

简单工厂模式:类创建模式

  • 工厂方法模式的一个特殊实现
  • 是学习工程方法模式的准备
  • 由一个工厂对象决定创建哪一种产品类的实例

参与者职责

  • 工厂

  • 抽象产品

  • 具体产品

优点:
设计简单
产品类等级结构变化不会影响代工厂类
职责分明,创建和使用部分分开

缺点:

  • 工厂类会变得非常负责,形成一个上帝类
  • 简单工厂模式使用静态方法,而静态方法无法由子类继承,因此,工厂角色无法形成基于继承的等级结构

以上缺点在工厂方法模式中得到克服

具体使用:

DataFormat

XMLReaderFactory

工厂方法模式

工厂方法模式(Factory Method)

类的创建模式

别名:虚拟构建者(Virtual Constructor)
多态性工厂(Polymorphic Factory)

目的:

定义创建产品对象的工厂接口,让子类决定实例化哪一个类,将实际创建推迟到子类中

“推迟到子类中” - 使用一个类通过子类实例化

要生产A类产品的实例

  • 在工厂接口下建立一个专门的工厂(具体工厂)
  • 客户端调用具体工厂的实例去生产A类产品的具体产品
  • 具体工厂的父类(即工厂接口)完全不知道
    • 实例化那个具体工厂
    • 生产什么产品

和简单工厂模式区别:多态性

  • 工厂类不再负责所有的产品的创建,而是将具体创建的工作交给子类
  • 核心类-抽象工厂
  • 仅负责给出具体工厂子类必须实现的接口,而不接触一个产品类被实例化的细节

可以允许系统在不修改具体工厂角色的情况下引进新的产品

抽象工厂模式

  • 所有形态的工厂模式中最为抽象和最具一般性的形态
  • 向客户端提供一个接口,使得客户端在不必指定产品的具体类型的情况下,创建多个产品族中的产品对象

  • 抽象工厂模式与工厂模式的区别

    • 工厂方法模式针对的是一个产品等级结构
    • 而抽象工厂模式需要面对多个产品等级结构
  • 目的
    在不指明类型的情况下,提供一个创建相联系或相依赖的对象接口

解决方案

  1. 思路
    用户接口工具箱
    按不同的观感(Look-and-feel)定义用户接口工具,如滚动条、窗口、按钮的不同表现和行为
    要求在不同观感标准之间提高可移植性

  2. 结构

  3. 参与职责

    • 抽象工厂类(AbstractFactory)-(WidgetFactory)
    • 具体工厂类 (ConcreteFactory) - (MotifWidgetFactory, PMWidgetFactory)
    • 抽象产品类 (AbstractProduct) - (Window, ScrollBar)
    • 具体产品类 (ConcreteProduct)
      • 定义将被相应的具体工厂类产生的产品对象
      • 实现抽象产品类接口
    • 客户(client)
      • 仅使用由抽象工厂类和抽象产品类声明的接口
  4. 协作

    • ConcreteFactory类的一个实例一般在运行时产生。它产生有特定实现的产品对象。
      要产生不同的产品对象,Client要使用不同的ConcreteFactory
    • AbstractFactory将产品对象交给ConcreteFactory创建
  5. 使用条件

    • 系统与如何创建、组合和表示其产品无关
    • 系统应由多个产品族之一配置
    • 相关对象族需要同时设计和使用
    • 应提供产品类库,只提供接口,而不是实现
  • 后果:
    • 隔离了具体的类
    • 使产品族间的转换容易
    • 提供了产品间的一致性
    • 很难支持新产品种类

Builder模式

产品的内部表象

一个产品常有不同的组成成分(零件)

如汽车,有很多部件:车轮 方向盘 发动机还有各种小零件等等

这些零件有可能是对象,也有可能不是对象

它们通常叫做内部表象

不同的产品可以有不同的内部表象

解决方案:

思路

将复杂对象的部件内部表象和复杂对象分开来

同样的构建过程可以创建不同的表示

用户不知道具体构建细节, 只通过指定对象的类型和内容构建它们

建造模式使客户端不需要知道:
所生成的产品对象有哪些部件
每个产品的对应零件彼此有何不同
是怎么建造出来的
怎样组成产品

  • 结构

  • 参与者

    • 具体建立者
    • 指导者
    • 产品
    • 客户端

一般来说一个产品类一个builder

协作:

Client产生Director对象,用想要的Builder对象配置它
Director在凡要建造产品的某一部分的时候都通知Builder
Builder处理从Director来的请求,将要建造的这一部分加入到产品中去
Client从Bulider回溯产品

使用条件:

产品对象有复杂的内部结构

产品对象的属性相互依赖。一个属性必须在另一属性被赋值之后才可以被赋值

在对象创建过程中用到创建过程中不易得到的系统中其他对象

在产品的属性没有确定之前,产品对象不能使用。属性赋值和使用时分步骤进行的

生成一个复杂对象的算法独立于建造对象和集成它们的部分

构造过程允许构造对象有不同的表示

例子:

StringBuilder

原型模式

工作原理:

将一个原型对象传给发动创建的对象
原型对象实例指明了创建对象的类
发动创建的对象请求原型对象拷贝它们自己来实施创建
一个对象创建另一个可定制对象,无需知道如何创建的细节

很多语言都自身支持这个模式,比如Java

Java中的Object类含有clone的方法

对任何的对象X, 都有X.clone() != X, X.getClass() == X.clone().getClass()

克隆的对象不能是原来的对象,但是类型必须相同

五个模式的不同

1
2
3
4
5
简单工厂:一个工厂生产多种产品
工厂方法:工厂的分厂生产不同产品
抽象工厂:工厂的每个分厂生产不同品牌的产品族
建造者:工厂的分厂制造零件,总厂负责装配
原型:复印商店

单例模式

什么是单例? 孤子模式、单态模式

让类自己负责保存它唯一的实例,这个类可以保证不能再产生别的实例,而且提供获得这个实例的方法

  • 某个类只能有一个实例

  • 它必须自行创建这个实例

  • 它必须自行向整个系统提供这个实例

这个类称为单例类

1
2
3
4
5
6
7
8
用途
资源管理:
打印机只能有一个 Printer Spooler ——避免两个打印作业间时输出到打印机中。
只应有一个软件负责管理传真卡——避免出现两份传真作业同时传到传真卡中的情况。
通信端口管理——避免一个通信端口同时被2个请求同时调用。
记录网站来访人数的部件
记录软件系统内部事件、出错信息的部件
对系统的表现进行检查的部件等。

几种创建单例模式的方法:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// 如果对创建对象的时间无所谓,可以使用这个
public class Singleton {
private Singleton() {
System.out.println("Singleton is create"); //创建单例的过程可能会比较慢
}

private static Singleton instance = new Singleton();
public static Singleton getInstance() {
return instance;
}

public static void createString(){ //这是模拟单例类扮演其他角色
System.out.println("createString in Singleton");
}
}
1
2
3
4
5
6
7
8
9
10
11
// synchronized 有性能损耗
public class LazySingleton {
private LazySingleton(){
System.out.println("LazySingleton is create"); }
private static LazySingleton instance = null;
public static synchronized LazySingleton getInstance() {
if (instance==null)
instance=new LazySingleton();
return instance;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
// 最推荐
public class StaticSingleton {
private StaticSingleton(){
System.out.println("StaticSingleton is create");
}
private static class SingletonHolder {
private static StaticSingleton instance = new StaticSingleton();
}
public static StaticSingleton getInstance() {
return SingletonHolder.instance;
}
}
1
2
3
4
5
6
7
8
9
10
11
12
13
// 这种方法不推荐,因为枚举一般是常量
public enum Singleton implements MySingleton {
INSTANCE {
@Override
public void doSomething() {
System.out.println("complete singleton");
}
};

public static MySingleton getInstance() {
return Singleton.INSTANCE;
}
}

后果:
有控制地得到唯一的实例。
限制了实例个数,减小了内存空间。

但是不推荐使用这种模式,应该通过容器的限制去使用,比如Spring

多例模式

  • 有上限多例
    • 单例的推广
    • 比如麻将牌的两个骰子
  • 无上限多例
  • 特点
    • 多例类可以有多个实例
    • 多例类必须自己创建自己的实例,并管理自己的实例,和向外界提供自己的实例
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// 有上限多例
public class Die
{
private static Die die1 = new Die();
private static Die die2 = new Die();

private Die() {

}

public static Die getInstance(int whichOne) {
if (whichOne == 1) {
return die1;
} else {
return die2;
}
}
}
1
2
无上限的多例
比如:国际化支持(不确定到底有多少语言和区域)

结构性模式

适配器模式

桥接模式

组合模式

装饰模式

门面模式 (Facade)

门面模式在四人帮书中讲述它的意图就是“Provide a unified interface to a set of interfaces in a subsystem. Facade defines a higher-level interface that makes the subsystem easier to use.” 另外一本参考书则直接使用“简化”两字描述这一模式。Coursera的软件架构这课上描述也不错:A facade is a wrapper class that encapsulate the subsystem in order to hide the subsystem’s complexity. 用我自己的语言来说,门面模式就是直接满足客户端的需求,即使用一个新的类去集成子系统的功能,从而使客户端不需要知道子系统的功能达到目的.

例子:

四人帮设计模式:编译器的一个compile()方法里包含了scanner和parser.Parse()

享元模式

代理模式

定义:

四人帮书:One reason for controlling access to an object is to defer the full cost of its creation and initialization until we actually need to use it.

Coursera的软件架构: The proxy acts as a simplified or lightweight version of the original object. A proxy object is still able to accomplish the same tasks, but may delegate requests to the original object to achieve them.

个人觉得,代理并不是真的像现实生活一样去帮你代理做事,而是让请求先经过代理,通过代理再在适当得时候调用真正的对象的方法。

应用场景:

使用动态代理,可以为所有的类增加Cache功能


Reference

炼数成金-设计模式

Thanks, mate.
0%