本文主要归纳设计模式中的创建模式 (creational pattern)，主要包括了工厂模式，单例多例，建造者模式，和原型模式等。

创建模式是指对象的实例化过程，这些模式都提供了一种将对象实例化从客户端分离的方法。

为什么要有创建模式，这也符合开闭原则，Java 自带的 new Object() 实例化对象没有任何问题，问题在于修改，一旦当具体实例涉及变化，那么就必须修改实例自身，不符合开闭原则，所以才有这么多的创建模式。将对外暴露的接口抽象起来，将对象创建的方式封装，对外接口尽量减少。

简单工厂

主要分为三个部分，工厂，抽象产品，具体产品。

工厂直接提供具体产品，也就是直接创建具体类。

工厂模式将产品的生产和其提供的功能隔离。

多态工厂方法

又称为工厂方法。

The Factory Method Pattern defines an interface for creating an object, but lets subclasses decide which class to instantiate. Factory Method lets a class defer instantiation to subclasses.

分为四个部分，抽象工厂，具体工厂，抽象产品，具体产品。将产品实例化放到具体工厂子类中实现，抽象出工厂的一般方法。通常一个具体工厂产出一种具体产品。

因此在添加具体产品后不需要修改具体工厂类，而只需要相应的添加具体工厂来产出产品。

抽象工厂

和多态工厂相同，包含四个部分。

The Abstract Factory Pattern provides an interface for creating families of related or dependent objects without specifying their concrete classes.

抽象工厂和工厂方法的区别在于，抽象工厂模式中，一个工厂可以提供多个抽象产品。在工厂方法模式中，由“具体工厂”决定提供哪一类具体产品；在抽象工厂中，由客户端决定返回哪一类产品。

单例

至始至终只有一个实例。

Eager initialization

The instance of Singleton is created at the time of class loading.

public class EagerSingletion {
	private static final EagerSingletion instance = new EagerSingletion();
	private EagerSingletion() {}
	public static EagerSingletion getInstance() {
		return instance;
	}
}

在 Singleton 不占用太多资源时可以使用 static 在类加载时使用这个方法。但是对于大对象这个方法就不是很好。

Static block initialization

Use static block to create instance

public class StaticBlockSingleton {
	private static StaticBlockSingleton instance = null;
	private StaticBlockSingleton() {}
	static {
		try {
			instance = new StaticBlockSingleton();
		} catch(Exception e) {
			throw new RunTimeException("Exception creating singleton");
		}
	}

	public static StaticBlockSingleton getInstance() {
		return instance;
	}
}

使用 static 字段和 static block 定义的实例都是在实例对象被使用之前就已经创建。

Lazy Initialization

在第一次使用时创建。

public class LazyInitialSingleton {
	public static LazyInitialSingleton instance = null;
	private LazyInitialSingleton() {}
	public static LazyInitialSingleton getInstance() {
		if (instance == null) {
			instance = new LazyInitialSingleton();
		}
		return instance;
	}
}

但是这个方法在单线程中是没有问题的，如果是多线程同时调用 getInstance 方法，就可能创建多个实例。

Thread Safe Singleton

public class ThreadSafeSingleton {
	public static ThreadSafeSingleton instance = null;
	private ThreadSafeSingleton() {}
	public static synchronized ThreadSafeSingleton getInstance() {
		if (instance == null) {
			instance = new ThreadSafeSingleton();
		}
		return instance;
	}
}

synchronized 作用于静态方法等同于对类加锁。

Double checked Singleton

public static ThreadSafeSingleton getInstance () {
	if (instance == null) {
		synchronized (ThreadSafeSingleton.class) {
			if (instance == null) {
				instance = new ThreadSafeSingleton();
			}
		}
	}
	return instance;
}

Bill Pugh Singleton

使用内部静态类

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

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

这里涉及到类加载机制，在类加载 Singleton 时，内部静态类是不会被加载的。只有当有调用 getInstance() 方法，实例才会初始化。

多例

一个类存在多个自身的实例，并且多例类需要自己创建，管理自己的实例，并向外提供自己的实例。

常见的线程池，数据库连接池就是多例的使用案例。

建造者模式

当需要创建的对象，创建步骤比较复杂时，可以将对象的”创建”和”表示”分离。Builder 模式允许用户将复杂对象的创建封装，允许使用者多个步骤来构造对象。

建造者模式包括：导演，抽象建造者，具体建造者，和产品

建造者模式的使用场景：

  • 对象内部结构复杂，比如包含不同零件的汽车类，比如一个复杂的邮件类
  • 对象内部属性有依赖，需要按照某一些顺序进行赋值
  • 对象创建过程依赖系统其他对象，而这些依赖的对象不易获取

优点：

  • 封装了内部构造细节
  • 隐藏了内部表示
  • 构造对象内部实现可以灵活改动，客户端只通过抽象接口来构造该对象

缺点：

  • 相较于工厂模式，客户端需要额外的知识来创建对象

原型模式

通过原型指明要创建的对象类型，然后通过该原型创造更多的对象实例。Java 中可以通过 clone() ，或者反序列化来实现。原型模式允许客户端在不知道对象具体内部细节的情况下创建实例。

一个比较具体的使用场景，比如要对比两个对象修改前后的差异，可以在修改前复制一个对象实例，然后修改之后对比。再比如一次比较重的数据库查询，可以缓存该对象，再下一次请求到来时直接返回该对象的复制。

一些比较适合的场景：

  • 当创建一个实例比较昂贵或者复杂时

原型模式的优点：

  • 对客户端隐藏了构造对象的复杂细节
  • 对客户端提供了一种在不确定类型情况下创建对象实例的方法
  • 某一些场景下复制对象实例要比创建来的更有效率

缺点：

  • 对于一些只有少量对象的系统来说并不太需要
  • 每一个原型类的子类都需要实现 clone 方法，有些时候创建对象拷贝并不是非常轻松

reference