设计模式：创建型 (Creational)

抽象工厂 (Abstract Factory)

案例

前面在依赖倒置原则中，其实已经举过一个贴纸的例子，其实就是抽象工厂模式的一个应用。

除了对 Product 和 Factory 进行抽象以外，抽象工厂方法还强调了产品系列的概念。比如《设计模式》一书中经典的例子，支持多种视感（look-and-feel）标准的用户界面，不同的视感风格为诸如滚动条、窗口和按钮等用户界面『窗口组件』定义不同的外观和行为。而某个特定视感风格下的一系列『窗口组件』，就是一个产品系列。我们不应该在 Motif 风格的窗口组件中，混入一个 PM 风格的窗口组件。

这里我们需要解决两个问题：

如何确保软件不依赖某种具体的视感风格，以保证软件的可移植性。就像前面的案例中， Editor 不应该直接依赖某个具体的 StaticSticker 一样；
如何确保我们不会在 Motif 视感中，错误的使用了一个 PM 风格的组件？

我们可以通过抽象工厂模式，优雅地解决上述两个问题。看一下类图就明白了：

每一种视感标准都对应一个具体的 WidgetFactory 子类，客户只需要通过 WidgetFactory 即可创建出一组特定风格的窗口组件，无需关心哪些类实现了特定风格的窗口组件，而且可以保证绝对不会错误的混用不同风格的窗口，因为 WidgetFactory 强化了同一类型风格组件之间的绑定关系。

适用性

一个系统希望独立于它的产品的创建、组合和实现。
一个系统存在多个产品系列，在工作时需要选择其中一个产品系列来使用。
比较强调产品系列的概念，同一个系列的产品应该配合在引起使用，不同系列的产品不能混用。
提供一个产品类库，但只想暴露它们的接口而不是实现。

优点

它分离了具体实现类
替换产品系列变得十分简单，只需替换一个 factory 即可
有利于产品的一致性，可以自动确保不同系列的产品之间不会混用

缺点

该模式可以很轻易的扩展新的产品系列，但如果要扩展产品系列中的产品类型，例如上述案例中，增加一种新的窗口组件，会比较困难，因为会涉及 AbstractFactory 类及其所有子类的修改。

因此，使用该模式最好一开始就考虑清楚系统中有哪些产品类型，是否相对稳定，否则不太建议使用。

工厂方法 (Factory Method)

意图

定义一个用于创建对象的接口，让子类决定具体将创建哪一种类型的实例，即对象的实例化过程被延迟到子类进行。

工厂方法相对比较简单，其实在Abstract Factory 抽象工厂中就有工厂方法的运用。

类图

生成器 (Builder)

意图

将一个复杂对象的构建与它的内部表示相分离，使得二者可以独立发生变化。

这里有两层含义：

构建过程（Director）和内部表示（Builder）相分离。同样的构建过程，可以生成不同的结果。例如，“解析并遍历 RTF 文档结构”这个过程是可复用的，但是我利用不同的 Builder, 最终可以构建出不同格式的文档（ Markdown, Html, Text 等）。
构建过程不用关心产品的内部组成部分是如何创建的（具体由哪些类实例化），以及这些部分是如何组装的。因此，构建过程可以被独立修改。

通过克隆原型实例的方式来创建新的对象。

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

实现

饿汉式

Java 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
class Singleton {
    public static Singleton getInstance() {
        return instance;
    }

    // ...

    private Singleton() {}
    private static Singleton instance = new Singleton();
}

Kotlin 实现
1 2 3
object Singleton { // ... }

双重检查锁 (Double-checked locking)

Java 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
class Singleton {
    public static Singleton getInstance() {
        if (instance == null) {
            synchronized (Singleton.class) {
                if (instance == null) {
                    instance = new Singleton();
                }
            }
        }
        return instance;
    }

    private Singleton() {}
    private volatile static Singleton instance;
}

Kotlin 实现

1
2
3
4
5
6
7
class Singleton private constructor() {
    companion object {
        val instance: Singleton by lazy(mode = LazyThreadSafetyMode.SYNCHRONIZED) {
            Singleton()
        }
    }
}

静态内部类

这种方式利用 Java 虚拟机的类加载机制来实现懒加载的效果，并处理同步锁的问题。

Java 实现

 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
class Singleton {
    public static Singleton getInstance() {
        return Holder.instance;
    }
    public static void hello() {
        System.out.println("hello");
    }

    static {
        System.out.println("Singleton has been loaded!");
    }

    private Singleton() {}
    private static class Holder {
        static {
            System.out.println("Holder has been loaded!");
        }
        static final Singleton instance = new Singleton();
    }

    public static void main(String[] args) {
        Singleton.hello();
        // 下面这句会触发 Holder 的加载，进而触发 instance 的初始化
        Singleton.getInstance();
    }
}

Kotlin 实现

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
class Singleton private constructor() {
    companion object {
        init {
            println("Singleton has been loaded!")
        }
        val instance get() = Holder.instance
        fun hello() {
            println("hello")
        }
    }

    private object Holder {
        init {
            println("Holder has been loaded!")
        }
        val instance = Singleton()
    }
}

Singleton.hello()
// 下面这句会触发 Holder 的加载，进而触发 instance 的初始化
Singleton.instance

劣势

从可测试性的角度，应该尽量减少 Singleton 的使用。因为 Singleton 难以被 mock。可以考虑用抽象工厂 (Abstract Factory)来代替 Singleton, 并在工厂内部返回其唯一实例。
由于单例对象无法被垃圾回收，会导致部分内存或其他资源长期被占据。如果单例是一个占用较多资源的复杂对象，这可能会造成资源紧张的问题。

设计模式：创建型 (Creational)

抽象工厂 (Abstract Factory)

意图

案例

适用性

优点

缺点

相关模式

工厂方法 (Factory Method)

意图

类图

生成器 (Builder)

意图

结构

类图

时序图

效果

它使你可以改变一个产品的内部表示

它使你可以在不同的 `Director` 中复用同一个 `Builder`

它使你对构造过程可以进行更精细的控制

相关模式

抽象工厂 (Abstract Factory)

访问者 (Visitor)

原型 (Prototype)

意图

类图

效果

运行时增加和删除产品

减少子类数量

单例 (Singleton)

意图

实现

饿汉式

双重检查锁 (Double-checked locking)

静态内部类

劣势

设计模式：创建型 (Creational)

See Also: