I walk very slowly, but I never walk backwards 

设计模式 - 原型模式（下）

​ 寂然

大家好~，我是寂然，本节课呢，我们对原型模式进行深入一点的讨论，我们来聊聊深拷贝和浅拷贝

前情提要

上节课，我们聊了聊小李求职的事情，写了一个关于原型模式的案例，大家有没有发现，我们使用原型模式创建类 Resume 的对象时，类 Resume 的属性，都是 String 类型，换而言之，都是简单类型，那假设，现在增加了一个属性，简历上需要有一个证明人，是 Witness 类型的对象，那大家一起来思考这样一个问题，当再次进行原型拷贝的时候，属性 witness 会怎么去处理呢？是复制一份，还是让一个引用去指向已有的 witness？觉知此事要躬行，下面，我们通过案例代码来进行测试

案例演示

//简历类
public class Resume implements Cloneable{

    private String name;

    private String position;

    private String salary;

    public Witness witness; //证明人
    
    //构造器/get/set/toString...省略
}

//证明人类
public class Witness {

    private String name;

    private String job; //职务
    
    //构造器/get/set/toString...省略
}

//使用原型模式测试
public class Client {

    public static void main(String[] args) {

        Resume resume = new Resume("小李", "海淀区", "面议");

        resume.setWitness(new Witness("三叔","养猪场CTO"));

        Resume clone = (Resume)resume.clone(); //使用原型模式克隆两份

        Resume clone1 = (Resume)resume.clone();

        Resume clone2 = (Resume)resume.clone();

        System.out.println(clone.getWitness().hashCode()); //测试

        System.out.println(clone1.getWitness().hashCode());
        
        System.out.println(clone2.getWitness().hashCode());

    }
}

可以看到，我们使用原型模式克隆了三份，发现三个成员变量 witness 的哈希值是相同的，也就是说，默认并没有对属性 witness 进行拷贝，而是通过一个引用去指向已有的 witness，这种情况就称为浅拷贝

浅拷贝

下面，我们来一起看一下浅拷贝的介绍

对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，就是将该属性值复制一份给新的对象

---

对于数据类型是引用数据类型的成员变量，比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象，实际上两个对象的该成员变量都指向同一个实例，这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值

所以，我们前面讲的小李求职的案例就是浅拷贝，浅拷贝就是使用默认的 clone() 方法实现的

那如果说，实际情况中，我们希望对于数据类型是引用数据类型的成员变量，也复制一份呢？那对比着再来聊一下深拷贝，以及深拷贝的实现方式

深拷贝

深拷贝的基本介绍如下

复制对象的所有基本数据类型的成员变量值

为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象可达的所有对象，也就是说，对象进行深拷贝要对整个对象（包括对象的引用类型）进行拷贝

深拷贝在实际开发中有两种实现方式，一种是通过重写 clone () 方法实现，一种是通过对象序列化实现

实现方式一：重写 clone() 方法

示例代码如下图所示

public class DeepCloneableTarget implements Serializable, Cloneable {

    private static final long serialVersionUID = 1L;

    private String cloneName;

    private String cloneClass;

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

    //因为该类的属性都是String,所以我们使用默认的clone方法完成即可
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}


public class DeepProtoType implements Serializable, Cloneable {

    private String name; //String类型

    private DeepCloneableTarget deepCloneableTarget; //引用类型

    public DeepProtoType() {
        super();
    }

    //深拷贝 - 方式一：重写clone方法
    @Override
    protected Object clone() throws CloneNotSupportedException {

        Object deep = null;

        //这里完成的是对基本数据类型以及String类型的拷贝
        deep = super.clone();

        //对引用类型的属性进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;

        deepProtoType.deepCloneableTarget= (DeepCloneableTarget) deepCloneableTarget.clone();


        return deepProtoType;
    }
}

public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        DeepProtoType deepProtoType = new DeepProtoType();

        deepProtoType.name = "小李";

        deepProtoType.deepCloneableTarget = new DeepCloneableTarget("老李","克隆类");

        //方式一完成深拷贝
        DeepProtoType clone = (DeepProtoType) deepProtoType.clone();

        DeepProtoType clone1 = (DeepProtoType) deepProtoType.clone();

        System.out.println(clone.deepCloneableTarget.hashCode());

        System.out.println(clone1.deepCloneableTarget.hashCode()); //哈希值不一样
        
    }
}

可以看到，经测试，哈希值不一样，说明确实整个对象（包括对象的引用类型）都进行了拷贝 ，实现了深拷贝

重写 clone() 方法完成深拷贝的思路就是，分步进行，在 clone() 方法里，首先调用 super.clone() 完成对基本类型和 String 类型的拷贝，因为对于基本数据类型的成员变量，深拷贝和浅拷贝的处理方式一致，都是将该属性值复制一份给新的对象，接着我们对引用类型的属性进行单独处理，同样使用 clone() 方法完成属性值的拷贝

那这样有的小伙伴要问了，如果 DeepProtoType 有很多个引用类型的成员属性，都要这样挨个使用 clone() 方法完成属性值的拷贝嘛？是的，这种情况下，每个引用类型需要单独处理，那还有的小伙伴问了，如果引用类型是个类，里面仍然有引用类型的成员属性呢？

级联处理演示

如果引用类型是个class，类型，里面仍然有引用类型的成员属性同样，核心思想是分布单独处理，假设类 DeepProtoType 里有成员属性 deepCloneableTarget ，而DeepCloneableTarget 类中有成员属性 witness ，同样使用方式一，重写 clone() 方法完成深拷贝，示例代码如下图所示

//方式一升级：测试级联克隆
public class DeepProtoType implements Serializable, Cloneable {

    public String name; //String类型

    public DeepCloneableTarget deepCloneableTarget; //引用类型

    public DeepProtoType() {
        super();
    }

    //深拷贝 - 方式一：重写clone方法  级联

    @Override
    protected Object clone() throws CloneNotSupportedException {

        Object deep = null;

        //这里完成的是对基本数据类型以及String类型的拷贝
        deep = super.clone();

        //对引用类型的属性进行单独处理
        DeepProtoType deepProtoType = (DeepProtoType) deep;

        deepProtoType.deepCloneableTarget= (DeepCloneableTarget) deepCloneableTarget.clone();

        deepProtoType.deepCloneableTarget.witness = (Witness) deepProtoType.deepCloneableTarget.witness.clone();

        return deepProtoType;
    }

    @Override
    public String toString() {
        return "DeepProtoType{" +
                "name='" + name + '\'' +
                ", deepCloneableTarget=" + deepCloneableTarget +
                '}';
    }
}


public class DeepCloneableTarget implements Serializable, Cloneable {

    private static final long serialVersionUID = 1L;

    private String cloneName;

    private String cloneClass;

    public Witness witness; //增加引用类型

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

    //因为该类的属性都是String,所以我们使用默认的clone方法完成即可
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "DeepCloneableTarget{" +
                "cloneName='" + cloneName + '\'' +
                ", cloneClass='" + cloneClass + '\'' +
                ", witness=" + witness +
                '}';
    }
}

//证明人类
public class Witness implements Serializable,Cloneable {

    private String name;

    private String job; //职务

    public Witness(String name, String job) {
        this.name = name;
        this.job = job;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getJob() {
        return job;
    }

    public void setJob(String job) {
        this.job = job;
    }

    @Override
    public String toString() {
        return "Witness{" +
                "name='" + name + '\'' +
                ", job='" + job + '\'' +
                '}';
    }

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

//方式一升级：测试级联克隆
public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        DeepProtoType deepProtoType = new DeepProtoType();

        deepProtoType.name = "小李";

        deepProtoType.deepCloneableTarget = new DeepCloneableTarget("老李","克隆类");

        deepProtoType.deepCloneableTarget.witness = new Witness("证明人", "职务");

        DeepProtoType clone = (DeepProtoType) deepProtoType.clone();

        DeepProtoType clone1 = (DeepProtoType) deepProtoType.clone();

        System.out.println(clone);

        System.out.println(clone1);

        System.out.println(clone.deepCloneableTarget.witness.hashCode());

        System.out.println(clone1.deepCloneableTarget.witness.hashCode());
        //测试哈希值不一样  实现了深拷贝

    }
}

实现方式二：通过对象序列化

上面我们演示了方式一，实现了深拷贝，但同时也带来了问题，如果有很多个引用类型的成员属性，或者说（引用类型是个类，里面仍然有引用类型的成员属性）这种级联的情况，需要分步处理，如果要拷贝的对象结构复杂，实现起来非常繁琐，那有没有可以一步到位的方法呢？下面我们来演示第二种，使用对象序列化的形式，示例代码如

下图所示

public class DeepProtoType implements Serializable, Cloneable {

    public String name; //String类型

    public DeepCloneableTarget deepCloneableTarget; //引用类型

    public DeepProtoType() {
        super();
    }

    //深拷贝 - 方式二：通过对象序列化（推荐的）
    public Object deepClone(){

        //创建流对象
        ByteArrayOutputStream bos = null;

        ObjectOutputStream oos = null;

        ByteArrayInputStream bis = null;

        ObjectInputStream ois = null;

        try {
            //序列化
            bos = new ByteArrayOutputStream();

            oos = new ObjectOutputStream(bos);

            oos.writeObject(this);//将当前对象，以对象流的方式输出(即序列化)
            //输出的时候会把包括引用类型一起输出

            //反序列化
            bis = new ByteArrayInputStream(bos.toByteArray());//把输出去的对象再读进来

            ois = new ObjectInputStream(bis);

            DeepProtoType clone = (DeepProtoType)ois.readObject();
            //充分利用序列化和反序列化的特点，把当前对象this以对象流的方式输出去，然后以对象的方式再读回来，关联的引用类型自然也读回来了

            return clone;

        } catch (Exception e) {

            e.getMessage();

        } finally {

            //关闭流操作
            try {
                bos.close();
                
                oos.close();
                
                bis.close();
                
                ois.close();
                
            } catch (IOException e) {

                e.getMessage();

            }
        }

        return null;
    }

    @Override
    public String toString() {
        return "DeepProtoType{" +
                "name='" + name + '\'' +
                ", deepCloneableTarget=" + deepCloneableTarget +
                '}';
    }
}

public class DeepCloneableTarget implements Serializable, Cloneable {

    /**
     * 
     */
    private static final long serialVersionUID = 1L;

    private String cloneName;

    private String cloneClass;

    public DeepCloneableTarget(String cloneName, String cloneClass) {
        this.cloneName = cloneName;
        this.cloneClass = cloneClass;
    }

    //因为该类的属性都是String,所以我们使用默认的clone方法完成即可
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    @Override
    public String toString() {
        return "DeepCloneableTarget{" +
                "cloneName='" + cloneName + '\'' +
                ", cloneClass='" + cloneClass + '\'' +
                '}';
    }
}

// 测试 方式二 通过对象序列化
public class Client {

    public static void main(String[] args) throws CloneNotSupportedException {

        DeepProtoType deepProtoType = new DeepProtoType();

        deepProtoType.name = "小李";

        deepProtoType.deepCloneableTarget = new DeepCloneableTarget("老李","克隆类");

        DeepProtoType clone = (DeepProtoType)deepProtoType.deepClone();

        DeepProtoType clone1 = (DeepProtoType)deepProtoType.deepClone();

        System.out.println(clone.toString());

        System.out.println(clone1.toString());

        System.out.println(clone.deepCloneableTarget.hashCode());

        System.out.println(clone1.deepCloneableTarget.hashCode()); //测试哈希值不一致
    }
}

可以看到，经测试，哈希值不一样，说明确实整个对象（包括对象的引用类型）都进行了拷贝 ，我们通过对象序列化的方式也实现了深拷贝，而且利用序列化和反序列化的特点，把当前对象this以对象流的方式输出去，然后以对象的方式再读回来，关联的引用类型的属性值自然也读回来了，这种方式是推荐大家使用的，因为是直接把当前整个对象进行序列化和反序列化操作，那不管类的结构如何复杂，都可以通过对象序列化的方式整体处理

注意事项

原型模式到这里就告一段落了，下面我们一起来总结下原型模式的注意事项，分析下优劣势以及应用场景

优势

创建新的对象比较复杂时，可以利用原型模式简化对象的创建过程，同时也可以提高效率

不用重新初始化对象，而是动态地获得对象运行时的状态

如果原始对象发生变化（增加或者减少属性），其它克隆对象的也会发生相应的变化，无需修改代码

劣势

需要为每一个类配备一个克隆方法，这对全新的类来说不是很难，但对已有的类进行改造时，需要修改其源代码，会违背 ocp 原则，这点需要和小伙伴们提一下

下节预告

OK， 下一节我们进入下一个模式 - 建造者模式的学习，希望大家在学习的过程中，能够感觉到设计模式的有趣之处，高效而愉快的学习，那我们下期见~