设计模式——原型模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述原型（Prototype）模式的：原型模式属于对象的创建模式。通过给出一个原型对象来指明所有创建的对象的类型，然后用复制这个原型对象的办法创建出更多同类型的对象。这就是选型模式的用意。

原型模式属于创建型模式，创建型模式一般都是通过new来创建一个新对象，然后调用对象的相关操作。原型模式通过提供具有复制能力的clone方法来快速创建一个对象，在创建复杂对象的时候，可以快速创建对象。

原型模式的使用场景

1. 类的创建需要消耗大量的资源时，比如需要初始化大量的数据、占用过多的硬件资源时候，我们可以通过原型拷贝的形式来避免这些消耗；
2. 当一个类对象需要被共享操作时；因为各个调用者都可能修改操作对象，可以考虑用原型模式拷贝多个对象来操作。
3. 通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。

原型模式的UML图

PrototypePattern.png

组成角色

• 抽象原型接口（IPrototype）：定义一组具备clone能力的接口标准。
• 具体的原型类（ConcreteProtoType）：实现抽象原型接口的具体原型类。
• 客户端：客户端用户。

案例场景
这里假设有个档案库，档案库有很多管理员都可以随时查看管理学生的信息，新增学生联系方式。

定义原型接口和具体的接口实现类

/**
 * 定义一个具备clone能力的抽象接口
 * @author Iflytek_dsw
 *
 */
abstract class Prototype {
    protected String name;
    protected ArrayList<String> telephoneList;
    
    public Prototype(String name){
        this.name = name;
        telephoneList = new ArrayList<>();
    }
    
    public void addTelephone(String telephone){
        telephoneList.add(telephone);
    }
    
    public void printTele(){
        for(String tele : telephoneList){
            System.out.println(tele);
        }
    }
    //具备克隆能力的接口
    public abstract Prototype clone();
}

/**
 * 具体实现类，
 * @author Iflytek_dsw
 *
 */
class StudentPrototype extends Prototype{

    public StudentPrototype(String name) {
        super(name);
    }

    @Override
    public Prototype clone() {
        StudentPrototype prototype = new StudentPrototype(name);
        prototype.name = name;
        prototype.telephoneList = telephoneList;
        return prototype;
    }
}

/**
 * 具体原型实现类
 * @author Iflytek_dsw
 *
 */
class TeacherPrototype extends Prototype{

    public TeacherPrototype(String name) {
        super(name);
    }

    @Override
    public Prototype clone() {
        TeacherPrototype prototype = new TeacherPrototype(name);
        prototype.name = name;
        prototype.telephoneList = telephoneList;
        return prototype;
    }
}

定义客户端使用

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        Prototype prototype = new StudentPrototype("小李");
        prototype.addTelephone("152000000");
        prototype.addTelephone("152111111");
        System.out.println("原始类型值：");
        prototype.printTele();
        
        Prototype prototypeClone = prototype.clone();
        prototypeClone.addTelephone("1530000");
        System.out.println("Clone类型值：");
        prototypeClone.printTele();
        
        System.out.println("原始类型修改后值：");
        prototype.printTele();
    }
}

我们来看下具体的运行结果：

原始类型值：
152000000
152111111
Clone类型值：
152000000
152111111
1530000
原始类型修改后值：
152000000
152111111
1530000

通过上面可以看到，我们通过clone方法创建的对象经过操作后，它的值会响应它的原型。在某些场景下这种方式就把原型数据破坏了。在上面的clone方法中，我们直接将telephoneList变量直接赋值给克隆的对象，本质上这里只是将克隆对象的telephoneList只是原型的一个引用，我们没有通过new重新创建，所以telephoneList在内存中的地址只有一个、副本和原型都是公用的，所以副本之间的操作会影响原型。这种方式就被称之为“浅拷贝”。

原型模式是设计模式中非常简单的一个模式，它的核心问题就是关于clone方法对原始对象的拷贝，对象拷贝(Object Copy)就是将一个对象的属性拷贝到另一个有着相同类类型的对象中去。在程序中拷贝对象是很常见的，主要是为了在新的上下文环境中复用对象的部分或全部数据。这里需要注意两种拷贝方式：浅拷贝和深拷贝。

浅拷贝和深拷贝

浅拷贝
浅拷贝是按位拷贝对象，它会创建一个新对象，新对象有着一份原始对象属性值的精确拷贝。如果属性是基本类型(比如基本数据类型、String类型)，拷贝的就是基本类型的值；如果属性是内存地址（引用类型，对象），拷贝的就是内存地址 ，因此如果其中一个对象改变了这个地址，就会影响到另一个对象。常见的方式：

• 变量直接赋值

深度拷贝
深拷贝会拷贝所有的属性,并拷贝属性指向的动态分配的内存。当对象和它所引用的对象一起拷贝时即发生深拷贝。深拷贝相比于浅拷贝速度较慢并且花销较大。常见的实现方式：

• 通过new创建类、成员变量的新对象；
• 通过序列化实现深拷贝，序列化将整个对象图写入到一个持久化存储文件中并且当需要的时候把它读取回来, 这意味着当你需要把它读取回来时你需要整个对象图的一个拷贝。这就是当你深拷贝一个对象时真正需要的东西。请注意，当你通过序列化进行深拷贝时，必须确保对象图中所有类都是可序列化的。序列化这种方式有其自身的限制和问题：1、无法序列化transient变量, 使用这种方法将无法拷贝transient变量。2、太浪费效率，速度太慢。

上面我们介绍了自定义原型接口实现Clone方法，我们知道在Java中所有类都是集成Object实现，而Object类提供protected Object clone()方法对对象进行复制，子类当然也可以把这个方法置换掉，提供满足自己需要的复制方法。对象的复制有一个基本问题，就是对象通常都有对其他的对象的引用。当使用Object类的clone()方法来复制一个对象时，此对象对其他对象的引用也同时会被复制一份

Java语言提供的Cloneable接口只起到在运行时期通知Java虚拟机可以安全地在这个类上使用clone()方法。通过调用这个clone()方法可以得到一个对象的复制。由于Object类本身并不实现Cloneable接口，因此如果所考虑的类没有实现Cloneable接口时，调用clone()方法会抛出CloneNotSupportedException异常。

克隆满足的条件

clone()方法将对象复制了一份并返还给调用者。所谓“复制”的含义与clone()方法是怎么实现的。一般而言，clone()方法满足以下的描述：

1. 对任何的对象x，都有：x.clone()!=x。换言之，克隆对象与原对象不是同一个对象。
2. 对任何的对象x，都有：x.clone().getClass() == x.getClass()，换言之，克隆对象与原对象的类型一样。
3. 如果对象x的equals()方法定义其恰当的话，那么x.clone().equals(x)应当成立的。

在JAVA语言的API中，凡是提供了clone()方法的类，都满足上面的这些条件。JAVA语言的设计师在设计自己的clone()方法时，也应当遵守着三个条件。一般来说，上面的三个条件中的前两个是必需的，而第三个是可选的。

总结

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

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

那么，如果上面的场景改成：每个人都可以查看备份档案，但是原型不受副本影响，该怎么改呢？^~。