设计模式之原型模式，及深浅拷贝

设计模式，不管是在准备面试过程，还是在实际工作编码中，都是应该掌握的技能，所以特别整理一下设计模式相关的知识，希望对大家有所帮助

可能我们会遇到这样一种场景：在编码中有这样一个对象，此对象比较重（构造比较耗时）或者是构造方法相当复杂，使用起来很麻烦，总之创建成本很高，类似这样

public class HeavyObject {

    public HeavyObject(){
        try {
            // 模拟次对象创建耗时
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("HeavyObject init success");
    }
}

而这种对象可能由于业务的需求，需要在循环中创建并使用

public class PrototypeTest {

    public static void main(String[] args) {
        long l1 = System.currentTimeMillis();
        for(int i = 0; i < 10; i ++) {
            HeavyObject heavyObject = new HeavyObject();
            System.out.println(heavyObject);
        }
        long l2 = System.currentTimeMillis();
        System.out.println(l1 - l2);
    }
}

上面这段代码的效率相信不用执行大家也知道是多大惨不忍睹，执行测试，在我机器上为：10006ms；而针对这种情况能不能有一个好的方式来优化呢？当然是今天的主角：原型模式啦。虽然号称是“设计模式”，但是原型模式在实现的角度看确实很简单：实现Cloneable接口即可，然后再获取新的对象实例的时候使用原实例对象的clone()即可；
HeavyObject 变化为

public class HeavyObject implements Cloneable {

    public HeavyObject(){
        try {
            // 模拟次对象创建耗时
            Thread.sleep(1000);
        } catch (InterruptedException e) {
            e.printStackTrace();
        }
        System.out.println("HeavyObject init success");
    }
}

测试方法

public class PrototypeTest {
    
    public static void main(String[] args) throws CloneNotSupportedException {
        long l1 = System.currentTimeMillis();
        HeavyObject heavyObject = new HeavyObject();
        for(int i = 0; i < 10; i ++) {
            // 通过clone获取新的对象
            HeavyObject cloneHeavyObject = (HeavyObject) heavyObject.clone();
            System.out.println(cloneHeavyObject);
        }
        long l2 = System.currentTimeMillis();
        System.out.println(l1 - l2);
    }
}

此时测试结果为1000ms，耗时主要在为初次构造HeavyObject 实例时构造方法耗费，而且结果中，只打印了一次HeavyObject 构造方法中的"HeavyObject init success"可以印证这一点，可见使用clone创建对象实例时没有调用构造方法，实际上是通过二进制流的方式只能读取源数据并生成新的对象（Object中的native方法）；
原型模式创建实例的方式看起来简单而美好，但是有时候也是有些小坑的。比如我们的HeavyObject 中有List成员变量

public class HeavyObject implements Cloneable {

    List list;

    public List getList() {
        return list;
    }

    public void setList(List list) {
        this.list = list;
    }

   // ... 省略重复代码

而我们使用的业务场景是这样的

public class PrototypeTest {

    public static void main(String[] args) throws CloneNotSupportedException {
        HeavyObject heavyObject = new HeavyObject();
        List list = new ArrayList();
        list.add(1);
        heavyObject.setList(list);
        // 通过clone拷贝对象
        HeavyObject cloneHeavyObject = (HeavyObject) heavyObject.clone();
        // 模拟业务场景，对clone的对象中的list进行操作
        cloneHeavyObject.getList().remove(0);
        System.out.println(heavyObject.getList());
    }

执行结果

HeavyObject init success
[]

Process finished with exit code 0

可见，对clone对象成员变量进行操作，影响了原对象。我们在最后一行打断点，看一下

image.png

上面的原对象和下面的clone对象的成员变量list，指向的对象都是ArrayList@455，所以造成操作clone对象的List而影响了原对象，这种拷贝对象的方式，也被成为浅拷贝，浅拷贝就是将原对象直接拷贝一份，原对象中的成员变量的指针当然也拷贝过来，所以该例中的两个对象的list仍旧指向同一个对象；怎么解决呢？其实jdk早给给我们了答案，我们翻看一下ArrayList，发现它也实现了Cloneable接口的，然后看下其clone()

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);
        }
    }

ArrayList答题实现思路是将ArrayList本身拷贝后，将其成员变量elementData ，通过Arrays方法重写拷贝一份赋值，我们尝试把HeavyObject的clone()这么改，即新创建一个List对象

@Override
    protected Object clone() throws CloneNotSupportedException {
        HeavyObject cloneHeavyObject = (HeavyObject) super.clone();
        cloneHeavyObject.list = new ArrayList(this.list);
        return cloneHeavyObject;
    }

在执行测试方法结果

HeavyObject init success
[1]

Process finished with exit code 0

上面这种，除了拷贝对象本身以为，还将对象中其他对象也拷贝一份新的对象，也就是我们常说的深拷贝。其实上例实现的深拷贝，也是有问题的，比如List承载的元素依旧是引用类型，而我的拷贝方式是直接将原List中的对象拿过来加到新的List中，所以虽然List对象是新创建的，但其中元素依旧指向同一个对象，所以业务有需求时应继续给List中对象也继续拷贝一份新的。