JavaScript构建新对象及其原型用到原型设计模式详细剖析

一、概述

原型模式（Prototype Pattern）的简单程度仅次于单例模式和迭代器模式。正是由于简单，使用的场景才非常地多，其定义如下：

Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.

（用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

非常的简单，原型模式的核心就是一个clone方法，通过该方法进行对象的拷贝。Java提供了一个Cloneable接口来表示这个对象是可以被拷贝的。但是，为什么说是“标识”？

当我们打开JDK源码发现，Cloneable是一个方法都没有的，这个接口就是一个标识作用。在JVM中具有这个表示的对象才可能被拷贝。

那怎么才能从“有可能被拷贝”转换为“可以被拷贝”呢？方法是覆盖clone()方法，是的，你没有看错是重写clone()方法。

二、原型设计模式的结构与写法

1. 结构

原型模式包含如下角色：

• 抽象原型类：规定了具体原型对象必须实现的的 clone() 方法。
• 具体原型类：实现抽象原型类的 clone() 方法，它是可被复制的对象。
• 访问类：使用具体原型类中的 clone() 方法来复制新的对象。

我们可以定义的接口类图如下：

2. 实现

Cloneable 接口是上面的类图中的抽象原型类，而实现了Cloneable接口的子实现类就是具体的原型类。代码如下:

Realizetype（具体的原型类）：

public class Realizetype implements Cloneable{

    public Realizetype(){
        System.out.println("具体的原型对象创建完成");
    }

    // 这是一个克隆
    @Override
    protected Realizetype clone() throws CloneNotSupportedException {
        System.out.println("具体的原型对象复制成功!");
        return (Realizetype) super.clone();
    }
}

测试类

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        // 1. 创建一个原型对象
        Realizetype realizetype = new Realizetype();
        // 2. 调用Realizetype类中的clone方法进行对象的克隆
        Realizetype clone = realizetype.clone();
        // 3. 打印出来的不是同一个对象
        System.out.println(realizetype);
        System.out.println(clone);
    }
}

来看看结果：

首先，对于Realizetype 的构造方法只是调用了一次，说明，通过new创建对象的方式，我们只进行了一次。
而且打印出的对象不一致，所以，克隆成功。

3. 案例举例

假设有这样一个需求，用模型模式去克隆证书。
同一学校的“三好学生”奖状除了获奖人姓名不同，其他都相同，可以使用原型模式复制多个“三好学生”奖状出来，然后在修改奖状上的名字即可。

代码如下：

//奖状类
public class Citation implements Cloneable {
    private String name;
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getName() {
        return (this.name);
    }
​
    public void show() {
        System.out.println(name + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
    }
​
    @Override
    public Citation clone() throws CloneNotSupportedException {
        return (Citation) super.clone();
    }
}
​
//测试访问类
public class CitationTest {
    public static void main(String[] args) throws CloneNotSupportedException {
        Citation c1 = new Citation();
        c1.setName("张三");
​
        //复制奖状
        Citation c2 = c1.clone();
        //将奖状的名字修改李四
        c2.setName("李四");
​
        c1.show();
        c2.show();
    }
}

完全没问题。

三、原型模式中的深克隆和浅克隆

原型模式的克隆分为浅克隆和深克隆

• 浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

• 深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

而Java中的Object类中提供了clone() 方法来实现浅克隆。
举个例子：还是上面的示例，将上面的“三好学生”奖状的案例中Citation类的name属性修改为Student类型的属性。代码如下:

//奖状类
public class Citation implements Cloneable {
    private Student stu;
​
    public Student getStu() {
        return stu;
    }
​
    public void setStu(Student stu) {
        this.stu = stu;
    }
​
    void show() {
        System.out.println(stu.getName() + "同学：在2020学年第一学期中表现优秀，被评为三好学生。特发此状！");
    }
​
    @Override
    public Citation clone() throws CloneNotSupportedException {
        return (Citation) super.clone();
    }
}
​
//学生类
public class Student {
    private String name;
    private String address;
​
    public Student(String name, String address) {
        this.name = name;
        this.address = address;
    }
​
    public Student() {
    }
​
    public String getName() {
        return name;
    }
​
    public void setName(String name) {
        this.name = name;
    }
​
    public String getAddress() {
        return address;
    }
​
    public void setAddress(String address) {
        this.address = address;
    }
}
​
//测试类
public class CitationTest {
    public static void main(String[] args) throws CloneNotSupportedException {
​
        Citation c1 = new Citation();
        Student stu = new Student("张三", "西安");
        c1.setStu(stu);
​
        //复制奖状
        Citation c2 = c1.clone();
        //获取c2奖状所属学生对象
        Student stu1 = c2.getStu();
        stu1.setName("李四");
​
        //判断stu对象和stu1对象是否是同一个对象
        System.out.println("stu和stu1是同一个对象？" + (stu == stu1));
​
        c1.show();
        c2.show();
    }
}

发现，进行了克隆操作之后，对象里的非基本类型指向的还是同一个对象。

stu对象和stu1对象是同一个对象，就会产生将stu1对象中name属性值改为“李四”，两个Citation（奖状）对象中显示的都是李四。这就是浅克隆的效果，对具体原型类（Citation）中的引用类型的属性进行引用的复制。

解决浅克隆的方式有很多，这里我只是通过常见的一种方式，使用序列化和反序列化的方式来实现深克隆。

代码如下：

public class CitationTest {
    public static void main(String[] args) throws Exception {
        // 1. 创建原型对象
        Citation citation1 = new Citation();
        // 2. 创建一个people对象
        People people = new People();
        people.setName("zhangsan");
        citation1.setPeople(people);

        // 创建对象输出流
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("C:\\Users\\fangshaolei\\Desktop\\a.txt"));
        // 写对象
        oos.writeObject(citation1);
        // 释放资源
        oos.close();

        // 读取对象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("C:\\Users\\fangshaolei\\Desktop\\a.txt"));
        // 读取对象
        Citation citation2 = (Citation) ois.readObject();
        ois.close();

        citation2.getPeople().setName("wangwu");

        System.out.println(citation1.getPeople().getName());
        System.out.println(citation2.getPeople().getName());
    }
}

运行结果是：

说明，实现了深克隆。

四、总结

原型模式的使用场景适用于当对象的创建非常复杂的情况下，我们可以使用原型模式快捷的创建对象。或者是对性能和安全要求比较高。

优点是：
原型模式允许在运行时动态改变具体的实现类型。原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态地改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类

缺点是：
原型模式最主要的缺点是每一个类都必须配备一个克隆方法。配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类来说不是很难，而对于已经有的类不一定很容易，特别是当一个类引用不支持序列化的间接对象，或者引用含有循环结构的时候。

Notice: 本文的所有代码都已提交到GitHub仓库：原型设计模式（Prototype Pattern）-GitHub Link

---

参考：

设计模式之禅——原型模式的定义

《JAVA与模式》之原型模式

阎宏博士的《JAVA与模式》