java Cloneable—从原型模式说起
从原型模式说起
最近复习了一下23种设计模式，其中有一种模式叫“原型模式”，我更想称之为“克隆模式”。看到一遍讲的比较清楚的文章：
http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html。
文中提到克隆，分为浅克隆和深克隆。看完之后我个人的理解是这样：
浅克隆：只负责克隆不可变类型的数据（比如基本数据类型、String类型），而不复制它所引用的对象，换言之，所有的对其他对象的引用都仍然指向原来的对象。具体做法是实现Cloneable接口，覆盖Object的clone()方法。
深克隆：利用序列化实现深度克隆。
要实现“深克隆”只能利用序列化来实现吗？这个成本也太高了点：每次将对象写入一个outputStream，再构造一个inputStream读出来。
答案显然不是，因为jdk源码中很多类都不是通过这种方式实现的深度克隆。
Cloneable接口
这里不讲解采用序列化实现深度克隆，感兴趣的同学可以看一下我上面提到博客，里面讲得很清楚。
Cloneable接口的目的：实现这个接口的类的对象允许被克隆。同时该类需要重写Object类的clone方法。先看下一个最简单的做法：
/**
* Created by gantianxing on 2017/5/13.
*/
public class PhoneNumber implements Cloneable{
private short areaCode;//区号
private short lineNum;//号码
public PhoneNumber(short areaCode,short lineNum) {
this.areaCode = areaCode;
this.lineNum = lineNum;
}
@Override
public PhoneNumber clone(){
try {
return (PhoneNumber)super.clone();
} catch (CloneNotSupportedException e){
throw new AssertionError();
}
}
// 其他方法
}
super.clone()实际上调用的是Object的clone方法，看下源码是个本地方法，应该是JVM实现的：
protected native Object clone() throws CloneNotSupportedException;
实例化一个PhoneNumber的对象，调用clone方法，可以完全得到一个新的对象。
实现clone方法需要注意：clone方法必须确保它不会伤害到原始对象。
由于short类型是不可变类型，假设克隆对象里的值改变了，也不会影响到原始对象。
假设PhoneNumber对象中添加一个 private Person person 的对象，采用上面的方法进行clone就是所谓的“浅克隆”，克隆对象和原始对象持有的是同一个person对象，克隆对象改变person对象，就会伤害到原始对象。这种做法是不建议使用的（除非你业务确实需要）。
那怎么来实现含有“可变对象”成员变量的“深克隆”呢？我们可以从jdk中学习到一些经典做法。
jdk中Vector的clone方法
我们先看一个简单的Vector类的clone方法。
public class Vector<E>
extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
protected Object[] elementData; //数组对象 可变
protected int elementCount;//成员个数 不可变
protected transient int modCount = 0;//修改次数
//省略代码
public synchronized Object clone() {
try {
@SuppressWarnings("unchecked")
Vector<E> v = (Vector<E>) super.clone();
//最终通过System.arraycopy生成一个新的数组
v.elementData = Arrays.copyOf(elementData, elementCount);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
//省略代码
}
我们看到：
第一步，克隆“不可变对象”（elementCount等），调用的是super.clone()，生成一个新的对象v。
第二步，克隆“可变对象”（elementData），通过Arrays.copyOf方法生成一个新的数组对象。
第三步，调整“不可变对象”modCount，新克隆对象的修改次数肯定是从0开始。这一步根据具体业务需要进行调整。
其实对于数组还有一种方式：
public synchronized Object clone() {
try {
Vector<E> v = (Vector<E>) super.clone();
v.elementData = elementData.clone();
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
这是采用递归的方式进行克隆。
其实这两种clone方式都不是严格意义上的“深克隆”，如果Vector中存放的是不可变类型对象（比如 string，Integer等）那属于“深克隆”，但如果存放的是其他对象，则还是是“浅克隆”。
测试代码如下：
public static void main(String[] args) {
Vector<User> vector = new Vector();
User test = new User();
test.setId(1);
vector.add(test);
//以vector对象clone出 vector2对象
Vector <User> vector1 = (Vector) vector.clone();
System.out.println(vector.get(0).getId());
System.out.println(vector1.get(0).getId());
//改版vector对象中存储的对象值，发现vector1中也跟着变了
vector.get(0).setId(2);
System.out.println(vector.get(0).getId());
System.out.println(vector1.get(0).getId());
}
public class User {
private int id;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
}
执行main方法 结果为：
1 1 2 2
说明Vector的clone方法本质上还是属于“浅克隆”。
另外还有其他很多工具类都是"浅克隆"，比如散列表的clone方法（HashMap Hashtable），它的内部包含的是一个散列桶数组，每个散列桶指向一个单项链表的第一项键值对，如果为空，则为null。如果这时候采用数据copy或者递归克隆，都只是对桶数组进行克隆，其中的单项链表其实还是同一份。同样违背了“clone方法必须确保它不会伤害到原始对象”的原则。
这里提到的Vetor、HashMap、ArrayList、Hashtable的clone方法实现都是“浅克隆”。
jdk中HashTable的clone方法
我们来看看Hashtable的做法：
public class Hashtable<K,V>
extends Dictionary<K,V>
implements Map<K,V>, Cloneable, java.io.Serializable {
//。。。省略代码。。。
public synchronized Object clone() {
try {
Hashtable<K, V> t = (Hashtable<K, V>) super.clone();//调用object的clone方法
t.table = new Entry[table.length];//新建一个桶数组
for (int i = table.length; i-- > 0; ) {//克隆桶数组
t.table[i] = (table[i] != null)
? (Entry<K, V>) table[i].clone() : null;//table[i].clone() 为
}
//。。。。省略代码
return t;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError();
}
}
private static class Entry<K, V> implements Map.Entry<K, V> {
//。。。。省略代码
protected Entry(int hash, K key, V value, Entry<K, V> next) { //Entry对象,组成单项链表
this.hash = hash;
this.key = key;
this.value = value;
this.next = next;
}
protected Object clone() { //单项链表的克隆，递归调用下一个对象的clone方法
return new Entry<K, V>(hash, key, value,
(next == null ? null : (Entry<K, V>) next.clone()));
}
//省略代码
}
//。。。省略代码。。。
}
可以看到对单项链表的克隆采用的是对下一个Entry clone()方法的递归调用，如果这个单项链表太长，可能会引发 栈溢出：栈内存默认是128K，递归调用会不停的压栈，超过128k就会溢出。如果你的Hashtable（或HashMap）中存放有比较大的对象，恰巧某个hash桶里的单项链表又比较长。这个时候调用这个Hashtable的clone方法很有可能会出现*Error。当然你可以通过修改 jvm启动参数 –Xss 1024k,调大每个线程的栈内存；或者直接放弃clone。
个人愚见，这也相当于jdk的坑吧，在effective java中有一个用循环改递归的改进方法，不知道jdk以后会不会采纳（话说Hashtable的使用基本已经废弃，估计是不会改了）：
Entry deepCopy(){
Entry result = new Entry(key,vlue,next);
for(Entry p = result;p.next !=null;p=p.next){
p.next=new Entry(p.next.key,p.next.vlue,p.next.next);
}
}
成员变量是自定义对象的情况，就不说了，通过新建对象，并为其赋值即可。 当然更好的方式是让该自定义类也实现其clone方法，外部类直接调用即可。
虽然Hashtable的实现也不是“深克隆”（可以自己做类似上述Vector的测试），但我们已经找到我们想要的了，就是递归调用内部可变对象的clone方法。这里以HashMap为例进行讲解如何实现 对HashMap的“深克隆”，定义一个新的User类，多个Address信息以HashMap的形式作为User类的成员变量，为了能对User实现“深克隆”，我们必须重新User类、Address类的clone方法：
public class User implements Cloneable{
private int id;
private HashMap<String,Address> addressMap = new HashMap<>();
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
public HashMap<String, Address> getAddressMap() {
return addressMap;
}
public void setAddressMap(HashMap<String, Address> addressMap) {
this.addressMap = addressMap;
}
@Override
public Object clone(){
try {
User newUser = (User)super.clone();
newUser.addressMap = new HashMap<>(addressMap.size());
for (String key:addressMap.keySet()){
//把clone对象放到新的hashmap
newUser.addressMap.put(key,(Address)addressMap.get(key).clone());
}
return newUser;
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
}
User类的clone方法，主要是循环遍历老Hashmap，clone里面的Address对象，把clone的Address对象放入新HashMap里。
由于没有可变对象类型的成员变量，Address类的clone方法很简单，直接调用super.clone即可：
public class Address implements Cloneable{
private String address;
public Object clone(){
try {
return super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
}
}
public String getAddress() {
return address;
}
public void setAddress(String address) {
this.address = address;
}
}
最后编写测试main方法：
public static void main(String[] args) {
User user = new User();
user.setId(1);
Address home = new Address();
home.setAddress("四川成都");
user.getAddressMap().put("home",home);
//以user对象为基础进行克隆
User newUser = (User)user.clone();
System.out.println(user.getAddressMap().get("home"));
System.out.println(newUser.getAddressMap().get("home"));
//改变老user对象hashmap中的地址信息，对比看newUser对象hashmap中的地址信息是否发生变化
user.getAddressMap().get("home").setAddress("中国北京");
System.out.println(user.getAddressMap().get("home").getAddress());
System.out.println(newUser.getAddressMap().get("home").getAddress());
}
执行mian方法，结果为：
com.jd.ejshop.domain.pub.render.Address@4617c264 com.jd.ejshop.domain.pub.render.Address@36baf30c 中国北京 四川成都
测试结果说明，老User对象中的Address发生变化时，不会影响newUser对象中的Adress。说明newUser对象是“深克隆”。
至此如何实现自己的“深克隆”模式讲解完毕，简单的讲就是递归调用clone方法，关于Cloneable就说这么多吧。