[工作中的设计模式]原型模式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;
}
}
}
}