原型模式
概念
原型模式（Prototype Pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，属于创建型模式。
原型模式的核心在于拷贝原型对象。以系统中已存在的一个对象为原型，直接基于内存二进制流进行拷贝，无需再经历耗时的对象初始化过程（不调用构造函数），性能提升许多。当对象的构建过程比较耗时时，可以利用当前系统中已存在的对象作为原型，对其进行克隆（一般是基于二进制流的复制），躲避初始化过程，使得新对象的创建时间大大减少。
类结构图
原型模式类结果图.png
角色
从 UML 图中，我们可以看到，原型模式 主要包含三个角色：
- 客户(Client)：客户类提出创建对象的请求。
- 抽象原型(Prototype)：规定拷贝接口。
- 具体原型（Concrete Prototype）：被拷贝的对象。
适用场景
- 类初始化消耗资源较多
- new 产生一个对象需要非常繁琐的过程（数据准备、访问权限等）
- 构造函数比较复杂
- 循环体中生成大量对象时
通用写法
先创建原型 IPrototype 接口：
public interface IPrototype<T> {
T clone();
}
创建具体需要克隆的对象 ConcretePrototype：
public class ConcretePrototype implements IPrototype {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public ConcretePrototype clone() {
ConcretePrototype concretePrototype = new ConcretePrototype();
concretePrototype.setAge(this.age);
concretePrototype.setName(this.name);
return concretePrototype;
}
@Override
public String toString() {
return "ConcretePrototype{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
测试代码：
public static void main(String[] args) {
ConcretePrototype concretePrototype = new ConcretePrototype();
concretePrototype.setAge(20);
concretePrototype.setName("Aaron");
System.out.println(concretePrototype);
ConcretePrototype copyObject = concretePrototype.clone();
System.out.println(copyObject);
}
运行结果：
ConcretePrototype{age=20, name='Aaron'}
ConcretePrototype{age=20, name='Aaron'}
事实上，JDK 已经实现了一个现成的API，我们只需要实现 Cloneable 接口即可。
改造代码，修改 ConcretePrototype 类：
public class ConcretePrototype implements Cloneable {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public ConcretePrototype clone() {
// ConcretePrototype concretePrototype = new ConcretePrototype();
// concretePrototype.setAge(this.age);
// concretePrototype.setName(this.name);
// return concretePrototype;
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
浅克隆
这种克隆方法存在问题，当原型类中的属性为引用数据类型时，该属性会共用一个内存地址，克隆复制的不是值，而是引用的地址。这就是我们常说的浅克隆。
public class ConcretePrototype implements Cloneable {
private int age;
private String name;
private List<String> hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype{" +
"age=" + age +
", name='" + name + '\'' +
", hobbies=" + hobbies +
'}';
}
}
测试代码：
public static void main(String[] args) {
ConcretePrototype concretePrototype = new ConcretePrototype();
concretePrototype.setAge(20);
concretePrototype.setName("Aaron");
List<String> hobbies = new ArrayList<String>();
hobbies.add("书法");
hobbies.add("美术");
concretePrototype.setHobbies(hobbies);
System.out.println(concretePrototype);
ConcretePrototype copyObject = concretePrototype.clone();
copyObject.getHobbies().add("技术");
System.out.println("原型对象：" + concretePrototype);
System.out.println("克隆对象：" + copyObject);
}
测试结果：
ConcretePrototype{age=20, name='Aaron', hobbies=[书法, 美术]}
原型对象：ConcretePrototype{age=20, name='Aaron', hobbies=[书法, 美术, 技术]}
克隆对象：ConcretePrototype{age=20, name='Aaron', hobbies=[书法, 美术, 技术]}
使用序列化实现深度克隆
改造代码，增加 deepClone() 方法：
public class ConcretePrototype implements Cloneable, Serializable {
private int age;
private String name;
private List<String> hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
public ConcretePrototype deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (ConcretePrototype) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype{" +
"age=" + age +
", name='" + name + '\'' +
", hobbies=" + hobbies +
'}';
}
}
测试代码：
public class Client {
public static void main(String[] args) {
ConcretePrototype concretePrototype = new ConcretePrototype();
concretePrototype.setAge(20);
concretePrototype.setName("Aaron");
List<String> hobbies = new ArrayList<String>();
hobbies.add("书法");
hobbies.add("美术");
concretePrototype.setHobbies(hobbies);
System.out.println(concretePrototype);
ConcretePrototype copyObject = concretePrototype.deepClone();
copyObject.getHobbies().add("技术");
System.out.println("原型对象：" + concretePrototype);
System.out.println("克隆对象：" + copyObject);
}
}
测试结果：
ConcretePrototype{age=20, name='Aaron', hobbies=[书法, 美术]}
原型对象：ConcretePrototype{age=20, name='Aaron', hobbies=[书法, 美术]}
克隆对象：ConcretePrototype{age=20, name='Aaron', hobbies=[书法, 美术, 技术]}
优点
- 性能优良，Java 自带的原型模式是基于内存二进制流的拷贝，比直接 new 一个对象性能上提升了许多
- 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用（例如恢复到历史某一状态），可辅助实现撤销操作
缺点
- 需要为每一个类配置一个克隆方法
- 克隆方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则
- 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦
