创建型设计模式——原型模式

定义

原型模式是一个创建型的设计模式。用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。
原型模式多用于创建复杂的或者构造耗时的实例，通过克隆已有的对象来创建的新的对象，从而节省时间和内存。

关键点

• 原型模式是一种创建模式
• 原型模式适用于构建较复杂，耗时较长的对象
• 原型模式不经过构造方法
• 使用原型模式区分好深拷贝和浅拷贝
• 对于简单的对象，不建议使用的原型模式

原型模式UML图

• Client 客户端类调用的类
• Prototype 提供clone()等方法的原型抽象接口
• ConcretePrototype 具体的原型的函数

原型模式分为浅拷贝和深拷贝，拷贝实际上并不是将原始文档的所有字段重新构造一份，而是副本文档的字段引用原始文档的字段。这时候如果成员有引用型对象时，浅拷贝后修改或者新增该引用型对象会将原型的内容修改，引起问题。因而建议在使用原型模式时候，尽量采用深拷贝，避免操作副本时影响原始对象的问题。

拷贝

使用场景

• 类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗。
• 通过new产生的一个对象需要非常繁琐的数据准备或者权限，这时可以使用原型模式。
• 一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
• 注：通过实现Cloneable接口的原型模式在调用clone方法构造实例时并不一定比通过new操作速度快，只有当通过new构造对象较为耗时或者成本比较高的时候，通过clone方法才能获得效率上的提升。
  实现原型模式也不一定非要实现Cloneable接口。

场景例子说明

在进行简单的文档拷贝过程中，首先创建一个文档对象，文档包含文字、图片。用户进行一系列编辑后，打算对该文档进行进一步编辑，但是不确定这个编辑后的文档是否会被确定，因而想做一个备份，然后在副本上进行修改。从而保证了初始编辑的原始文档，和进一步编辑后的副本文档。以下用代码进行说明：

/**
 * WordDoc扮演的角色既是具体的原型类，其中接口Cloneable代表的角色是原型类
 * WordDoc中的clone方法以实现对象克隆
 */
public class WordDoc implements Cloneable {
    private String text;//文本
    private ArrayList<String> images = new ArrayList<>();//图片

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

    @Override
    protected Object clone() throws CloneNotSupportedException {
        WordDoc doc = (WordDoc) super.clone();
        doc.text = this.text;
        doc.images = this.images;
        return doc;
    }

    public String getText() {
        return text;
    }

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

    public ArrayList<String> getImages() {
        return images;
    }

    public void addImage(String imgName) {
        this.images.add(imgName);
    }

    public void show() {
        System.out.println("Text:" + text);
        System.out.println("Images List:");
        for (String imgName : images) {
            System.out.println("image name :" + imgName);
        }
        System.out.println("---------------------------");
    }
}

//测试
public class WordTest {
    public static void main(String[] args) {
        //构建文档对象
        WordDoc doc = new WordDoc();
        //编辑文档，添加图片等操作
        doc.setText("原型文档");
        doc.addImage("图片1");
        doc.addImage("图片2");
        doc.addImage("图片3");

        //拷贝副本
        WordDoc doc2 = null;
        try {
            doc2 = (WordDoc) doc.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //副本文档编辑
        doc2.setText("这是拷贝后的文档");
        //原型和副本内容展示
        doc.show();
        doc2.show();
    }
}

//结果
------WordDoc构造函数------
Text:原型文档
Images List:
image name :图片1
image name :图片2
image name :图片3
---------------------------
Text:这是拷贝后的文档
Images List:
image name :图片1
image name :图片2
image name :图片3
---------------------------

• 从上面的结果我们可以知道，通过clone拷贝对象时并不会执行构造函数，因此如果在构造函数中需要一些特殊的初始化操作类型，使用Cloneable实现拷贝的时候，需要注意构造函数不会执行的问题。
• 注：上述的WordDoc类中， clone方法并不是Cloneable接口中的，而是Object中的方法。但是Cloneable是一个标识接口，表面这个类的对象是可以被拷贝的，如果没有实现该接口，调用clone方法时会抛异常。

如果将上述部分代码增加doc2.addImage("拷贝后的图片");

public class WordTest {
    public static void main(String[] args) {
        //构建文档对象
        WordDoc doc = new WordDoc();
        //编辑文档，添加图片等操作
        doc.setText("原型文档");
        doc.addImage("图片1");
        doc.addImage("图片2");
        doc.addImage("图片3");

        //拷贝副本
        WordDoc doc2 = null;
        try {
            doc2 = (WordDoc) doc.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        //副本文档编辑
        doc2.setText("这是拷贝后的文档");

        //******************增加的内容****************
        doc2.addImage("拷贝后的图片");

        //原型和副本内容展示
        doc.show();
        doc2.show();
    }
}

//结果
------WordDoc构造函数------
Text:原型文档
Images List:
image name :图片1
image name :图片2
image name :图片3
image name :拷贝后的图片
---------------------------
Text:这是拷贝后的文档
Images List:
image name :图片1
image name :图片2
image name :图片3
image name :拷贝后的图片
---------------------------

可以发现拷贝后的文档进行增加图片操作时，原型文档也增加了该图片。从上文关键点中已经说道过，拷贝实际上并不是将原始文档的所有字段重新构造一份，而是副本文档的字段引用原始文档的字段。这时候如果成员有引用型对象时，浅拷贝后修改或者新增该引用型对象会将原型的内容修改，引起问题。

上述代码其实是进行的浅拷贝操作

如果要进行深拷贝操作，那么在进行拷贝对象时，对于引用型的字段也要采用拷贝的形式，而不是单纯的进行引用。修改如下：

@Override
    protected Object clone() throws CloneNotSupportedException {
        WordDoc doc = (WordDoc) super.clone();
        doc.text = this.text;
        //**********************修改的地方**********************
        doc.images = (ArrayList<String>) this.images.clone();

        return doc;
    }

//结果
------WordDoc构造函数------
Text:原型文档
Images List:
image name :图片1
image name :图片2
image name :图片3
---------------------------
Text:这是拷贝后的文档
Images List:
image name :图片1
image name :图片2
image name :图片3
image name :拷贝后的图片
---------------------------

Android源码中的原型模式

在Android源码中，Intent用于跳转Activity、启动服务、发布广播等功能，它是Android系统各个组件之间的纽带，也是组件之间传递数据的载体，正是Intent的存在使得Android各个组件之间的耦合性很低，Android组件才能很灵活。
Intent也实现了原型模式，其 clone()方法如下

    @Override
    public Object clone() {
        return new Intent(this);
    }

    /**
     * Copy constructor.
     */
    public Intent(Intent o) {
        this.mAction = o.mAction;
        this.mData = o.mData;
        this.mType = o.mType;
        this.mPackage = o.mPackage;
        this.mComponent = o.mComponent;
        this.mFlags = o.mFlags;
        this.mContentUserHint = o.mContentUserHint;
        this.mLaunchToken = o.mLaunchToken;
        /*************
         *****这里面的引用类型都是重新new来进行拷贝的******
         ******/
        if (o.mCategories != null) {
            this.mCategories = new ArraySet<String>(o.mCategories);
        }
        if (o.mExtras != null) {
            this.mExtras = new Bundle(o.mExtras);
        }
        if (o.mSourceBounds != null) {
            this.mSourceBounds = new Rect(o.mSourceBounds);
        }
        if (o.mSelector != null) {
            this.mSelector = new Intent(o.mSelector);
        }
        if (o.mClipData != null) {
            this.mClipData = new ClipData(o.mClipData);
        }
    }

从上述代码可以知道，clone方法实际上在内部并没有调用super.clone()方法来实现对象拷贝，而是调用的new Intent(this)。

将原始对象作为构造函数的参数，然后在构造函数内将原始对象的数据逐个拷贝一遍。

使用clone和new需要根据构造对象的成本来决定，如果对象的构造成本比较高或者构造较为麻烦，那么使用clone()方法效率较高，否则可以使用new的形式。

原型模式的优缺点

优点：

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

缺点：

• 优点也是其缺点，直接在内存中拷贝，构造函数是不会执行的，这个问题在开发过程中需要进行考虑。
  
  
  
  
  

引用：
《Android源码设计模式解析与实战》
Android中的原型模式
Android开发中无处不在的设计模式——原型模式