原型模式（Prototype Pattern）

定义

用一个已经创建的实例作为原型，通过复制该原型对象来创建一个和原型相同或相似的新对象。

在这里，原型实例指定了要创建的对象的种类。用这种方式创建对象非常高效，根本无须知道对象创建的细节。

属于创建型模式。

结构

主要角色：

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

优点

原型模式是在内存中二进制流的拷贝，要比直接new一个对象性能好很多,

特别是要在一个循环体内产生大量的对象时,原型模式可以更好的体现其优点。

简化了创建过程。

缺点

这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的，在实际开发当中应该注意这个潜在的问题。优点就是减少了约束，缺点也是减少了约束，这就需要我们在实际应用中考虑怎么合理的使用原型模型。

必须配备克隆（或者可拷贝）方法。

对克隆复杂对象或对克隆出的对象进行复杂改造时，易带来风险。 深拷贝、浅拷贝要运用得当。

应用场景

• 类初始化消耗资源较多。
• new产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）。
• 循环体中生产大量对象时，可读性下降。
• 对象之间相同或相似，即只是个别的几个属性不同的时候。
• 对象的创建过程比较麻烦，但复制比较简单的时候。

实现

由于 Java 提供了对象的 clone() 方法，所以用 Java 实现原型模式很简单。

JDK提供的实现Cloneable接口，实现快速复制。

原型模式的克隆分为浅克隆和深克隆。克隆（复制）在Java中是一种常见的操作，目的是快速获取一个对象副本。

浅克隆

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

深克隆

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

总之深浅克隆都会在堆中新分配一块区域，区别在于对象属性引用的对象是否需要进行克隆（递归性的）。

案例

用原型模式模拟“齐天大圣”复制自己。

分析：

• Java 中的 Cloneable 接口是抽象原型类。
• 齐天大圣QiTianDaSheng类是具体原型类。
• 齐天大圣 先是猴子，有一个金箍棒。

先来创建一个猴子Monkey类：

/**
 * @description: 猴子
 * @author: liuzhangcheng
 **/
public class Monkey {
    // 身高
    private int height;
    // 体重
    private int weight;

    // 出生时间
    private LocalDateTime date;

   // getter setter
}

再来一个金箍棒JinGuBang类：

public class JinGuBang implements Serializable {
    // 长度
    private int length;

    // 重量
    private int weight;

    public JinGuBang(int length, int weight) {
        this.length = length;
        this.weight = weight;
    }

    // getter setter
}

最后创建一个齐天大圣QiTianDaSheng，继承Monkey，实现Cloneable，因为需要进行深克隆，也实现了Serializable

// 实现抽象原型类：Cloneable 的 clone方法
// Serializable序列化支持，可进行深拷贝
public class QiTianDaSheng extends Monkey implements Cloneable, Serializable {

    private JinGuBang jinGuBang;

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

    /**
     * 深克隆
     * @return
     */
    public QiTianDaSheng deepClone() {
        try{
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);

            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);

            QiTianDaSheng copy = (QiTianDaSheng)ois.readObject();
            copy.setDate(LocalDateTime.now());

            return copy;
        }catch (Exception e){
            e.printStackTrace();
            return null;
        }
    }

    // 浅克隆
    public QiTianDaSheng shallowClone() {
        QiTianDaSheng copy = new QiTianDaSheng();
        copy.jinGuBang = this.jinGuBang;
        copy.setWeight(this.getWeight());
        copy.setHeight(this.getHeight());

        copy.setDate(LocalDateTime.now());

        return copy;
    }

    public JinGuBang getJinGuBang() {
        return jinGuBang;
    }

    public void setJinGuBang(JinGuBang jinGuBang) {
        this.jinGuBang = jinGuBang;
    }
}

测试代码：

public class DeepPrototypeTest {
    public static void main(String[] args) {
        QiTianDaSheng prototype = new QiTianDaSheng();
        prototype.setWeight(140);
        prototype.setHeight(180);
        prototype.setDate(LocalDateTime.now());
        prototype.setJinGuBang(new JinGuBang(234, 111));

        try {
            QiTianDaSheng prototypeClone = (QiTianDaSheng) prototype.clone();

            System.out.println("原型对象：" + prototype);
            System.out.println("克隆对象：" + prototypeClone);
            System.out.println("原型对象引用JiGuBang对象地址：" + prototype.getJinGuBang());
            System.out.println("克隆对象引用JiGuBang对象地址：" + prototypeClone.getJinGuBang());
            // 结果为false
            System.out.println("原型与克隆对象引用List对象地址比较：" + (prototype.getJinGuBang() == prototypeClone.getJinGuBang()));

        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
    }
}

打印结果：

原型对象：design.pattern.prototype.deep.QiTianDaSheng@58372a00
克隆对象：design.pattern.prototype.deep.QiTianDaSheng@5fd0d5ae
原型对象引用JiGuBang对象地址：design.pattern.prototype.deep.JinGuBang@4dd8dc3
克隆对象引用JiGuBang对象地址：design.pattern.prototype.deep.JinGuBang@2d98a335
原型与克隆对象引用List对象地址比较：false

显而易见深克隆引用JiGuBang对象地址不一样了。

那如果我们用浅克隆进行测试,将测试代码中的clone()方法换成shallowClone() ：

QiTianDaSheng prototypeClone = (QiTianDaSheng) prototype.shallowClone();

浅克隆测试的打印结果：

浅克隆：
原型对象：design.pattern.prototype.deep.QiTianDaSheng@3d075dc0
克隆对象：design.pattern.prototype.deep.QiTianDaSheng@214c265e
原型对象引用JiGuBang对象地址：design.pattern.prototype.deep.JinGuBang@448139f0
克隆对象引用JiGuBang对象地址：design.pattern.prototype.deep.JinGuBang@448139f0
原型与克隆对象引用List对象地址比较：true

浅克隆引用JiGuBang对象地址一样。

克隆破坏了单例模式

如果我们克隆的目标的对象是单例对象，那意味着，深克隆就会破坏单例。

实际上防止克隆破坏单例解决思路非常简单，禁止深克隆便可。

要么你我们的单例类不实现 Cloneable 接口；

要么我们重写 clone()方法，在 clone 方法中返回单例对象即可。

Cloneable源码分析

先看我们常用的 ArrayList 就实现了 Cloneable 接口，来看代码 clone()方法的实现：

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            // Arrays.copyOf 把内部的元素一个一个的迭代，再进行赋值
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // this shouldn't happen, since we are Cloneable
            throw new InternalError(e);
        }
    }
}

Arrays.copyOf()方法进行跟踪：

public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }