原型模式-通过克隆创建对象

介绍

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

原型模式(Prototype Pattern)是一个比较简单的创建型设计模式，它的重点在于克隆，也就是将一个对象作为原型，对其进行复制、克隆，产生一个和原对象类似的新对象

原型模式类图

原型方法模式的角色及职责

• 客户(Client)：提出创建对象的请求，使用复制对象的方法创建新实例
• 抽象原型(Abstract Prototype)：定义所有的具体原型类所需的复制方法，接口或抽象类
• 具体原型(Concrete Prototype)：被克隆、复制的对象，此角色需要实现抽象的原型角色所要求的接口

原型模式通用类图

原型模式实现

在Java中实现原型模式特别简单，只要两步即可

• 实现Cloneable接口
• 重写clone()方法

public class PrototypeClass implements Cloneable{
    @Override
    protected PrototypeClass clone() throws CloneNotSupportedException {
        return (PrototypeClass)super.clone();
    }
}

原型模式已经与Java融为一体，Object类提供了一个clone()方法，且是native方法（本地原生方法，C/C++实现），所以所有类都可以通过重写Object的clone()方法或者调用clone()方法来实现对对象的克隆

不过要实现克隆的类还必须实现Cloneable接口，Cloneable是一个标识接口，表明该对象可以复制，如果没有实现该接口却调用Object的clone()方法，会抛出CloneNotSupportedException异常

我们再为上面的类添加一些成员变量，看一下再执行克隆方法的情况

public class PrototypeClass implements Cloneable{

    private String name;
    private List<String> list = new ArrayList<>();

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

    public String getName() {
        return name;
    }

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

    public List<String> getList() {
        return list;
    }

    public void setList(List<String> list) {
        this.list = list;
    }
    
    @Override
    public String toString() {
        return "[name: " + name + ", list: " + list.toString() + "]";
    }
}

测试

@Test
public void test() throws CloneNotSupportedException {
    PrototypeClass p1 = new PrototypeClass();
    p1.setName("zhangsan");
    p1.getList().add("zhangsan");
    System.out.println("p1 " + p1.toString());

    PrototypeClass p2 = p1.clone();
    p2.setName("lisi");
    p2.getList().add("lisi");
    System.out.println("p2 " + p2.toString());
    System.out.println("p1 " + p1.toString());
}

测试结果

p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan, lisi]]

从上面的结果我们可以发现，当我们对克隆对象p2的引用类型的成员变量进行修改时，p1的list变量也改变了，这说明原始对象和克隆对象的list变量指向的是同一个对象。为什么会这样呢？

原来clone()方法只是复制成员变量的值，也就是说如果成员变量是值类型（基本数据类型和String），会复制值，而如果是引用类型，则只会复制引用但不会复制引用所指向的对象，这种复制叫做浅复制。两个对象会共享一个私有的变量，大家都能修改，这是不安全的，那是不是还有更深入的复制呢？

浅复制和深复制

• 浅复制：将一个对象复制后，基本数据类型的变量都会重新创建，而引用类型，指向的还是原对象所指向的

• 深复制：将一个对象复制后，不论是基本数据类型还有引用类型，都是重新创建的。简单来说，就是深复制进行了完全彻底的复制，而浅复制不彻底

我们通过直接调用Object的clone()便可以实现浅复制，但是引用地址只是复制了它的引用，那么我们想复制它指向的对象，是不是可以对成员变量也调用clone()方法复制一遍

public class PrototypeClass implements Cloneable {

    private String name;
    private ArrayList<String> list = new ArrayList<>();

    @Override
    protected PrototypeClass clone() throws CloneNotSupportedException {
        PrototypeClass newPrototypeClass = (PrototypeClass) super.clone();
        newPrototypeClass.list = (ArrayList<String>) this.list.clone();
        return newPrototypeClass;
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<String> getList() {
        return list;
    }

    public void setList(ArrayList<String> list) {
        this.list = list;
    }

    @Override
    public String toString() {
        return "[name: " + name + ", list: " + list.toString() + "]";
    }
}

测试

@Test
public void test() throws CloneNotSupportedException {
    PrototypeClass p1 = new PrototypeClass();
    p1.setName("zhangsan");
    p1.getList().add("zhangsan");
    System.out.println("p1 " + p1.toString());

    PrototypeClass p2 = p1.clone();
    p2.setName("lisi");
    p2.getList().add("lisi");
    System.out.println("p2 " + p2.toString());
    System.out.println("p1 " + p1.toString());
}

测试结果

p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan]]

使用序列化实现深复制

使用序列化实现深复制，采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象

public class PrototypeClassSerialize implements Serializable {

    private String name;
    private ArrayList<String> list = new ArrayList<>();

    /**
     * 深复制 需要采用流的形式读入当前对象的二进制输入，再写出二进制数据对应的对象
     */
    public Object deepClone() throws IOException, ClassNotFoundException {
        // 将对象序列化到二进制流
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        // 从二进制流中读出产生的新对象
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

    public String getName() {
        return name;
    }

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

    public ArrayList<String> getList() {
        return list;
    }

    public void setList(ArrayList<String> list) {
        this.list = list;
    }

    @Override
    public String toString() {
        return "[name: " + name + ", list: " + list.toString() + "]";
    }
}

测试

@Test
public void test() throws IOException, ClassNotFoundException {
    PrototypeClassSerialize p1 = new PrototypeClassSerialize();
    p1.setName("zhangsan");
    p1.getList().add("zhangsan");
    System.out.println("p1 " + p1.toString());

    PrototypeClassSerialize p2 = (PrototypeClassSerialize) p1.deepClone();
    p2.setName("lisi");
    p2.getList().add("lisi");
    System.out.println("p2 " + p2.toString());
    System.out.println("p1 " + p1.toString());
}

测试结果

p1 [name: zhangsan, list: [zhangsan]]
p2 [name: lisi, list: [zhangsan, lisi]]
p1 [name: zhangsan, list: [zhangsan]]