使程序运行更高效 - 原型模式

原型模式是一个创建型的模式。原型二字表明了该模式应该有一个样板实例，用户从这个样板对象中复制处一个内部属性一致的对象，这个过程也就是我们俗称的“克隆”。被克隆的实例就是我们所称的“原型”，这个原型是可定制的。原型模式多用于创建复杂的或者构造耗时的实例，因为这种情况下，复制一个已经存在的实例可使程序运行更高效。

定义

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

原型模式的使用场景

1. 类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗。
2. 通过new产生一个对象需要非常繁琐的数据准备或访问权限，这时可以使用原型模式。
3. 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。

需要注意的是，通过实现Cloneable 接口的原型模式在调用clone 函数构造实例时并不一定比通过new操作速度快，只有当通过new构造对象较为耗时或者说成本较高时，通过clone方法才能够获得效率上的提升。因此，在使用Cloneable 时需要考虑构建对象的成本以及做一些效率上的测试。当然，实现原型模式也不一定非要实现Cloneable 接口，也有其他的实现方式，本章将会对这些一一说明。

原型模式的UML类图

• Client：客户端用户
• Prototype：抽象类或者接口，声明具备clone 能力
• ConcretePrototype：具体的原型类

原型模式的简单实现

下面以简单的文档拷贝为例来演示一下简单的原型模式，我们在这个例子中首先创建了一个文档对象，即WordDocument，这个文档中含有文字和图片。用户经过了很长时间的内容编辑后，打算对该文档做进一步的编辑，但是，这个编辑后的文档是否会被采用还不确定，因此，为了安全起见，用户需要将当前文档拷贝一份，然后再在文档副本上进行修改，这与《Effective Java》一书中提到的保护性拷贝有些类似，如此，这个原始文档就是我们上述所说的样板实例，也就是将要被“克隆”的对象，我们称之为原型：

/**
 * 文档类型，扮演的是ConcretePrototype角色，而cloneable是代表prototype角色
 */
public class WordDocument implements Cloneable {
    //文本
    private String mText;
    //图片名列表
    private ArrayList<String> mImages = new ArrayList<String>();

    public WordDocument() {
        System.out.println("----WordDocument 构造函数----");
    }

    @Override
    protected WordDocument clone() {
        try {
            WordDocument doc = (WordDocument)super.clone();
            doc.mText = this.mText;
            doc.mImages = this.mImages;
            return doc;
        }catch (Exception e){
        }
        return null;
    }

    public String getText() {
        return mText;
    }

    public void setText(String mText) {
        this.mText = mText;
    }

    public List<String> getImages() {
        return mImages;
    }

    public void addImage(String img) {
        this.mImages.add(img);
    }

    /**
     * 打印文档内容
     */
    public void showDocument() {
        System.out.println("----Word Content Start ----");
        System.out.println("Text :" + mText);
        System.out.println("Images List: ");
        for(String imageName : mImages) {
            System.out.println("image name: " + imageName);
        }
        System.out.println("----Word Content End ----");
    }
}

通过WordDocument类模拟类Word文档中的基本元素，即文字和图片。WordDocument 在该原型模式示例中扮演的角色为ConcretePrototype，而Clonebale的角色则为Prototype。WordDocument中的clone方法泳衣实现对象克隆。注意，这个方法并不是Cloneable接口中的，而是Object中的方法。Cloneable 也是一个标示接口，它表明这个类的对象是可拷贝的。如果没有实现Cloneable接口却调用了clone函数将抛出异常。在这个示例中，我们通过实现Cloneable接口和覆写clone方法实现原型模式。

下面看看Client端的使用：

public class Client {
    public static void main(String[] args) {
        //1. 构建文档对象
        WordDocument originDoc = new WordDocument();
        //2. 编辑文档，添加图片等
        originDoc.setText("这是一篇文档");
        originDoc.addImage("图片1");
        originDoc.addImage("图片2");
        originDoc.addImage("图片3");
        originDoc.showDocument();

        // 以原始文档为原型，拷贝一份副本
        WordDocument doc2 = originDoc.clone();
        doc2.showDocument();
        //修改文档副本，不会影响原始文档
        doc2.setText("这是修改过的Doc2");
        doc2.showDocument();

        originDoc.showDocument();
    }
}

输出结果如下：

----WordDocument 构造函数----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是修改过的Doc2
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----

从上图中可以看到，doc2是通过originDoc.clone()创建的，并且doc2第一次输出的时候和originDoc输出是一样的，即doc2是originDoc 的一份拷贝，他们的内容是一样的，而doc2修改了文本内容以后并不会影响originDoc 的文本内容，这就保证了originDoc的安全性。还需要注意的是，通过clone拷贝对象时并不会执行构造函数！因此，如果在构造函数中需要一些特殊的初始化操作的类型，在使用Cloneable实现拷贝时，需要注意构造函数不会执行的问题。

浅拷贝和深拷贝

上述原型模式的实现实际上只是一个浅拷贝，也称为影子拷贝，这份拷贝实际上并不是将原始文档的所有字段都重新构造了一份，而是副本文档的字段引用原始文档的字段，如下图所示：

我们知道A引用B就是说两个对象指向同一个地址，当修改A时B也会改变，B修改时A同样会改变。我们直接看下面的例子，将main函数的内容修改为如下：

public static void main(String[] args) {
    //1. 构建文档对象
    WordDocument originDoc = new WordDocument();
    //2. 编辑文档，添加图片等
    originDoc.setText("这是一篇文档");
    originDoc.addImage("图片1");
    originDoc.addImage("图片2");
    originDoc.addImage("图片3");
    originDoc.showDocument();

    // 以原始文档为原型，拷贝一份副本
    WordDocument doc2 = originDoc.clone();
    doc2.showDocument();
    //修改文字和图片
    doc2.setText("这是修改过的Doc2");
    doc2.addImage("haha.jpg");
    doc2.showDocument();

    originDoc.showDocument();
}

输出结果如下：

----WordDocument 构造函数----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是修改过的Doc2
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
image name: haha.jpg
----Word Content End ----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
image name: haha.jpg
----Word Content End ----

细心的读者可能发现了，最后两个文档信息输出是一致的。我们在doc2添加了一张名为“haha.jpg”的图片，但是，同时也显示在originDoc中了，这是怎么回事呢？学习过C++的读者都会有比较深刻的体会，这是因为上文中WordDocument的clone方法中只是简单地进行浅拷贝，引用类型的新对象doc2的mImages只是单纯地指向了this.mImages引用，并没有重新构造一个mImages对象，然后将原始文档中的图片添加到新的mImages对象中，这样就导致doc2中的mImages与原始文档中的是同一个对象，因此修改了其中一个文档中的图片，另一个文档也会受印象。doc2的mImages添加了新的图片，实际上也就是往originDoc里添加了新的图片，所以，originDoc里面也有"haha.jpg"图片文件。那如何解决这个问题呢？答案就是采用深拷贝，即在拷贝对象时，对于引用型的字段也要采用拷贝的形式，而不是单纯引用的形式。clone方法修改如下：

/**
 * 克隆对象
 */
@Override
protected WordDocument clone() {
    try {
        WordDocument doc = (WordDocument)super.clone();
        doc.mText = this.mText;
        doc.mImages = (ArrayList<String>)this.mImages.clone();
        return doc;
    }catch (Exception e){
    }
    return null;
}

如上述代码所示，将doc.mImages指向this.mImages的一份拷贝，而不是this.mImages本身，这样在doc2添加图片时并不会影响originDoc，运行效果如下：

----WordDocument 构造函数----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----
----Word Content Start ----
Text :这是修改过的Doc2
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
image name: haha.jpg
----Word Content End ----
----Word Content Start ----
Text :这是一篇文档
Images List: 
image name: 图片1
image name: 图片2
image name: 图片3
----Word Content End ----

原型模式是非常简单的一个模式，它的核心问题就是对原始对象进行拷贝，在这个模式的使用过程中需要注意的一点就是：深、浅拷贝的问题。在开发过程中，为了减少错误，建议大家在使用该模式时尽量使用深拷贝，避免操作副本时影响原始对象的问题。

总结

原型模式本质上就是对象拷贝，与C++中的拷贝构造函数有些类似，他们之间容易出现的问题也都是深拷贝、浅拷贝。使用原型模式可以解决构建复杂对象的资源消耗问题，能够在某些场景下提升创建对象的效率。还有一个重要的用途就是保护性拷贝，也就是某个对象对外可能是只读的，为了防止外部对这个只读对象进行修改，通过可以通过返回一个对象拷贝的形式实现只读的限制。

优点与缺点

优点

原型模式是在内存中二进制流的拷贝，要不直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。

缺点

这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的，在实际开发当中应该注意这个潜在的问题。优点就是减少了约束，缺点也是减少了约束，需要大家在实际应用时考虑。

本文转载自《Android源码设计模式解析与实战》一书，手敲一遍，加深印象。原作者在这