【设计模式】创建型：原型模式（三）深度克隆

悠悠 2023-01-15 14:28 101阅读 0赞

实现深度克隆有两种方案：

*  递归拷贝对象、对象的引用对象以及引用对象的引用对象……直到要拷贝的对象只包含基本数据类型数据，没有引用对象为止。
 *  先将对象序列化，然后再反序列化成新的对象，在反序列时就会将重新创建一个对象，然后会自动创建原对象持有引用的对象。

我们还是通过一个场景来演示，大家都知道齐天大圣。首先它是一只猴子，有七十二般变化，把一根毫毛就可以吹出千万个泼猴，手里还拿着金箍棒，金箍棒可以变大变小。这就是我们耳熟能详的原型模式的经典体现

创建原型猴子 Monkey 类，它是 QiTianDaSheng 的基类：

public class Monkey {
        
        public int height;
        public int weight;
        public Date birthday;
    }

创建引用对象金箍棒 Jingubang 类，它是 QiTianDaSheng 的引用类型变量：

public class JinGuBang implements Serializable {
        
        public float h = 100;
        public float d = 10;
    
        public void big(){
        
            this.d *= 2;
            this.h *= 2;
        }
    
        public void small(){
        
            this.d /= 2;
            this.h /= 2;
        }
    }

创建具体的对象齐天大圣 QiTianDaSheng 类：

// 实现 Cloneable 接口
    public class QiTianDaSheng extends Monkey implements Cloneable,Serializable {
        
    	// 要拷贝的引用成员
        public JinGuBang jinGuBang;
    
        public  QiTianDaSheng(){
        
            // 只是初始化
            this.birthday = new Date();
            this.jinGuBang = new JinGuBang();
        }
    	
        @Override
        // 实现 clone 方法
        protected Object clone() throws CloneNotSupportedException {
        
            return this.deepClone();
        }
    
    	// 深度克隆
        public Object 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);
    			
    			// 再将对象从字节数组反序列化
                QiTianDaSheng copy = (QiTianDaSheng)ois.readObject();
                copy.birthday = new Date();
                return copy;
            }catch (Exception e){
        
                e.printStackTrace();
                return null;
            }
    
        }
    
    	// 浅克隆
        public QiTianDaSheng shallowClone(QiTianDaSheng target){
        
    		// 直接创建新对象然后赋值
            QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();
            qiTianDaSheng.height = target.height;
            qiTianDaSheng.weight = target.height;
    
            qiTianDaSheng.jinGuBang = target.jinGuBang;
            qiTianDaSheng.birthday = new Date();
            return qiTianDaSheng;
        }
    
    
    }

测试代码：

public class DeepCloneTest {
        
    
        public static void main(String[] args) {
        
    		
    		// 先创建一个 QiTianDaSheng 实例
            QiTianDaSheng qiTianDaSheng = new QiTianDaSheng();
            try {
        
            	// 通过 深度克隆 再产生一个实例
                QiTianDaSheng clone = (QiTianDaSheng)qiTianDaSheng.clone();
                // 比较两个实例的 JinguBang 是否指向同一对象
                System.out.println("深克隆：" + (qiTianDaSheng.jinGuBang == clone.jinGuBang));
            } catch (Exception e) {
        
                e.printStackTrace();
            }
    		
    		// 再创建一个 QiTianDaSheng 来验证一下浅克隆
            QiTianDaSheng q = new QiTianDaSheng();
            QiTianDaSheng n = q.shallowClone(q);
            System.out.println("浅克隆：" + (q.jinGuBang == n.jinGuBang));
    
        }
    }

结果如下：

![在这里插入图片描述][20210422235906546.png_pic_center]

### 原型模式总结 ###

原型模式有两种实现方法，深拷贝和浅拷贝。浅拷贝只会复制对象中基本数据类型数据和引用对象的内存地址，不会递归地复制引用对象，以及引用对象的引用对象……而深拷贝得到的是一份完完全全独立的对象。

所以，深拷贝比起浅拷贝来说，更加耗时，更加耗内存空间。 但对于可变对象来说，浅拷贝得到的对象和原始对象会共享部分数据，就有可能出现数据被修改的风险，也就变得复杂多了。

如果要拷贝的对象是不可变对象，浅拷贝共享不可变对象是没问题的，否则，没有充分的理由，不要为了一点点的性能提升而使用浅拷贝。

**克隆破坏单例模式问题**

如果我们克隆的目标的对象是单例对象，那意味着，深克隆就会破坏单例。

实际上防止克隆破坏单例解决思路非常简单，禁止深克隆便可。要么单例类不实现 Cloneable 接口；要么我们重写 clone()方法，在 clone 方法中返回单例对象即可，具体代码如下：

@Override
    protected Object clone() throws CloneNotSupportedException {
        
    	return INSTANCE;
    }

[20210422235906546.png_pic_center]: /images/20221022/39eb4b97ca1a4466beeef0d29099b4f5.png