设计模式（三）——原型模式 Craftsman

一、引子

1、克隆人的问题

　　问题：有一个人叫张三，姓名：张三，年龄：18，身高：178。如何创建和张三属性完全相同的10个人呢？
　　代码示例：

public class Main {

    public static void main(String[] args) {
        Person p0 = new Person("张三", 18, 178);

        Person p1 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p2 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p3 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p4 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p5 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p6 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p7 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p8 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p9 = new Person(p0.getName(), p0.getAge(), p0.getHeight());
        Person p10 = new Person(p0.getName(), p0.getAge(), p0.getHeight());

        System.out.println(JSON.toJSONString(p0));
    }
}

class Person {
    private String name;
    private int age;
    private int height;
    // getter & setter
    // 有参数、无参构造器
}

　　这样创建的问题显而易见：如果Person类有100个属性呢？如果要创建和张三属性完全相同的100个人呢？

二、原型模式

1、介绍

　　原型模式（Prototype）：用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象，无需知道创建的细节。简单来说就是复制一个和已知对象一模一样的对象。
　　方式：实现 Cloneable 接口，复写 Object 类的 clone() 方法。该方法可以将一个 Java 对象复制一份，但调用该方法的类必须实现Cloneable接口，这是一个标志接口，标识该类能够复制且具有复制的能力。如果不实现 Cloneable 接口，直接调用 clone() 方法，会抛出 CloneNotSupportedException 异常。
　　源码示例：Object.clone()

protected native Object clone() throws CloneNotSupportedException;

　　这是一个本地方法，具体实现细节，不需要了解，由操作系统实现。只需要知道它的作用就是复制对象，产生一个新的对象。

2、解决克隆人的问题

　　代码示例：实现Cloneable接口，复写clone()方法。

public class Main {

    public static void main(String[] args) {
        Person p0 = new Person("张三", 18, 178);

        final Person p1 = p0.clone();

        System.out.println(JSON.toJSONString(p1));
        System.out.println(p0 == p1);
    }
}

class Person implements Cloneable {
    private String name;
    private int age;
    private int height;

    @Override
    public Person clone() {
        Person person = null;
        try {
            person = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }

    // getter & setter
    // 有参数、无参构造器
}

// 结果
{"age":18,"height":178,"name":"张三"}
false

　　从结果可以看出，复制了一个和张三一模一样的人。

三、深拷贝与浅拷贝

1、介绍

　　在 Java 中有两种数据类型：基本类型和引用类型。
　　基本类型，也称为值类型，有八大基本数据类型：byte、short、int、long、float、double、char、boolean。注：String并不是基本数据类型。
　　引用类型，有数组、类、接口、枚举等。

　　浅拷贝：只复制基本数据类型，以及引用类型的引用。
　　深拷贝：复制基本数据类型，以及引用类型的引用，和引用对象的实例。

　　如图所示：克隆"张三"。
　　浅拷贝，只会克隆张三的基本属性，如姓名，年龄，身高等，不会克隆他的狗，他两共用这只狗。
　　深拷贝，除了克隆张三，还会克隆他的狗，他两分别独立拥有各自的狗。

2、浅拷贝

　　上述在解决克隆人的问题上，其实就是一种浅拷贝。接下来，假设张三拥有一只狗，叫"旺财"。
　　代码示例：

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        Person p0 = new Person("张三", 18, 178, dog);

        final Person p1 = p0.clone();

        // 修改p0 张三的狗的名字为 大黄
        p0.getDog().setName("大黄");

        System.out.println(JSON.toJSONString(p1));
    }
}

class Person implements Cloneable {
    private String name;
    private int age;
    private int height;
    private Dog dog; // 引用类属性

    @Override
    public Person clone() {
        Person person = null;
        try {
            person = (Person) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
    // getter & setter
    // 有参数、无参构造器
}

class Dog {
    private String name;
    // getter & setter
    // 有参数、无参构造器
}

// 结果
{"age":18,"dog":{"name":"大黄"},"height":178,"name":"张三"}

　　问题：从结果可以看出，修改了张三的狗的名字，克隆张三的狗的名字也改变了。原因是他两指向的是同一只狗。也就是说对象经过克隆后，只是复制了其引用，其指向的还是同一块堆内存空间，当修改其中一个对象的属性，另一个也会跟着变化。

3、深拷贝

　　如果就想要，在克隆张三后，他两各自拥有自己独立的狗，怎么办呢？就要用到深拷贝。
　　实现方式一：让引用类属性也具备可拷贝性。
　　代码示例：让Dog同样具备可拷贝性

public class Main {

    public static void main(String[] args) {
        Dog dog = new Dog("旺财");
        Person p0 = new Person("张三", 18, 178, dog);

        final Person p1 = p0.clone();

        // 修改p0 张三的狗的名字为 大黄
        p0.getDog().setName("大黄");

        System.out.println(JSON.toJSONString(p1));
        System.out.println(JSON.toJSONString(p0));
    }
}

class Person implements Cloneable {
    private String name;
    private int age;
    private int height;
    private Dog dog; // 引用类属性

    @Override
    public Person clone() {
        Person person = null;
        try {
            // 1.先克隆一个人
            person = (Person) super.clone();

            // 2.再克隆一条狗,并让这个狗属于这个人.
            person.dog = this.dog.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return person;
    }
    // getter & setter
    // 有参数、无参构造器
}

class Dog implements Cloneable {
    private String name;

    @Override
    public Dog clone() {
        Dog dog = null;
        try {
            dog = (Dog) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return dog;
    }
    // getter & setter
    // 有参数、无参构造器
}

// 结果
{"age":18,"dog":{"name":"旺财"},"height":178,"name":"张三"}
{"age":18,"dog":{"name":"大黄"},"height":178,"name":"张三"}

　　问题：从结果可以看出，他两各自拥有了独立的狗。这种方式，确实实现了对象的深拷贝。但是有一个问题，如果Dog类还有引用类属性，也需要同样让其具备可拷贝性，嵌套太深的话，很不利于代码的扩展性。
　　一般推荐使用方式二来实现。
　　实现方式二：序列化。对序列化不了解的，可以先看这篇，对象流。
　　代码示例：序列化

public class Main {

    public static void main(String[] args) throws Exception {
        Dog dog = new Dog("旺财");
        Person p0 = new Person("张三", 18, 178, dog);
        // 序列化
        ObjectOutputStream output = new ObjectOutputStream(new FileOutputStream("temp.dat"));
        output.writeObject(p0);

        // 反序列化
        ObjectInputStream input = new ObjectInputStream(new FileInputStream("temp.dat"));
        final Person p1 = (Person) input.readObject();

        // 修改p0 张三的狗的名字为 大黄
        p0.getDog().setName("大黄");

        System.out.println(JSON.toJSONString(p1));
        System.out.println(JSON.toJSONString(p0));
    }
}

class Person implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    private int age;
    private int height;
    private Dog dog; // 引用类属性
    // getter & setter
    // 有参数、无参构造器
}

class Dog implements Serializable {
    private static final long serialVersionUID = 1L;
    private String name;
    // getter & setter
    // 有参数、无参构造器
}

　　注意：因为使用了序列化，引用类属性，要想序列化，也需要具备可序列化。
　　代码示例：优化，可抽取为一个工具类

public class CloneUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepClone(T obj) {
        T cloneObj = null;
        try {
            // 写入字节流
            ByteArrayOutputStream out = new ByteArrayOutputStream();
            ObjectOutputStream obs = new ObjectOutputStream(out);

            obs.writeObject(obj);
            obs.close();

            // 分配内存，写入原始对象，生成新对象
            ByteArrayInputStream ios = new ByteArrayInputStream(out.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(ios);

            cloneObj = (T) ois.readObject();
            ois.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
        return cloneObj;
    }
}

4、优点

　　性能高：原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以很好地体现其优点。
　　避免构造函数的约束：这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的，优点就是减少了约束， 缺点也是减少了约束，需要在实际应用时考虑使用。

四、原型模型在框架中的应用