Java设计模式笔记（4）原型模式
1. 原型模式的定义
原型模式（Prototype Pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式实际上就是不通过 new 关键字，而是通过对象拷贝来实现创建另一个新的对象，使新的对象有具有原对象的特征。原型模式可分为两种形式：浅度克隆、深度克隆
- 浅度克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。
- 深度克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。
2. 原型模式的使用场景
- 类初始化消耗的资源较多；
- new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）
- 构造函数比较复杂；
- 循环体中生产大量对象时。
- 在 Spring 中，原型模式应用得非常广泛。例如 scope=“prototype”，我们经常用的 JSON.parseObject()也是一种原型模式。
3. Java中的深度克隆与浅度克隆
Java的所有类都是从java.lang.Object类继承而来的，而Object类提供protected Object clone()方法对对象进行复制，但Object类的clone方法只会拷贝对象中的基本的数据类型，对于数组、容器对象、引用类型对象等都不会拷贝，这就是所谓浅拷贝。如果要实现深拷贝，必须将原型模式中的数组、容器对象、引用对象等另行拷贝。
注意事项：
- Java语言提供的Cloneable接口只起一个作用，就是在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。
- 使用原型模式复制对象不会调用类的构造方法。因为对象的复制是通过调用Object类的clone方法来完成的，它直接在内存中复制数据，因此不会调用到类的构造方法。不但构造方法中的代码不会执行，甚至连访问权限都对原型模式无效。还记得单例模式吗？单例模式中，只要将构造方法的访问权限设置为private型，就可以实现单例。但是clone方法直接无视构造方法的权限，所以，单例模式与原型模式是冲突的，在使用时要特别注意。
4. 浅度克隆
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() {
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype{" + "age=" + age + ", name='" + name + '\'' + '}';
}
}
测试代码：
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("prototype");
List<String> hobbies = new ArrayList<String>();
hobbies.add("复制");
hobbies.add("拷贝");
prototype.setHobbies(hobbies);
System.out.println(prototype);
//拷贝原型对象 ConcretePrototype
ConcretePrototype cloneType = prototype.clone();
cloneType.getHobbies().add("不留痕迹");
System.out.println("原型对象：" + prototype);
System.out.println("克隆对象：" + cloneType);
}
运行结果：
ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝]]
原型对象：ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝, 不留痕迹]]
克隆对象：ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝, 不留痕迹]]
我们给复制后的克隆对象新增一项爱好，发现原型对象也发生了变化，这显然不符合我们的预期。 因为我们希望克隆出来的对象应该和原型对象是两个独立的对象，不应该再有联系了。从测试结果分析来看，应该是 hobbies 共用了一个内存地址，意味着复制的不是值，而是引用的地址。这样的话，如果我们修改任意一个对象中的属性值，prototype 和 cloneType 的 hobbies 值都会改变。这就是我们常说的浅克隆。只是完整复制了值类型数据，没有赋值引用对象。换言之，所有的引用对象仍然指向原来的对象，显然不是我们想要的结果。那如何解决这个问题呢？下面我们来看深度克隆继续改造。
5. 深度克隆
在上面的基础上我们继续改造，来看代码，增加一个 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 Object deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
oos.flush();
oos.close();
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
ConcretePrototype clone = (ConcretePrototype)ois.readObject();
ois.close();
return clone;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype [age=" + age + ", name=" + name + ", hobbies=" + hobbies + "]";
}
}
测试代码：
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("prototype");
List<String> hobbies = new ArrayList<String>();
hobbies.add("复制");
hobbies.add("拷贝");
prototype.setHobbies(hobbies);
System.out.println(prototype);
//拷贝原型对象 ConcretePrototype
ConcretePrototype cloneType = (ConcretePrototype) prototype.deepClone();
cloneType.getHobbies().add("不留痕迹");
System.out.println("原型对象：" + prototype);
System.out.println("克隆对象：" + cloneType);
System.out.println(prototype == cloneType);
System.out.println("原型对象的爱好：" + prototype.getHobbies());
System.out.println("克隆对象的爱好：" + cloneType.getHobbies());
System.out.println(prototype.getHobbies() == cloneType.getHobbies());
}
运行结果：
ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝]]
原型对象：ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝]]
克隆对象：ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝, 不留痕迹]]
false
原型对象的爱好：[复制, 拷贝]
克隆对象的爱好：[复制, 拷贝, 不留痕迹]
false
可以发现我们得到了期望的结果
6. 克隆破坏单例模式
如果我们克隆的目标的对象是单例对象，那意味着，深克隆就会破坏单例。实际上防止克隆破坏单例解决思路非常简单，禁止深克隆便可。要么我们的单例类不实现Cloneable 接口；要么我们重写 clone()方法，在 clone 方法中返回单例对象即可，具体
代码如下
@Override
protected Object clone() throws CloneNotSupportedException {
return INSTANCE;
}
7. Cloneable 源码分析
先来 JDK 中 Cloneable 接口
public interface Cloneable {
}
接口定义的很简单，我们找源码其实只需要找到看哪些接口实现了 Cloneable 即可。来看ArrayList 类的实现
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
可以发现方法中只是将 List 中的元素循环遍历了一遍。那么是不是这种形式就是深克隆呢？我们来用代码验证一下，继续修改 ConcretePrototype 类，增加一个deepCloneHobbies()方法
public ConcretePrototype deepCloneHobbies(){
try {
ConcretePrototype result = (ConcretePrototype)super.clone();
result.hobbies = (List)((ArrayList)result.hobbies).clone();
return result;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
测试代码：
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("prototype");
List<String> hobbies = new ArrayList<String>();
hobbies.add("复制");
hobbies.add("拷贝");
prototype.setHobbies(hobbies);
System.out.println(prototype);
//拷贝原型对象 ConcretePrototype
ConcretePrototype cloneType = (ConcretePrototype) prototype.deepCloneHobbies();
cloneType.getHobbies().add("不留痕迹");
System.out.println("原型对象：" + prototype);
System.out.println("克隆对象：" + cloneType);
System.out.println(prototype == cloneType);
System.out.println("原型对象的爱好：" + prototype.getHobbies());
System.out.println("克隆对象的爱好：" + cloneType.getHobbies());
System.out.println(prototype.getHobbies() == cloneType.getHobbies());
}
运行结果：
ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝]]
原型对象：ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝]]
克隆对象：ConcretePrototype [age=18, name=prototype, hobbies=[复制, 拷贝, 不留痕迹]]
false
原型对象的爱好：[复制, 拷贝]
克隆对象的爱好：[复制, 拷贝, 不留痕迹]
false
运行也能得到期望的结果。但是这样的代码，其实是硬编码，如果在对象中声明了各种集合类型， 那每种情况都需要单独处理。因此，深克隆的写法，一般会直接用序列化来操作。
8. 原型模式优点
- 性能优良，Java 自带的原型模式 是基于内存二进制流的拷贝，比直接 new 一个对象性能上提升了许多。
- 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用(例如恢复到历史某一状态)，可辅助实现撤销操作
9. 原型模式缺点
- 每一个类必须配备一个克隆（或者可拷贝）方法。
- 克隆方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则
- 对克隆复杂对象或对克隆出的对象进行复杂改造时，易带来风险。
- 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深拷贝、浅拷贝需要运用得当。
10. 原型模式特点
- 不调用构造函数
