一、原型模式介绍

原型模型(Prototype) 是一种对象创建型模式，使用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象，主要用于创建重复的对象，同时又能保证性能。工作原理是将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过原型对象拷贝自己来实现创建过程。原型模型应该是最简单的设计模式了，实现一个接口，重写一个方法即可完成原型模式。

• 核心组成
  • Prototype：声明克隆方法的接口，是所有具体原型类的公共父类，也就是 Cloneable 接口
  • ConretePrototype：具体原型类，也就是实现了 Cloneable 接口的类
  • Client：让一个原型对象克隆自身从而创建一个新的对象，也就是使用者（比如在 main 函数中）
• 应用场景
  • 创建新对象成本较大，新的对象可以通过原型模式对已有对象进行复制来获取
  • 如果系统要保存对象的状态，做备份使用
• 两种拷贝
  • 㳀拷贝：如果原型对象的成员变量是基本数据类型（int、double、byte、boolean、char 等），将复制一份给克隆对象；如果原型对象的成员变量是引用类型，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象的成员变量指向相同的内存地址。通过覆盖 Object 类的 clone()方法可以实现浅克隆。
  • 深拷贝：无论原型对象的成员变量是基本数据类型还是引用类型，都将复制一份给克隆对象，如果需要实现深克隆，可以通过序列化（Serializable）等方式来实现。
• 优点
  • 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，可以提高实例的创建效率
  • 可辅助实现撤销操作，使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便在需要的时候使用恢复到历史状态
• 缺点
  • 需要为每一个类配备一个克隆方法，对已有类进行改造时，需要修改源代码，违背了“开闭原则”。
  • 在实现深克隆时需要编写较为复杂的代码，且当对象之间存在多重嵌套引用时，需要对每一层对象对应的类都必须支持深克隆。

综上，为方便记忆原型模式，可以 “肤浅” 的认为：

• 浅拷贝：实现 Cloneable 接口
• 深拷贝：实现 Serializable 接口 或 借助其他序列化手段

以下，是对 Cloneable 接口的补充说明：

• Cloneable 接口是一个空接口，仅用于标记对象，Cloneable 接口里面是没有 clone()方法的，clone()方法是 Object 类里面的方法，默认实现是一个 Native 方法。
• 如果对象 implement Cloneable 接口的话，需要覆盖 clone 方法（因为 Object 类的 clone 方法是 protected，需要覆盖为 public）

二、原型模式代码实现

创建原型类(ConretePrototype) ：

public class Person implements Cloneable, Serializable {

	private String name;
	private int age;
	private List<String> list;

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	public int getAge() {
		return age;
	}

	public void setAge(int age) {
		this.age = age;
	}

	public List<String> getList() {
		return list;
	}

	public void setList(List<String> list) {
		this.list = list;
	}

	@Override
	protected Person clone() throws CloneNotSupportedException {
		return (Person) super.clone();
	}

	public Person deepClone() {
		Person copyObj = null;
		byte[] byteArray = null;

		// 序列化 输出
		try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
				ObjectOutputStream oos = new ObjectOutputStream(baos);) {
			oos.writeObject(this);
			byteArray = baos.toByteArray();
		} catch (Exception e) {
			e.printStackTrace();
		}

		// 反序列化 输入
		try (ByteArrayInputStream bais = new ByteArrayInputStream(byteArray);
				ObjectInputStream ois = new ObjectInputStream(bais);) {
			copyObj = (Person) ois.readObject();
		} catch (Exception e) {
			e.printStackTrace();
		}

		return copyObj;
	}
}

注意：deepClone()中 try-catch 的用法是 JDK1.7 优化后的 try-with-resource 语法，会自动调用 close()。

使用方使用原型类克隆出新对象实例：

public class Client {
	public static void main(String[] args) throws CloneNotSupportedException {
		List<String> fruits = new ArrayList<String>(Arrays.asList("apple", "banana", "pear"));

		Person person1 = new Person();
		person1.setName("GitLqr");
		person1.setAge(18);
		person1.setList(fruits);

		// 浅拷贝
		// Person person2 = person1.clone();
		// 深拷贝
		Person person2 = person1.deepClone();
		person2.setName("CharyLin");
		person2.getList().add("shit");

		System.out.println("person1 name is " + person1.getName() + ", age is " + person1.getAge() + ", list is "
				+ person1.getList());
		System.out.println("person2 name is " + person2.getName() + ", age is " + person2.getAge() + ", list is "
				+ person2.getList());
	}
}