设计模式 | 乱花渐欲迷人眼

一. 前言

设计模式是解决问题的方案，学习现有的设计模式可以做到经验复用。拥有设计模式词汇，在沟通时就能用更少的词汇来讨论，并且不需要了解底层细节。

二. 设计原则

开闭原则

一个软件实体如类,模块,和函数应该对拓展开放,对修改关闭
依赖倒置原则

高层模块不应该依赖低层模块,二者都应该依赖其抽象.

抽象不应该依赖细节,细节应该依赖抽象.

针对接口编程,不要针对实现编程.

尽量抽象出接口,拓展其实现子类而非拓展原有类的方法,传参用接口,这样完成什么功能由客户端自己传入的子类类型决定,服务方不用修改.
单一职责原则

不要存在多于一个导致类变更的原因.

一个类/接口/方法只负责一项职责,不要承担过多的任务.比如更新用户信息可以拆分成更新用户名,用户密码,地址等等.

该原则目的在于降低当需求变更时修改代码导致的BUG风险.修改代码时容易因为新情况的加入而忽略旧情况或者新旧边界值等.
接口隔离原则

用多个专门的接口,而不使用单一的总接口,客户端不应该依赖它不需要的接口

一个类对一个类的依赖应该建立在最小的接口上

建立单一接口,不要建立庞大臃肿的接口

尽量细化接口,接口中的方法尽量少.细粒度可以组装,但是粗粒度不能拆分.

例如,animal接口中有eat,fly,swim三个方法,dog类实现该接口,就不得不实现一个空的fly方法,所以应该将接口拆分,让dog类去实现其所需要的接口方法.
迪米特法则(最少知道原则)

一个对象应该对其他对象保持最少的了解,尽量降低类与类之间的耦合

A找B买东西,B需要C进货,但是A不需要了解C,他只需要和B交互即可
里氏替换原则

子类对象替换父类对象时,程序的功能不受影响.也就是子类可以拓展父类,但不得改变或者削弱父类原有的功能
- 子类可以实现父类的抽象方法，但不能覆盖父类的非抽象方法。
- 子类中可以增加自己特有的方法。
- 当子类的方法重载父类的方法时，方法的前置条件（即方法的形参）要比父类方法的输入参数更宽松。
- 当子类的方法实现父类的抽象方法时，方法的后置条件（即方法的返回值）要比父类更严格。
举这么一个例子,父类中的A方法被B方法引用,子类重写了A方法,并且只调用了A方法,完全无视B方法,如果此时有另外一个类会扫描该父类的所有子类并调用其B方法,那么B方法的行为可能就会改变而导致BUG
合成/复用原则(组合/复用原则)

新对象需要使用已有对象,使之成为新对象的一部分,此时组合关系应优先于继承关系,因为继承受到里氏替换原则和其他的约束

三. 分类

创建型
- 单例
- 简单工厂
- 工厂方法
- 抽象工厂
- 生成器
- 原型
行为型
- 责任链
- 命令
- 解释器
- 迭代器
- 中介者
- 备忘录
- 观察者
- 状态
- 策略
- 模版方法
- 访问者
- 空对象
结构型
- 适配器
- 桥接
- 组合
- 装饰
- 外观
- 享元
- 代理

单例（Singleton）

Intent

确保一个类只有一个实例，并提供该实例的全局访问点。

Class Diagram

使用一个私有构造函数、一个私有静态变量以及一个公有静态函数来实现。

私有构造函数保证了不能通过构造函数来创建对象实例，只能通过公有静态函数返回唯一的私有静态变量。

Implementation

Ⅰ 懒汉式-线程不安全

以下实现中，私有静态变量 uniqueInstance 被延迟实例化，这样做的好处是，如果没有用到该类，那么就不会实例化 uniqueInstance，从而节约资源。

这个实现在多线程环境下是不安全的，如果多个线程能够同时进入 if (uniqueInstance == null) ，并且此时 uniqueInstance 为 null，那么会有多个线程执行 uniqueInstance = new Singleton(); 语句，这将导致实例化多次 uniqueInstance。

public class Singleton {

    private static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            uniqueInstance = new Singleton();
        }
        return uniqueInstance;
    }
}

Ⅱ 饿汉式-线程安全

线程不安全问题主要是由于 uniqueInstance 被实例化多次，采取直接实例化 uniqueInstance 的方式就不会产生线程不安全问题。

但是直接实例化的方式也丢失了延迟实例化带来的节约资源的好处。

private static Singleton uniqueInstance = new Singleton();

Ⅲ 懒汉式-线程安全

只需要对 getUniqueInstance() 方法加锁，那么在一个时间点只能有一个线程能够进入该方法，从而避免了实例化多次 uniqueInstance。

但是当一个线程进入该方法之后，其它试图进入该方法的线程都必须等待，即使 uniqueInstance 已经被实例化了。这会让线程阻塞时间过长，因此该方法有性能问题，不推荐使用。

public static synchronized Singleton getUniqueInstance() {
    if (uniqueInstance == null) {
        uniqueInstance = new Singleton();
    }
    return uniqueInstance;
}

Ⅳ 双重校验锁-线程安全(double check)

uniqueInstance 只需要被实例化一次，之后就可以直接使用了。加锁操作只需要对实例化那部分的代码进行，只有当 uniqueInstance 没有被实例化时，才需要进行加锁。

双重校验锁先判断 uniqueInstance 是否已经被实例化，如果没有被实例化，那么才对实例化语句进行加锁。

public class Singleton {

    private volatile static Singleton uniqueInstance;

    private Singleton() {
    }

    public static Singleton getUniqueInstance() {
        if (uniqueInstance == null) {
            synchronized (Singleton.class) {
                if (uniqueInstance == null) {
                    uniqueInstance = new Singleton();
                }
            }
        }
        return uniqueInstance;
    }
}

double check的改进在于,第一个if判断的作用为分流,只有首次调用时对象未实例化才会进入if里面,当对象已经实例化后访问不会遭到阻塞,第二个if判断才进行加锁保证安全.

不过,由于指令重排序的原因,单纯的double check无法百分百保证线程安全.例如， uniqueInstance = new Singleton(); 这段代码其实是分为三步执行：

为 uniqueInstance 分配内存空间
初始化 uniqueInstance
将 uniqueInstance 指向分配的内存地址

由于 JVM 具有指令重排的特性，执行顺序有可能变成 1>3>2。指令重排在单线程环境下不会出现问题，但是在多线程环境下会导致一个线程获得还没有初始化的实例导致空指针异常。例如，线程 T₁ 执行了 1 和 3(此时uniqueInstance != null)，此时 T₂ 调用 getUniqueInstance() 后发现 uniqueInstance 不为空，因此返回 uniqueInstance，但此时 uniqueInstance 还未被初始化。

使用 volatile 可以禁止 JVM 的指令重排，保证在多线程环境下也能正常运行。

Ⅴ 静态内部类实现

当 Singleton 类被加载时，静态内部类 SingletonHolder 没有被加载进内存。只有当调用 getUniqueInstance() 方法从而触发 SingletonHolder.INSTANCE 时 SingletonHolder 才会被加载，此时初始化 INSTANCE 实例，并且 JVM 能确保 INSTANCE 只被实例化一次。

这种方式不仅具有延迟初始化的好处，而且由 JVM 提供了对线程安全的支持。

public class Singleton {

    private Singleton() {
    }

    private static class SingletonHolder {
        private static final Singleton INSTANCE = new Singleton();
    }

    public static Singleton getUniqueInstance() {
        return SingletonHolder.INSTANCE;
    }
}

Ⅵ 枚举实现

public enum Singleton {

    INSTANCE;

    private String objName;


    public String getObjName() {
        return objName;
    }


    public void setObjName(String objName) {
        this.objName = objName;
    }


    public static void main(String[] args) {

        // 单例测试
        Singleton firstSingleton = Singleton.INSTANCE;
        firstSingleton.setObjName("firstName");
        System.out.println(firstSingleton.getObjName());
        Singleton secondSingleton = Singleton.INSTANCE;
        secondSingleton.setObjName("secondName");
        System.out.println(firstSingleton.getObjName());
        System.out.println(secondSingleton.getObjName());

        // 反射获取实例测试
        try {
            Singleton[] enumConstants = Singleton.class.getEnumConstants();
            for (Singleton enumConstant : enumConstants) {
                System.out.println(enumConstant.getObjName());
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
}

firstName
secondName
secondName
secondName

关于枚举的拓展:

枚举类的每一个枚举量在编译的时候都会编译成一个单独的final类,与静态内部类一样,该类的加载安全由JVM的类加载机制来保证.

该实现可以防止反射攻击。在其它实现中，通过 setAccessible() 方法可以将私有构造函数的访问级别设置为 public，然后调用构造函数从而实例化对象，如果要防止这种攻击，需要在构造函数中添加防止多次实例化的代码(如果尝试再次实例化对象则抛出异常)。该实现是由 JVM 保证只会实例化一次，因此不会出现上述的反射攻击。

该实现在多次序列化和序列化之后，不会得到多个实例。而其它实现需要使用 transient 修饰所有字段，并且实现序列化和反序列化的方法。

反序列化攻击:

如果单例类实现了Serializable接口,那么调用readObject()方法再到newInstance()方法会调用无参构造方法实例化新的对象,要防止该攻击,要么单例类不实现该接口,要么在Singleton类中定义readResolve()方法就可以解决该问题

 private Object readResolve() {
        return singleton;	//直接返回对象而非创建对象
    }

Examples

Logger Classes
Configuration Classes
Accesing resources in shared mode
Factories implemented as Singletons

JDK

java.lang.Runtime#getRuntime() –饿汉式
java.awt.Desktop#getDesktop()
[java.lang.System#getSecurityManager()](

Spring

AbstractFactoryBean.getObect()

AbstractBeanFactory的作用

api里是这样说的,是抽象BeanFactory的基类,同时实现了ConfigurableBeanFactory的SPI,提供了所有的功能

也可以从我们定义的资源中resource中来获取bean的定义.

也提供了单例bean的缓存通过他的爷爷如图中的DefaultSingletonBeanRegistry,同时提供了单例和多例和别名的定义等操作.

上述只是其中的一部分,总之来说它的作用还是挺大的.

生成器（Builder）

Intent

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

封装一个对象的构造过程，并允许按步骤构造.

生成器模式生产的是一个可定制化的产品,可通过调用Builder类的多个方法来设置产品的属性.与工厂方法相比,工厂方法的产品是模型已经固定好了的.

Class Diagram

JDK

Guava

CacheBuilder.newBuilder()

生成器模式

生成器模式可以改进成链式调用(在guava中大力提倡),Builder类中赋值的方法返回类型不是void而是它本身,这样就可以链式调用起来,最后再通过builder()方法返回定制化的Product

可以这样简单理解:

简单工厂只有一个工厂,这个工厂生产多种产品,新增产品时需要增加方法.(一对多)
工厂方法拓展了工厂类,有多个工厂类,每个工厂生产一种产品,新增产品时新增工厂类.(一对一)
抽象工厂结合两者,生产产品族(二维),有多个工厂类,每个工厂类又是一个简单工厂.(一对多)

简单工厂（Simple Factory）

Intent

在创建一个对象时不向客户暴露内部细节，并提供一个创建对象的通用接口。

Class Diagram

简单工厂把实例化的操作单独放到一个类中，这个类就成为简单工厂类，让简单工厂类来决定应该用哪个具体子类来实例化。

这样做能把客户类和具体子类的实现解耦，客户类不再需要知道有哪些子类以及应当实例化哪个子类。客户类往往有多个，如果不使用简单工厂，那么所有的客户类都要知道所有子类的细节。而且一旦子类发生改变，例如增加子类，那么所有的客户类都要进行修改。

Implementation

public interface Product {
}
public class ConcreteProduct implements Product {
}
public class ConcreteProduct1 implements Product {
}
public class ConcreteProduct2 implements Product {
}

以下的 Client 类包含了实例化的代码，这是一种错误的实现。如果在客户类中存在这种实例化代码，就需要考虑将代码放到简单工厂中。

public class Client {

    public static void main(String[] args) {
        int type = 1;
        Product product;
        if (type == 1) {
            product = new ConcreteProduct1();
        } else if (type == 2) {
            product = new ConcreteProduct2();
        } else {
            product = new ConcreteProduct();
        }
        // do something with the product
    }
}

以下的 SimpleFactory 是简单工厂实现，它被所有需要进行实例化的客户类调用。

public class SimpleFactory {

    public Product createProduct(int type) {
        if (type == 1) {
            return new ConcreteProduct1();
        } else if (type == 2) {
            return new ConcreteProduct2();
        }
        return new ConcreteProduct();
    }
}
public class Client {

    public static void main(String[] args) {
        SimpleFactory simpleFactory = new SimpleFactory();
        Product product = simpleFactory.createProduct(1);
        // do something with the product
    }
}

工厂方法（Factory Method）

Intent

定义了一个创建对象的接口，但由子类决定要实例化哪个类。工厂方法把实例化操作推迟到子类。

Class Diagram

在简单工厂中，创建对象的是另一个类，而在工厂方法中，是由子类来创建对象。

下图中，Factory 有一个 doSomething() 方法，这个方法需要用到一个产品对象，这个产品对象由 factoryMethod() 方法创建。该方法是抽象的，需要由子类去实现。

Implementation

public abstract class Factory {
    abstract public Product factoryMethod();
    public void doSomething() {
        Product product = factoryMethod();
        // do something with the product
    }
}
public class ConcreteFactory extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct();
    }
}
public class ConcreteFactory1 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct1();
    }
}
public class ConcreteFactory2 extends Factory {
    public Product factoryMethod() {
        return new ConcreteProduct2();
    }
}

JDK

Collection.iterator() 产品为内部类Itr

抽象工厂（Abstract Factory）

Intent

提供一个接口，用于创建 相关的对象家族 。

Class Diagram

抽象工厂模式创建的是对象家族，也就是很多对象而不是一个对象，并且这些对象是相关的，也就是说必须一起创建出来。而工厂方法模式只是用于创建一个对象，这和抽象工厂模式有很大不同。

抽象工厂模式用到了工厂方法模式来创建单一对象，AbstractFactory 中的 createProductA() 和 createProductB() 方法都是让子类来实现，这两个方法单独来看就是在创建一个对象，这符合工厂方法模式的定义。

至于创建对象的家族这一概念是在 Client 体现，Client 要通过 AbstractFactory 同时调用两个方法来创建出两个对象，在这里这两个对象就有很大的相关性，Client 需要同时创建出这两个对象。

从高层次来看，抽象工厂使用了组合，即 Cilent 组合了 AbstractFactory，而工厂方法模式使用了继承。

Implementation

public class AbstractProductA {
}
public class AbstractProductB {
}
public class ProductA1 extends AbstractProductA {
}
public class ProductA2 extends AbstractProductA {
}
public class ProductB1 extends AbstractProductB {
}
public class ProductB2 extends AbstractProductB {
}
public abstract class AbstractFactory {
    abstract AbstractProductA createProductA();
    abstract AbstractProductB createProductB();
}
public class ConcreteFactory1 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA1();
    }

    AbstractProductB createProductB() {
        return new ProductB1();
    }
}
public class ConcreteFactory2 extends AbstractFactory {
    AbstractProductA createProductA() {
        return new ProductA2();
    }

    AbstractProductB createProductB() {
        return new ProductB2();
    }
}
public class Client {
    public static void main(String[] args) {
        AbstractFactory abstractFactory = new ConcreteFactory1();
        AbstractProductA productA = abstractFactory.createProductA();
        AbstractProductB productB = abstractFactory.createProductB();
        // do something with productA and productB
    }
}

JDK

数据库连接Connection.prepareStatement() 产品为Statement类

外观（Facade）(门面模式)

Intent

提供了一个统一的接口，用来访问子系统中的一群接口，从而让子系统更容易使用。

某个功能,需要调用多个接口,逻辑固定,因此可以封装成一个接口,通过该接口完成该功能.

Class Diagram

Implementation

观看电影需要操作很多电器，使用外观模式实现一键看电影功能。

public class SubSystem {
    public void turnOnTV() {
        System.out.println("turnOnTV()");
    }

    public void setCD(String cd) {
        System.out.println("setCD( " + cd + " )");
    }

    public void startWatching(){
        System.out.println("startWatching()");
    }
}
public class Facade {
    private SubSystem subSystem = new SubSystem();

    public void watchMovie() {
        subSystem.turnOnTV();
        subSystem.setCD("a movie");
        subSystem.startWatching();
    }
}
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.watchMovie();
    }
}

设计原则

最少知识原则：只和你的密友谈话。也就是说客户对象所需要交互的对象应当尽可能少。

原型模式（Prototype）

Intent

使用原型实例指定要创建对象的类型，通过赋值这个原型来创建新对象。

不需要知道任何创建的细节,不调用构造函数.核心是clone()方法,需要实现Cloneable接口,因此需要注意浅克隆(复制基本值)和深克隆(复制复杂对象)的区别.

核心作用是节省资源,复制的开销小于创建一个新的对象.

如果复制的对象包含复杂的成员对象,则需要重写clone方法,将这些对象也一起克隆.

Class Diagram

Implementation

public abstract class Prototype {
    abstract Prototype myClone();
}
public class ConcretePrototype extends Prototype {

    private String filed;

    public ConcretePrototype(String filed) {
        this.filed = filed;
    }

    @Override
    Prototype myClone() {
        return new ConcretePrototype(filed);
    }

    @Override
    public String toString() {
        return filed;
    }
}
public class Client {
    public static void main(String[] args) {
        Prototype prototype = new ConcretePrototype("abc");
        Prototype clone = prototype.myClone();
        System.out.println(clone.toString());
    }
}
abc

克隆破坏单例

如果克隆的是一个单例对象,那么clone()方法会返回一个新的对象,从而破坏了单例.因此需要重写clone方法,让它也通过单一入口来获取单例对象.

@Override
protected Object clone() throws CloneNotSupportedException {
    return getInstance();
}

JDK

java.lang.Object#clone()