【秒懂设计模式】原型模式

 秒懂设计模式——原型模式

（五）原型模式

【官方定义】用原型实例指定创建对象的种类，并且通过拷贝这些原型，创建新的对象，属于对象创建模式。

【举例】在找工作的时候，通常需要我们的毕业证和学位证，但是我们一般不会把原件（原型实例）给到用人单位，而是会把原件复印（拷贝）几份，然后供用人单位使用。

【Java代码】

①创建一个证书抽象类。

package com.liyan.prototype;
/**
 * 证书抽象类
 * <p>Title: Certificate</p>
 * @author  Liyan
 * @date    2017年5月2日 下午3:17:37
 */
public abstract class Certificate implements Cloneable{

	/**证书编号*/
	private Integer id;

	/**证书名称*/
	protected String name;

	/**测试方法*/
	abstract void testMethod();

	public Integer getId() {
		return id;
	}

	public void setId(Integer id) {
		this.id = id;
	}

	public String getName() {
		return name;
	}

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

	@Override
	protected Object clone() throws CloneNotSupportedException {
		return super.clone();
	}

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

}

②创建证书扩展类——毕业证

package com.liyan.prototype;
/**
 * 数据信息扩展类——毕业证
 * <p>Title: GraduationCertificate</p>
 * @author  Liyan
 * @date    2017年5月2日 下午3:17:47
 */
public class GraduationCertificate extends Certificate{

	public GraduationCertificate() {
		name = "毕业证";
	}

	@Override
	void testMethod() {
		System.out.println("毕业证复印完成！");
	}

}

③创建证书扩展类——学位证

package com.liyan.prototype;
/**
 * 证书扩展类——学位证
 * <p>Title: DegreeCertificate</p>
 * @author  Liyan
 * @date    2017年5月2日 下午3:18:26
 */
public class DegreeCertificate extends Certificate{

	public DegreeCertificate() {
		name = "学位证";
	}

	@Override
	void testMethod() {
		System.out.println("学位证复印完成！");
	}

}

④创建原型模式管理器——证书管理器

package com.liyan.prototype;
import java.util.HashMap;

/**
 * 原型模式管理器——证书管理器
 * <p>Title: CertificateManger</p>
 * @author  Liyan
 * @date    2017年5月2日 下午3:24:40
 */
public class CertificateManger {
	//证书的map集合
	private static HashMap<Integer, Certificate> certificateMap = new HashMap<Integer, Certificate>(0);
	//私有构造方法
	private CertificateManger (){}
	//懒加载构建原型模式管理器的单例模式
	private static CertificateManger certificateManger = null;

	/**
	 * 获取单例模式的原型模式管理器
	 * <p>Title: getCertificateManger</p>
	 * @author Liyan
	 * @date   2017年5月2日 下午3:24:51
	 * @return CertificateManger
	 */
	public static CertificateManger getCertificateManger() {
		if (certificateManger == null) {
			certificateManger = new CertificateManger();
		}
		return certificateManger;
	}

	/**
	 * 加载缓存
	 * <p>Title: getLoad</p>
	 * @author Liyan
	 * @date   2017年5月2日 下午3:25:07
	 */
	public static void getLoad() {
		GraduationCertificate certificate1 = new GraduationCertificate();
		certificateMap.put(1, certificate1);
		DegreeCertificate certificate2 = new DegreeCertificate();
		certificateMap.put(2, certificate2);
	}  

	/**
	 * 根据key获取克隆后的对象
	 * <p>Title: getCertificate</p>
	 * @author Liyan
	 * @date   2017年5月2日 下午3:25:31
	 * @param key
	 * @return Certificate
	 */
	public static Certificate getCertificate(Integer key) {
		try {
			Certificate certificate = (Certificate) certificateMap.get(key);
			if (certificate != null) {
				Certificate datinfo = (Certificate) certificate.clone();
				System.out.println("key="+key+"的对象克隆完成，datinfo="+datinfo);
				return datinfo;
			}else {
				System.out.println("key="+key+"并未加载！");
				return null;
			}
		} catch (CloneNotSupportedException e) {
			e.printStackTrace();
		}
		return null;
	}

}

⑤测试

package com.liyan.prototype;
/**
 * 测试
 * <p>Title: Test</p>
 * @author  Liyan
 * @date    2017年5月2日 下午3:30:21
 */
public class Test {
	@SuppressWarnings("static-access")
	public static void main(String[] args) {
		//提前加载到缓存数据
		CertificateManger.getLoad();
		//获取单例类CertificateManger
		CertificateManger manger  = CertificateManger.getCertificateManger();
		//获取毕业证复印件
		Certificate certificate1 = manger.getCertificate(1);
		certificate1.testMethod();
		//获取学位证复印件
		Certificate certificate2 = manger.getCertificate(2);
		certificate2.testMethod();
	}
}

⑥测试结果

key=1的对象克隆完成，datinfo=Certificate [id=null, name=毕业证]
毕业证复印完成！
key=2的对象克隆完成，datinfo=Certificate [id=null, name=学位证]
学位证复印完成！

图解关系：

分析：

这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

独特的优点：

（1）性能比直接new一个对象要好的多。因为clone方法是一个本地方法，它直接操作内存中的二进制流，特别是复制大对象时，性能的差别非常明显，所以在需要重复地创建相似对象时可以考虑使用原型模式。

（2）原型模式创建模式不会损坏原有对象。

（3）工厂模式对新产品的适应能力比较弱，层级结构比较复杂，没有原型模式简洁。

注意事项：

（1）使用原型模式复制对象不会调用类的构造方法。因为clone方法，会直接在内存中复制数据。

（2）单例模式与原型模式是冲突的。因为clone方法直接无视构造方法的权限。