JAVA 设计模式之 原型模式详解
原型模式（Prototype Pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式利用的是克隆的原理，创建新的对象，JDK提供的Cloneable 和JSON、springUtil里面的克隆都是一般浅克隆，与之对应的还有深克隆
1、浅克隆
浅克隆也是穿件一个新的对象，不过该对象的属性值是被克隆对象的，如果修改被克隆对象，后者跟着修改。
下面我们用Cloneable写一个简单的浅克隆
import java.util.List;
/**
* @Description TODO
* @Author Bert
* @Date 2019\6\10 0010
*/
public class ShallowClone implements Cloneable{
private String name;
private int age;
private List<String> hobbies;
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> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
//实现 Cloneable 的 clone 方法 属于浅克隆
@Override
public ShallowClone clone() {
ShallowClone shallowClone = null;
try {
shallowClone = (ShallowClone)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return shallowClone;
}
//手写 浅克隆 方法
public ShallowClone spellClone(){
ShallowClone shallowClone = new ShallowClone();
shallowClone.setName(this.name);
shallowClone.setAge(this.age);
shallowClone.setHobbies(this.hobbies);
return shallowClone;
}
}
测试代码：
public static void main(String[] args) {
ShallowClone shallowClone = new ShallowClone();
shallowClone.setName("ZhangSan");
shallowClone.setAge(21);
List<String> list = new ArrayList<>();
list.add("play game");
list.add("Listen music");
shallowClone.setHobbies(list);
//调用Cloneable 的clone方法
ShallowClone clone1 = shallowClone.clone();
//添加喜好
shallowClone.getHobbies().add("fitness");
//调用手写的浅克隆方法
ShallowClone clone2 = shallowClone.spellClone();
System.out.println(shallowClone == clone1);//判读是否为同一个对象
System.out.println(shallowClone == clone2);//判读是否为同一个对象
System.out.println("克隆对象中引用类型地址："+shallowClone.getHobbies());
System.out.println("克隆对象中引用类型地址："+clone1.getHobbies());
System.out.println("克隆对象中引用类型地址："+clone2.getHobbies());
}
运行结果：
false false 克隆对象中引用类型地址：[play game, Listen music, fitness] 克隆对象中引用类型地址：[play game, Listen music, fitness] 克隆对象中引用类型地址：[play game, Listen music, fitness]
从运行结果我们可以看出，克隆对象和原来的对象不是同一个，但对象的属性完全一样，即使改变了其中一个，其他的也会跟着改变。
通过上面spellClone() 方法我们可以看出，浅克隆的整个过程就是，创建一个新的对象，然后新对象的每个值都是由原对象的值，通过 = 进行赋值；
（1）拷贝后获取的是一个独立的对象，和原对象拥有不同的内存地址；
（2）基本元素类型，两者是隔离的，int, Integer, long, Long, char, Charset, byte,Byte, boolean, Boolean, float,Float, double, Double, String
（3）非基本数据类型（如基本容器，其他对象等），只是拷贝了一份引用出去了，实际指向的依然是同一份，例如上的list<String>
一句话总结就是：基本数据类型是值赋值；非基本的就是引用赋值。
2、深克隆
创建一个全新的对象，新的对象内部所有的成员也都是全新的，只是初始化的值已经由被克隆的对象确定，但是他们是两个完全独立的对象，修改是隔离，互不影响。
下面我们来写一个简单的深克隆
import java.io.*;
import java.util.ArrayList;
import java.util.List;
/**
* @Description TODO
* @Author Bert
* @Date 2019\6\10 0010
*/
public class DeepClone implements Serializable{
private String name;
private int age;
private List<String> hobbies;
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> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
// 深克隆 方法 1
public DeepClone deepClone(){
DeepClone deepClone = new DeepClone();
deepClone.setName(this.name);
deepClone.setAge(this.age);
//基本数据类型 重新创建
if(null != this.hobbies){
deepClone.setHobbies(new ArrayList<>(this.hobbies));
}
return deepClone;
}
//深克隆 2 通过 byte字节码 ，这种方式需要 实现 Serializable
public DeepClone deepCloneByte() {
DeepClone dClone = null;
ByteArrayOutputStream bys = new ByteArrayOutputStream();
try {
ObjectOutputStream oos = new ObjectOutputStream(bys);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bys.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
dClone = (DeepClone)ois.readObject();
} catch (Exception e) {
e.printStackTrace();
}
return dClone;
}
}
测试代码：
public static void main(String[] args) {
DeepClone deepClone = new DeepClone();
deepClone.setName("ZhangSan");
deepClone.setAge(21);
List<String> list = new ArrayList<>();
list.add("play game");
list.add("Listen music");
deepClone.setHobbies(list);
//调用第一种方式，并修改值
DeepClone deepClone1 = deepClone.deepClone();
deepClone1.getHobbies().add("fitness");
deepClone1.setAge(22);
//调用第二种方式，并修改值
DeepClone deepClone2 = deepClone.deepCloneByte();
deepClone2.getHobbies().add("Climbing mountain");
System.out.println(deepClone == deepClone1);
System.out.println(deepClone == deepClone2);
System.out.println("克隆对象中引用类型地址："+deepClone.getHobbies());
System.out.println("克隆对象中引用类型地址："+deepClone1.getHobbies());
System.out.println("克隆对象中引用类型地址："+deepClone2.getHobbies());
}
运行结果：
false false 克隆对象中引用类型地址：[play game, Listen music] 克隆对象中引用类型地址：[play game, Listen music, fitness] 克隆对象中引用类型地址：[play game, Listen music, Climbing mountain]
以上可以看出深克隆的对象之间修改完全不受影响。
3、原型模式运用场景
（1）类初始化消耗资源较多。
（2）new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）
（3）构造函数比较复杂。
（4）循环体中生产大量对象时。
在 Spring 中，原型模式应用得非常广泛。例如 scope=“prototype”，在我们经常用 的 JSON.parseObject()也是一种原型模式。
4、解决深克隆破坏单例模式
如果我们的被克隆对象是单例模式，深克隆就得破坏单例模式。
解决方案：禁止深克隆。一是不实现Cloneable； 二是实现Cloneable ,在clone方法中返回我们的单例。
@Override
protected Object clone() throws CloneNotSupportedException {
return INSTANCE;
}
Cloneable 源码分析：
以ArryList 为例，ArrayList 就实现了 Cloneable 接口
/**
* Returns a shallow copy of this <tt>ArrayList</tt> instance. (The
* elements themselves are not copied.)
*
* @return a clone of this <tt>ArrayList</tt> instance
*/
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);
}
}
