JAVA设计模式之原型模式

1. 什么是原型模式？

原型模式（Prototype Pattern）用原型对象指定创建对象的种类，并且通过-拷贝这些原型来创建新的对象。

原型模式用于创建重复的对象，同时又能保证性能。原型模式属于创建型模式。

原型模式要求原型对象实现一个“克隆”自身的方法，通过调用这个方法来创建一个新的实例对象。

说到“克隆”就不得不提深克隆和浅克隆，请参考另一片文章《java克隆之深克隆和浅克隆》。

原型模式有两种不同的实现方式：（1）简单形式；（2）登记形式；

登记形式适用于原型对象有多个的情景，将原型对象的管理交给原型管理器（PrototypeManager），原型管理器对象中有一个Map专门用来保存已经创建的原型对象。

2. 角色

 

简单形式类图

 

登记形式类图

 

抽象原型角色（Prototype）：可以是一个抽象类或接口，主要定义原型类需要实现的接口方法，一般这个方法为“克隆”方法。

具体原型角色（ConcretePrototype）：提供抽象原型角色具体的实现。此角色是用来“克隆”复制的角色。

原型管理器角色（PrototypeManager）：此角色只有在登记形式的原型模式才有，主要用一个Map集合来管理ConcretePrototype类，将客户端从原型对象的创建中剥离开来，使客户端不用关心原型对象是如何被创建的。

3. 优点

（1）使用原型模式创建重复对象比用new关键之创建对象性能上要好得多，提高系统性能。

（2）简化对象的创建。

4. 缺点

（1）如果使用浅克隆方式实现原型模式，必须要求原型对象实现Cloneable 接口，如果某个原型对象没有实现Cloneable接口则会抛出CloneNotSupportedException异常。

（2）如果是采用深克隆实现原型模式，则必须要求所有原型对象支持序列化和反序列化，必须实现Serializable接口。如果某个原型不支持序列化，则不能通过此方式实现原形模式。

5. 使用场景

（1）系统重复创建相同对象时可以考虑使用原型模式。

（2）在一个循环体内创建相同对象可以考虑使用原型模式。

（3）通过new关键字创建对象需要复杂的前期准备时可以考虑使用原型模式。

6. 示例代码

    以下统一采用登记形式来实现原型模式，并提供“深克隆”和“浅克隆”两种写法。

6.1 浅克隆

（1）原型接口类

/**
 *原型公共接口
 */
public interface Prototype {
    public Prototype clone();
}

（2）具体原型类

/**
 * 具体的原型类A
 */
public class ConcretePrototypeA implements Prototype,Cloneable {

	private String name;
	private int age;
	
	public ConcretePrototypeA(String name,int age) {
		this.name=name;
		this.age=age;
	}

	@Override
	public Prototype clone() {
		Prototype prototype=null;
		try {
			prototype=(Prototype) super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return prototype;
	}

	@Override
	public String toString() {
		return "ConcretePrototypeA [name=" + name + ", age=" + age + "]";
	}
}

/**
 * 具体的原型类B
 */
public class ConcretePrototypeB implements Prototype,Cloneable {
	
	private float height;
	private float weight;

	public ConcretePrototypeB(float height,float weight) {
		this.height=height;
		this.weight=weight;
	}

	@Override
	public Prototype clone() {
		Prototype prototype=null;
		try {
			prototype=(Prototype) super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return prototype;
	}

	@Override
	public String toString() {
		return "ConcretePrototypeB [height=" + height + ", weight=" + weight + "]";
	}
}

 

（3）原型管理器类

/**
 * 原型管理类
 * 主要用于存在多个原型的情况下。
 */
public class PrototypeManager {

	private static HashMap<String, Prototype> prototypeMap=new HashMap<String,Prototype>();
	/**
	 * 获取某个具体原型的克隆对象
	 */
	public static Prototype getClone(String prototypeName){
		return prototypeMap.get(prototypeName).clone();
	}
	
	/**
	 * 初始化原型缓存，将所有原型对象都先初始化以待使用。
	 */
	public static void getPrototypeInstance(){
		Prototype A=new ConcretePrototypeA("leitao", 25);
		Prototype B=new ConcretePrototypeB(5f, 2.5f);
		prototypeMap.put("ConcretePrototypeA", A);
		prototypeMap.put("ConcretePrototypeB", B);
	}
}

（4）测试

public class Client {
	public static void main(String[] args) {
		//初始化原型对象
		PrototypeManager.getPrototypeInstance();
		//获得A对象的克隆对象
		ConcretePrototypeA A1=(ConcretePrototypeA) PrototypeManager.getClone("ConcretePrototypeA");
		ConcretePrototypeA A2=(ConcretePrototypeA) PrototypeManager.getClone("ConcretePrototypeA");
		System.out.println("A1="+A1+",A2="+A2);
		System.out.println("A1==A2:"+(A1==A2));
		System.out.println("----------------");
		
		//获得B对象的克隆对象
		ConcretePrototypeB B1=(ConcretePrototypeB) PrototypeManager.getClone("ConcretePrototypeB");
		ConcretePrototypeB B2=(ConcretePrototypeB) PrototypeManager.getClone("ConcretePrototypeB");
		System.out.println("B1="+B1+",B2="+B2);
		System.out.println("B1==B2:"+(B1==B2));
	}
}

 

（5）测试结果

A1=ConcretePrototypeA [name=leitao, age=25],A2=ConcretePrototypeA [name=leitao, age=25]
A1==A2:false
----------------
B1=ConcretePrototypeB [height=5.0, weight=2.5],B2=ConcretePrototypeB [height=5.0, weight=2.5]
B1==B2:false

6.2 深克隆

（1）原型接口类

/**
 *原型公共接口
 */
public interface Prototype {
    public Prototype clone();
}

（ 2 ）具体原型类

/**
 * person原型类
 */
public class Person implements Prototype,Serializable {

	private static final long serialVersionUID = 3426430684192068358L;

	private Phone phone;
	private String name;
	
	public Person(Phone phone, String name) {
		this.phone = phone;
		this.name = name;
	}

	public Phone getPhone() {
		return phone;
	}

	public void setPhone(Phone phone) {
		this.phone = phone;
	}

	public String getName() {
		return name;
	}

	public void setName(String name) {
		this.name = name;
	}

	@Override
	public Prototype clone() {
		Prototype prototype=null;
		try {
			ByteArrayOutputStream bos=new ByteArrayOutputStream();
			ObjectOutputStream oos=new ObjectOutputStream(bos);
			oos.writeObject(this);
			ByteArrayInputStream bis=new ByteArrayInputStream(bos.toByteArray());
			ObjectInputStream ois=new ObjectInputStream(bis);
			prototype=(Prototype) ois.readObject();
		} catch (IOException e) {
			e.printStackTrace();
		} catch (ClassNotFoundException e) {
			e.printStackTrace();
		}
		return prototype;
	}

	@Override
	public String toString() {
		return "Person [phone=" + phone + ", name=" + name + "]";
	}
}

/**
 * 手机原型类
 * 因为此处使用序列化实现深克隆，没有使用Object的clone，
 * 因此phone对象可以不用实现Prototype接口
 */
public class Phone implements Serializable{

	private static final long serialVersionUID = -2376123551216737075L;

	private String number;

	public Phone(String number) {
		this.number = number;
	}

	public String getNumber() {
		return number;
	}

	public void setNumber(String number) {
		this.number = number;
	}

	@Override
	public String toString() {
		return "Phone [number=" + number + "]";
	}
}

（3）原型管理器类

/**
 * 原型管理类
 * 主要用于存在多个原型的情况下。
 */
public class PrototypeManager {

	private static HashMap<String, Prototype> prototypeMap=new HashMap<String,Prototype>();
	/**
	 * 获取某个具体原型的克隆对象
	 */
	public static Prototype getClone(String prototypeName){
		return prototypeMap.get(prototypeName).clone();
	}
	
	/**
	 * 初始化原型缓存，将所有原型对象都先初始化以待使用。
	 */
	public static void getPrototypeInstance(){
		Prototype A=new Person(new Phone("123"), "保安");
		Prototype B=new Person(new Phone("456"), "门卫");
		Prototype C=new Person(new Phone("789"), "保洁");
		prototypeMap.put("保安", A);
		prototypeMap.put("门卫", B);
		prototypeMap.put("保洁", C);
	}
}

（4）测试

public class Client {
	public static void main(String[] args) {
		//初始化原形对象
		PrototypeManager.getPrototypeInstance();

		Person A1= (Person) PrototypeManager.getClone("保安");
		Person A2=(Person) PrototypeManager.getClone("保安");
		System.out.println("A1="+A1+",A2="+A2);
		System.out.println("A1==A2:"+(A1==A2));
		
		System.out.println("----------------");
		A1.getPhone().setNumber("852");
		System.out.println("当A1更改自己的电话号码的时候，不影响A2的电话号码：");
		System.out.println("A1="+A1+",A2="+A2);
		System.out.println("A1==A2:"+(A1==A2));
		System.out.println("----------------");
		
		Person B=(Person) PrototypeManager.getClone("保洁");
		Person C=(Person) PrototypeManager.getClone("门卫");
		System.out.println("B="+B+",C="+C);
		System.out.println("B==C:"+(B==C));
	}
}

 （5）测试结果

A1=Person [phone=Phone [number=123], name=保安],A2=Person [phone=Phone [number=123], name=保安]
A1==A2:false
----------------
当A1更改自己的电话号码的时候，不影响A2的电话号码：
A1=Person [phone=Phone [number=852], name=保安],A2=Person [phone=Phone [number=123], name=保安]
A1==A2:false
----------------
B=Person [phone=Phone [number=789], name=保洁],C=Person [phone=Phone [number=456], name=门卫]
B==C:false

参考文章http://www.runoob.com/design-pattern/prototype-pattern.html

http://www.cnblogs.com/java-my-life/archive/2012/04/11/2439387.html

 【四川乐山程序员联盟，欢迎大家加群相互交流学习5 7 1 8 1 4 7 4 3】