[工作中的设计模式]原型模式prototype

一、模式解析

　　提起prototype，最近看多了js相关的内容，第一印象首先是js的原型

var Person=function(name){
    this.name=name;
}
Person.prototype.run=function(){
  alert(this.name+" is running";  
}

　　此处的原型是js的特殊定义，在原型上定义的属性和方法所有的类进行共享。

　　不过设计模式中的原型模式指的是：将已有的对象作为原型，拷贝出一份具有相同属性的新的对象。

　　模式定义为：原型模式要求对象实现一个可以“克隆”自身的接口，这样就可以通过复制一个实例对象本身来创建一个新的实例。这样一来，通过原型实例创建新的对象，就不再需要关心这个实例本身的类型，只要实现了克隆自身的方法，就可以通过这个方法来获取新的对象，而无须再去通过new来创建。

　　原型模式的实现主要有两种：1、继承接口clonable，实现类的拷贝，2、继承接口Serializable，将原实例序列化，然后解序列化生成新的对象。

　　针对第一种拷贝，又分为深拷贝和浅拷贝。

　　浅拷贝：实例中基本对象类型进行拷贝，引用对象类型仅拷贝引用地址，引用对象中的数据变化，会导致源对象和拷贝对象内容同时发生变化。

　　深拷贝：除基本对象类型外，引用对象类型也会一一拷贝其内部的的数据，从而使源对象变化不会引起拷贝对象变化。

二、模式代码

浅拷贝实例：

import java.util.ArrayList;
import java.util.List;

public class Prototype implements Cloneable {
    public String name;//普通数据类型
    public List<String> list =new ArrayList<String>();//list集合，引用数据类型
    public Prototype(String name){
        this.name=name;
    }
    
    @Override
    public Object clone(){
        try {
            return super.clone();
        } catch (CloneNotSupportedException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
            return null;
        }
    }
}

package prototype.patten;

public class Client {
    public static void main(String[] args) {
        Prototype p1=new Prototype("zhangsan");
        p1.list.add("a");
        p1.list.add("b");
        Prototype p2=(Prototype) p1.clone();
        p1.name="lisi";
        System.out.println("p1.name=="+p1.name);//p1.name==lisi
        System.out.println("p2.name=="+p2.name);//p2.name==zhangsan
        
        p2.list.add("c");
        System.out.println(p1.list.toString());//[a, b, c]
        System.out.println(p2.list.toString());//[a, b, c]
        
    }
}

可以看到基本类型name已经完全不同，p1的变化与p2无关，但list的变化仍然相关，p1增加元素会导致p2同时增加。

 

深拷贝实例：

package prototype.patten;

class Person implements Cloneable{
    public String name;
    @Override
    protected Person clone() throws CloneNotSupportedException {
        // TODO Auto-generated method stub
        return (Person)super.clone();
    }
}

public class DeepPrototype implements Cloneable {
    public Person person;
    public int count;
    
    @Override
    protected DeepPrototype clone() throws CloneNotSupportedException {
        DeepPrototype prototype=(DeepPrototype) super.clone();
        prototype.person=this.person.clone();//内部的引用类型分别执行clone方法
        
        return prototype;
    }
    
}

public class Client {
    public static void main(String[] args) throws CloneNotSupportedException {
        DeepPrototype prototype=new DeepPrototype();
        Person person=new Person();
        person.name="张三";
        prototype.person=person;
        prototype.count=10;
        DeepPrototype p2=prototype.clone();
        prototype.person.name="李四";
        prototype.count=11;
        System.out.println("prototype.person.name=="+prototype.person.name);//prototype.person.name==李四
        System.out.println("p2.person.name=="+p2.person.name);        //p2.person.name==张三
        System.out.println("prototype.count=="+prototype.count);    //    prototype.count==11
        System.out.println("p2.count=="+p2.count);//p2.count==10
        
    }
}

可以看到，深拷贝的重点是在clone方法中，所有引用对象类型要执行clone的方法，深拷贝完成后，源对象和新对象的所有属性具有无关性。

因为真的引用对象也要执行clone的方法，ArrayList等方法引用了clonable和Serializable等方法，因此同意可以实现深拷贝

 

序列化深克隆

 public  Object deepClone() throws IOException, ClassNotFoundException{
        //将对象写到流里
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        //从流里读回来
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }

只要实现了接口Serializable，均可以编写此方法，然后通过调用方法完成深克隆，无需考虑参数类型。

三、模式应用场景

　　在工作中目前还没有主动使用clone方法实现对象的创建，序列化方式的保存和复制对象在系统日志等非接化数据中进行使用，不过并非原型模式。

　　接触的比较接近与模板方式应用的例子是jquery源码中类的继承使用，由于jquery没有直接的继承方法，因此有与多人开发了如原型继承，混合继承的方法，jquery使用的是对象拷贝继承，可以根据参数选择，实现深拷贝或浅拷贝，算上原型模式的实例化最接近的例子。

四、模式代码

jQuery.extend = jQuery.fn.extend = function() {
    var src, copyIsArray, copy, name, options, clone,
        target = arguments[0] || {},
        i = 1,
        length = arguments.length,
        deep = false;

    // Handle a deep copy situation
    if ( typeof target === "boolean" ) {
        deep = target;
        target = arguments[1] || {};
        // skip the boolean and the target
        i = 2;
    }

    // Handle case when target is a string or something (possible in deep copy)
    if ( typeof target !== "object" && !jQuery.isFunction(target) ) {
        target = {};
    }

    // extend jQuery itself if only one argument is passed
    if ( length === i ) {
        target = this;
        --i;
    }

    for ( ; i < length; i++ ) {
        // Only deal with non-null/undefined values
        if ( (options = arguments[ i ]) != null ) {
            // Extend the base object
            for ( name in options ) {
                src = target[ name ];
                copy = options[ name ];

                // Prevent never-ending loop
                if ( target === copy ) {
                    continue;
                }

                // Recurse if we're merging plain objects or arrays
                if ( deep && copy && ( jQuery.isPlainObject(copy) || (copyIsArray = jQuery.isArray(copy)) ) ) {
                    if ( copyIsArray ) {
                        copyIsArray = false;
                        clone = src && jQuery.isArray(src) ? src : [];

                    } else {
                        clone = src && jQuery.isPlainObject(src) ? src : {};
                    }

                    // Never move original objects, clone them
                    target[ name ] = jQuery.extend( deep, clone, copy );

                // Don't bring in undefined values
                } else if ( copy !== undefined ) {
                    target[ name ] = copy;
                }
            }
        }
    }