设计模式之原型模式（浅拷贝与深拷贝详解，以及通过对象序列化实现深拷贝）

一、概述

1、定义

        Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.（用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象）

2、通用类图

3、基本介绍

1. 原型模式是指：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象；
2. 原型模式是一种创建型设计模式，允许一个对象再创建另外一个可定制的对象，无需知道如何创建的细节；
3. 工作原理：通过将一个原型对象传给那个要发动创建的对象，这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建，即：对象.clone().

二、通用源码

        原型模式的核心是clone方法，通过该方法进行对象的拷贝。在java中提供了一个Cloneable接口来标识这个对象是可拷贝的，一个对象要变得可拷贝，只需要实现Cloneable接口，并重写clone方法即可。

public class PrototypeClass implements Cloneable {

    @Override
    public Object clone() {
        PrototypeClass prototype=null;
        try {
            prototype= (PrototypeClass) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return prototype;
    }
}

main方法中的简单调用：

	PrototypeClass prototype=new PrototypeClass();//产生一个对象
    PrototypeClass prototypeClass= (PrototypeClass) prototype.clone();//克隆一个对象

三、原型模式的应用

1、优点

1. 性能优良：原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多；
2. 逃避构造函数的约束：直接在内存中拷贝，构造函数是不会执行的。这个既是优点，也是缺点；
3. 不用重新初始化，，可以动态的获得对象运行时的状态；

注：Object类的clone方法的原理是从内存中（具体的说是堆内存）以二进制流的方式进行拷贝，重新分配一个内存块。

2、缺点

        需要为每一个类配备一个克隆方法，这对全新的类来说并不很难，但对已有的类进行改造时，违背了OCP原则。

3、使用场景

1. 资源优化场景：类初始化需要大量资源时，包括数据资源、硬件资源等；
2. 性能和安全要求的场景：通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；
3. 一个对象多个修改者的场景：一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。

四、浅拷贝

1、浅拷贝介绍

1. 对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象；
2. 对于数据类型是引用类型的成员变量，比如:数组、类的对象等，那么浅拷贝会进行引用传递，也就是只将该成员变量的引用值（内存地址）复制一份给新的对象。因此两个对象的成员变量都指向同一个实例。这种情况下，在一个对象中修该成员变量会影响到另一个对象的成员变量值。
3. 浅拷贝使用默认的clone()方法来实现。

在这里使用一个图来加深一下理解，在下图中A对象有3个成员变量a,b,c，通过clone得到B对象，在这个过程中，a和b作为基本数据类型直接被复制了一份，而c是一个引用对象，只是复制一份c的元素地址给B对象，并没有拷贝一个新的c。

注：使用原型模式时，引用的成员变量满足两个条件才不会被拷贝：

1. 作为类的成员变量，而不是方法内变量；
2. 必须是一个可变的引用对象，而不是一个原始类型或不可变对象。

五、深拷贝

1、基本介绍

1. 复制对象的所有基本数据类型的成员变量值；
2. 为所有引用数据类型的成员变量申请存储空间，并复制每个引用数据类型成员变量所引用的对象，直到该对象，直到该对象可达的所有对象。也就是说：对象进行深拷贝要对整个对象进行拷贝。

2、深拷贝实现方式：

1. 重写clone()方法来实现深拷贝；
2. 通过对象序列化实现深拷贝。

2.1、通过重写clone()方法来实现深拷贝

public class DeepPrototype implements Cloneable {

    private String name;//基本数据类型
    private DeepCloneableTarget target;//引用类型

    public DeepPrototype(){
        super();
    }

    //深拷贝：使用clone方法
    @Override
    public Object clone() throws CloneNotSupportedException {
        Object deep=null;
        //完成对基本数据类型String类型的克隆
        deep=super.clone();
        //对引用类型的属性进行单独处理
        DeepPrototype deepPrototype= (DeepPrototype) deep;
        deepPrototype.target= (DeepCloneableTarget) target.clone();

        return deepPrototype;
    }

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

    public String getName() {
        return name;
    }

    public void setTarget(DeepCloneableTarget target) {
        this.target = target;
    }

    public DeepCloneableTarget getTarget() {
        return target;
    }
}

public class DeepCloneableTarget implements Cloneable {

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

之后我们可以通过在main方法中输出克隆前和克隆后的hashcode来判断深拷贝是否成功。代码和运行结果如下：

		DeepPrototype p=new DeepPrototype();
        p.setName("曹操");
        p.setTarget(new DeepCloneableTarget("曹孟德","曹阿瞒"));

        //clone方法完成深拷贝
        DeepPrototype p2= (DeepPrototype) p.clone();
        //输出克隆前后的两个对象的hashcode，若不一样则深拷贝成功
        System.out.println(p.getName()+":"+p.getTarget().hashCode());
        System.out.println(p2.getName()+":"+p2.getTarget().hashCode());

2.2、通过对象序列化来实现深拷贝

实现 Serializable接口，主要代码如下所示：

public class DeepPrototype implements Serializable{

    private String name;
    private DeepCloneableTarget target;

    public DeepPrototype(){
        super();
    }
    //深拷贝：通过对象的序列化实现
    public Object deepClone(){
        DeepPrototype copyObj=null;//要克隆的对象
        //创建流对象
        ByteArrayOutputStream bos=null;
        ByteArrayInputStream bis=null;
        ObjectOutputStream oos=null;
        ObjectInputStream ois=null;

        try {
            //序列化
            bos=new ByteArrayOutputStream();
            oos=new ObjectOutputStream(bos);
            oos.writeObject(this);//将当前这个对象以对象流的方式输出

            //反序列化
            bis=new ByteArrayInputStream(bos.toByteArray());
            ois=new ObjectInputStream(bis);
            copyObj= (DeepPrototype) ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }finally {
            try {
            	//关闭流
                bis.close();
                bos.close();
                oos.close();
                ois.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
        return copyObj;
    }

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

    public String getName() {
        return name;
    }

    public void setTarget(DeepCloneableTarget target) {
        this.target = target;
    }

    public DeepCloneableTarget getTarget() {
        return target;
    }
}


public class DeepCloneableTarget implements Serializable{

    private String cloneName;
    private String cloneClass;

    //构造器
    public DeepCloneableTarget(String cloneName,String cloneClass){
        this.cloneName=cloneName;
        this.cloneClass=cloneClass;
    }
}

我们同样可以通过输出hashCode来判断是不是完成了深拷贝。
注：
1. 浅拷贝是有风险的，尤其是涉及到引用数据类型时；
2. 深拷贝和浅拷贝建议不要混合使用，特别是在涉及类的继承的时候；
3. clone与final是冲突的，要使用clone方法，类的成员变量上就不要增加final关键字。