设计模式-原型模式

原型模式的UML类图

原型模式的实现

对于只需部分修改的对象，重新构造比克隆性能销毁更大。如若某个对象是来自对数据库的读取，那么每次构造该对象需要消耗较大的性能。在java中通过使用Clonable接口，并重写clone()方法来实现浅拷贝。

1、Prototype抽象类

public abstract class Prototype implements Cloneable{
	private String id;
	public Prototype(String id){
		this.id = id;
	}
	
	public String getId(){
		return this.id;
	}
	
	public Object clone(){
		Object obj = null;
		try {
			obj = super.clone();
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return obj;
	}
}

2、ConcretePrototype

public class ConcretePrototype extends Prototype {
	public ConcretePrototype(String id) {
		super(id);
	}
}

3、Cache缓存，从数据库中读取到的信息

import java.util.Hashtable;
public class Cache {
	private static Hashtable<String, Prototype> cacheTable = new Hashtable<String, Prototype>();
	
	public static Prototype getPrototype(String id){
		//克隆
		return (Prototype)cacheTable.get(id).clone();
	}

	public static void loadCache(){
		//在数据库中读取到信息构造成对象加入到缓存
		Prototype proto = new ConcretePrototype("a");
		cacheTable.put(proto.getId(), proto);
	}
}

4、Client客户端

public class Main {
	public static void main(String[] args) throws CloneNotSupportedException {
		Cache.loadCache();//缓存读取
		Prototype proto = Cache.getPrototype("a");
		System.out.println(proto.getId());
	}
}

原型模式的优缺点与使用场景

以下来自RUNOOB
优点： 1、性能提高。 2、逃避构造函数的约束。

缺点： 1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。 2、必须实现 Cloneable 接口。

使用场景： 1、资源优化场景。 2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。 3、性能和安全要求的场景。 4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。 5、一个对象多个修改者的场景。 6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。 7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。

深拷贝与浅拷贝

前面介绍了原型模式，是基于浅拷贝的，但在多少情况下，浅拷贝是不能满足需求的，若对象中引用了其他对象，那么引用的对象是不会被拷贝的。若在引用的对象中也加入clone()方法（需要使用Clonable接口），下面介绍一种java中常用的深拷贝方法：

在内存中通过字节流的拷贝是比较容易实现的。把母对象写入到一个字节流中，再从字节流中将其读出来，这样就可以创建一个新的对象了，并且该新对象与母对象之间并不存在引用共享的问题，真正实现对象的深拷贝。

1、将被拷贝的两个对象

import java.io.Serializable;
public class A implements Serializable{
	private String content = null;
	public void setContent(String content){
		this.content = content;
	}
	
	public String getContent(){
		return this.content;
	}
}

import java.io.Serializable;
public class B implements Serializable{
	public int id;
	private A a = null;
	public B(A a){
		this.a = a;
	}
	public void setId(int id){
		this.id = id;
	}
	public int getId(){
		return this.id;
	}
	public A getA(){
		return a;
	}
}

2、使用字节流序列化方法进行深拷贝

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.Serializable;


public class CloneUtil {
	public static <T extends Serializable> T clone(T obj){
		T cloneObj = null;
		try {
			ByteArrayOutputStream baos = new ByteArrayOutputStream();
			ObjectOutputStream oos = new ObjectOutputStream(baos);
			oos.writeObject(obj);
			oos.close();
			
			ByteArrayInputStream bais = new ByteArrayInputStream(baos.toByteArray());
			ObjectInputStream ois = new ObjectInputStream(bais);
			cloneObj = (T) ois.readObject();
			ois.close();
			
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return cloneObj;
	}
}

3、测试客户端

public class Main {
	public static void main(String[] args) throws CloneNotSupportedException {
		A a1 = new A();
		a1.setContent("a_1");
		B b1 = new B(a1);
		b1.setId(1);
		
		B b2 = CloneUtil.clone(b1);
		b2.getA().setContent("a_2");
		b2.setId(2);
		
		System.out.println("b1" + b1.getId() + "," + a1.getContent());
		System.out.println("b2" + b2.getId() + "," + b2.getA().getContent());		
	}
}

输出结果：
b11,a_1
b22,a_2

很明显的是，这里b2和b1不是引用的同一个A对象。