Java设计模式之原型模式

原型模式

作为对象的创建模式，与单例模式形成对比，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

原型模式的结构

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

写一个简单的原型模式

首先我们要写一个拥有克隆方法的接口,并让所有我们想用原型模式去创建对象的类实现它,我们称它为抽象原型

public interface Prototype {
	//克隆对象的方法
	public Object clone();
	public void doSome();
}

然后我们去写具体的原型类

public class PrototypeClass1 implements Prototype{
	@Override
	public Prototype clone() {
		Prototype prototyoe = new PrototypeClass1();
		return prototyoe;
	}
	@Override
	public void doSome() {
		System.out.println("p1");
	}
}
-------------------------------------------------
public class PrototypeClass2 implements Prototype{
	@Override
	public Prototype clone() {
		Prototype prototyoe = new PrototypeClass2();
		return prototyoe;
	}
	@Override
	public void doSome() {
		System.out.println("p2");
	}
}

之后就是我们的消费者

public class Consumer {
	//需要克隆的对象
	private Prototype prototype;
	//提供set方法
	public void setPrototype(Prototype prototype) {
		this.prototype = prototype;
	}
	public void doSome() {
		Prototype newPrototype = prototype.clone();
		newPrototype.doSome();
	}
	
}

测试

public static void main(String[] args) {
		Consumer consumer = new Consumer();
		consumer.setPrototype(new PrototypeClass2());
		consumer.doSome();
		consumer.setPrototype(new PrototypeClass1());
		consumer.doSome();
	}

打印结果即是:
p2
p1
这是一个简单的原型模式,当然还有复杂一点的登记原型模式
它多了一个原型管理器(PrototypeManager)角色，该角色的作用是：创建具体原型类的对象，并记录每一个被创建的对象。
这样的话要给每个具体类一个名字,在接口写出get set抽象方法

public interface Prototype {
	
	public Prototype clone();
	
	public void doSome();
	
	public String getName();
	
	public void setName(String name);
}

具体类

public class PrototypeClass1 implements Prototype{
	private String name;
	
	@Override
	public Prototype clone() {
		Prototype prototyoe = new PrototypeClass1();
		return prototyoe;
	}
	@Override
	public void doSome() {
		System.out.println("p1");
	}
	@Override
	public String getName() {
		return name;
	}
	@Override
	public void setName(String name) {
		this.name = name;
	}
	
	
}
-------------------------------------------------
public class PrototypeClass2 implements Prototype{
	private String name;
	@Override
	public Prototype clone() {
		Prototype prototyoe = new PrototypeClass2();
		return prototyoe;
	}
	@Override
	public void doSome() {
		System.out.println("p2");
	}
	@Override
	public String getName() {
		return name;
	}
	@Override
	public void setName(String name) {
		this.name = name;
	}
	
}

然后创建原型管理器,每创建过一个一个实例,就进行一次登记

public class PrototypeManager {
	//登记也就是存储到map  id作键 提供的原型作值
	private static Map<String,Prototype> map = new HashMap<String, Prototype>();
	//登记方法
	public synchronized static void setPrototype(String Id,Prototype prototype) {
		map.put(Id, prototype);
	}
	//注销方法
	public synchronized static void removePrototype(String Id) {
		map.remove(Id);
	}
	//获取原型实例
	public synchronized static Prototype getPrototype(String Id) throws Exception {
		Prototype prototype = map.get(Id);
		if(prototype!=null) {
			return prototype;
		}else {
			throw new Exception("Not Found Protype by this key");
		}
	}
	//因为原型管理器只提供静态方法操作,不允许外部创建对象
	private PrototypeManager() {
		
	}
	
}

测试:

public static void main(String[] args) throws Exception {
		//两个实例对象
		Prototype prototypeClass1 = new PrototypeClass1();
		prototypeClass1.setName("p1");
		Prototype prototypeClass2 = new PrototypeClass2();
		prototypeClass2.setName("p2");
		PrototypeManager.setPrototype(prototypeClass1.getName(), prototypeClass1);
		PrototypeManager.setPrototype(prototypeClass2.getName(), prototypeClass2);
		Consumer consumer = new Consumer();
		//使用第一个
		consumer.setPrototype(PrototypeManager.getPrototype("p1"));
		consumer.doSome();
		//使用第二个
		consumer.setPrototype(PrototypeManager.getPrototype("p2"));
		consumer.doSome();
		//使用第一个
		PrototypeManager.removePrototype("p1");
		consumer.setPrototype(PrototypeManager.getPrototype("p1"));
		consumer.doSome();
	}

打印结果:

第三次我们已经注销了,再获取抛出我们写好的异常
好了,原型模式就到这里,纯属个人一点见解,如有误区,望指正
还是要根据不同场景需求去选择和修改