【设计模式二十之原型模式】原型模式详解

原型模式Prototype Pattern

• 细说原型模式
• • 细说原型模式
  • • 定义
    • UML模型
    • • 基于UML的代码
    • 场景
    • • 场景一
    • 代码
    • • 代码一
    • 基于原型模式的深拷贝与浅拷贝
    • • 浅拷贝
      • 深拷贝
      • 原型模式clone与final冤家路窄
    • 原型模式应用和注意事项

细说原型模式

提示：

博主：章飞 _906285288的博客

博客地址：http://blog.csdn.net/qq_29924041

细说原型模式

原型模式这个模式的简单程度是仅次于单例模式和迭代器模式，非常简单，但是要使

用好这个模式还有很多注意事项。原型，顾名思义，也就是本来的模型只有一个，类似电子工业生产中的模具，有了这个模具之后，后面所有的产品都可以由这个模具生产出来，但是这个模具生产出来后，可以完全一样，也可以在生产的产品后再修改出一部分差异化的东西。这就是原型模式。

定义

原型模式：用原型实例指定创建对象的种类，通过拷贝这些原型来创建新的对象。

其实也就是使用java的拷贝原理，在原型的基础之上创建新的对象而已。

UML模型

从上述的UML图中就可以看到，原型模式是非常简单的，原型类中只有clone一个方法，而在java中提供了Cloneable这个接口来标识对象的可拷贝特性。这个接口其实只是一个标记作用，在JVM中通过这个标记来识别出这个对象具有可拷贝的特性。

基于UML的代码

package src.com.zzf.designpattern.prototypepattern.demo4;

/**
 * 原型对象，实现Cloneable接口，重写clone方法
 * @author zhouzhangfei
 *
 */
public class PrototypeClass implements Cloneable{
	public String name = "123";
	
	//重写clone方法
	@Override
	protected PrototypeClass clone()  {
		// TODO Auto-generated method stub
		PrototypeClass prototypeClass = null;
		try {
			prototypeClass =  (PrototypeClass) super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return prototypeClass;
	}
}

           

package src.com.zzf.designpattern.prototypepattern.demo4;

/**
 * 测试代码，通过拷贝方法，创建出了两个不同的对象
 * @author zhouzhangfei
 *
 */
public class Test {
	public static void main(String[] args) {
		//原型模式创建原始对象
		PrototypeClass prototypeClass = new PrototypeClass();
		System.out.println(prototypeClass.toString()+"\t"+prototypeClass.name);
		//通过克隆拷贝方法，创建出一个新的对象
		PrototypeClass prototypeClass2 = prototypeClass.clone();
		System.out.println(prototypeClass2.toString()+"\t"+prototypeClass2.name);
		
		//从上面可以看出，基本数据类型的拷贝是随着对象一起被克隆出去的，即两个对象的基本数据类型值是一致的
	}
}


           

场景

在之前所有关于设计模式的博客中都讲到了场景，同样，原型模式在实际的应用过程中也有非常多的场景。

场景一

设计模式之禅中举了一个群发邮件的案例，定义一个邮件的模板类，通过改变邮件的收件者和内容，然后修改邮件的发送。这个在实际开发过程中是有很广泛的应用的。如果通过new的方式，会造成大量的性能浪费，而使用原型模式，通过内存已有的对象，把对象拷贝一份，产生一个新的对象，和原有对象一样，然后再修改细节的数据。有助于提高性能

代码

代码一

package src.com.zzf.designpattern.prototypepattern.demo1;


/**
 * 广告信的模板
 * @author Administrator
 *
 */
public class AdvTemplate {
	private String advSubject = "XX银行信用卡抽奖活动";
	private String advContext = "国庆抽奖活动:只要刷卡就送你一百万!...";
	public String getAdvSubject() {
		return advSubject;
	}
	public void setAdvSubject(String advSubject) {
		this.advSubject = advSubject;
	}
	public String getAdvContext() {
		return advContext;
	}
	public void setAdvContext(String advContext) {
		this.advContext = advContext;
	}
	
}
           

package src.com.zzf.designpattern.prototypepattern.demo1;


public class Mail implements Cloneable{
	//收件人
	String receiver;
	//邮件名称
	String subject;
	//称谓
	String appellation;
	//邮件内容
	String context;
	//邮件的尾部
	String tail;
	
	public Mail(AdvTemplate mAdvTemplate) {
		this.context = mAdvTemplate.getAdvContext();
		this.subject = mAdvTemplate.getAdvSubject();
	}
	public String getReceiver() {
		return receiver;
	}
	public void setReceiver(String receiver) {
		this.receiver = receiver;
	}
	public String getSubject() {
		return subject;
	}
	public void setSubject(String subject) {
		this.subject = subject;
	}
	public String getAppellation() {
		return appellation;
	}
	public void setAppellation(String appellation) {
		this.appellation = appellation;
	}
	public String getContext() {
		return context;
	}
	public void setContext(String context) {
		this.context = context;
	}
	public String getTail() {
		return tail;
	}
	public void setTail(String tail) {
		this.tail = tail;
	}
	
	@Override
	protected Mail clone() {
		// TODO Auto-generated method stub
		Mail mail = null;
		try {
			mail = (Mail) super.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		return mail;
	}
}

           

package src.com.zzf.designpattern.prototypepattern.demo1;


import java.util.Random;
/**
 * 一是类初始化需要消化非常多的资源，这个资源包括数据、硬件资源
等；二是通过new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；
三是一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对
象供调用者使用。在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone
的方法创建一个对象，然后由工厂方法提供给调用者。
 * @author Administrator
 *
 */
public class Client {
	// 发送账单的数量，这个值是从数据库中获得
	private static int MAX_COUNT = 6;

	public static void main(String[] args) {
		// 模拟发送邮件
		int i = 0;
		// 把模板定义出来，这个是从数据库中获得
		Mail mail = new Mail(new AdvTemplate());
		mail.setTail("XX银行版权所有");

		while (i < MAX_COUNT) {
			// 以下是每封邮件不同的地方
			Mail mailclone = mail.clone();
			mailclone.setAppellation(getRandString(5) + " 先生（女士）");
			mailclone.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
			// 然后发送邮件
			sendMail(mailclone);
			i++;
		}
	}

	// 获得指定长度的随机字符串
	public static String getRandString(int maxLength) {
		String source = "abcdefghijklmnopqrskuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
		StringBuffer sb = new StringBuffer();
		Random rand = new Random();
		for (int i = 0; i < maxLength; i++) {
			sb.append(source.charAt(rand.nextInt(source.length())));
		}
		return sb.toString();
	}

	// 发送邮件
	public static void sendMail(Mail mail) {
		System.out.println("标题:" + mail.getSubject() + "\t收件人:" + mail.getReceiver() + "\t....发送成功！");
	}
	
}
           

注意：

对象拷贝时，类的构造函数是不会被执行的

基于原型模式的深拷贝与浅拷贝

既然原型模式是通过拷贝的形式来进行的，那也就有必要分析一下什么叫做浅拷贝，什么叫深拷贝

浅拷贝

浅拷贝（Shallow Copy）：①对于数据类型是基本数据类型的成员变量，浅拷贝会直接进行值传递，也就是将该属性值复制一份给新的对象。因为是两份不同的数据，所以对其中一个对象的该成员变量值进行修改，不会影响另一个对象拷贝得到的数据。②**对于数据类型是引用数据类型的成员变量，**比如说成员变量是某个数组、某个类的对象等，那么浅拷贝会进行引用传递，也就是只是将该成员变量的引用值（内存地址）复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下，在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。

如下描述代码所示：

package src.com.zzf.designpattern.prototypepattern.demo2;


/**
 * 浅拷贝对象，
 * @author zhouzhangfei
 *
 */
public class Thing implements Cloneable{
	//基本数据类型，int,String,long会直接拷贝一份过去
	public String nameString ="12345";
	public String string = new String("9999999");
	//数组对象不会直接拷贝，而是会将其地址拷贝一份过去，导致两个对象会访问同一块内存区域
	public int [] array = new int[]{};
	public  Thing() {
		System.out.println("构造函数被执行了");
	}
	
	@Override
	protected Thing clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		Thing mThing = null;
		mThing = (Thing) super.clone();
		return mThing;
	}
	
	
}

           

package src.com.zzf.designpattern.prototypepattern.demo2;


/**
 * 浅拷贝
 * @author Administrator
 * 内部的数组和引用对象不拷贝，其他的原始类型比如int,long,String(Java 就希望你把String 认为是基本类型，String 是没有clone 方法的)等都会被拷贝的。
 */
public class Test {
	public static void main(String[] args) {
		Thing mThing = new Thing();
		System.err.println(mThing.nameString);
		System.out.println(mThing.array);
		try {
			Thing cloneThing = mThing.clone();
			cloneThing.nameString = "445567";
			System.out.println(cloneThing.nameString);
			System.out.println(cloneThing.string);
			System.out.println(cloneThing.array);
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
	}
}

           

运行结果为：

构造函数被执行了

12345

[[email protected]

445567

9999999

[[email protected]

从结果中就可以看到。对于String,new String等数据类型结构，是直接在新的对象中拷贝了一份，而对于数组对象来说，则是把原型对象中的数组的地址拷贝了一份给新的对象，这就会导致两个数组对象会同时去访问同一块内存地址。这就是导致一种叫做脏数据的现象

深拷贝

深拷贝（Deep Copy）：对原型对象的所有数据结构都进行了拷贝。也就是对原型对象中的引用数据类型，集合，数组，等都在新的拷贝对象中开辟了一个新的空间。

如下案例所示：

package src.com.zzf.designpattern.prototypepattern.demo3;


import java.util.ArrayList;
/**
 * Clone 与final 两对冤家
 * 删除掉final 关键字，这是最便捷最安全最快速的方式，你要使用clone 方法就在类
的成员变量上不要增加final 关键字
 * @author Administrator
 *
 */
public class Thing implements Cloneable{
	
	private ArrayList<String> arrayList = new ArrayList<String>();
	public int [] array = new int[]{};
	@Override
	protected Object clone() throws CloneNotSupportedException {
		// TODO Auto-generated method stub
		Thing thing = null;
		thing = (Thing) super.clone();
		thing.arrayList = (ArrayList<String>) this.arrayList.clone();
		this.array = this.array.clone();
		return thing;
	}
	
	public void setValue(String obj) {
		this.arrayList.add(obj);
	}
	
	public ArrayList<String> getValue() {
		return arrayList;
	}
}

           

package src.com.zzf.designpattern.prototypepattern.demo3;


/**
 * 
 * @author Administrator
 *
 */
public class Client {
	
	public static void main(String[] args) {
		//产生一个对象
		Thing thing = new Thing();
		//设置一个值
		thing.setValue("张三");
		
		//拷贝一个对象
		Thing cloneThing = null;
		try {
			cloneThing = (Thing) thing.clone();
		} catch (CloneNotSupportedException e) {
			// TODO Auto-generated catch block
			e.printStackTrace();
		}
		
		cloneThing.setValue("李四");
		System.out.println(thing.array);
		System.out.println(thing.getValue());
		System.out.println(cloneThing.getValue());
		System.out.println(cloneThing.array);
	}
	
}

           

执行结果为:

[[email protected]

[张三]

[张三, 李四]

[[email protected]

从上面结果中可以看到。数组对象地址发生了改变，也就是数组对象是重新开辟了一块内存区域，而集合对象也发生了改变，拷贝对象中包含了原型对象中的元素，但是拷贝对象在修改完自己内部的集合的时候，并不会引起原型对象集合内容的改变，这就是深度拷贝，拷贝的不仅仅是基本数据类型，会将引用数据类型的地址在新的对象中重新开辟一份出来

原型模式clone与final冤家路窄

final关键字我们都知道是不能改变的对吧，而clone是为了拷贝而存在的，clone对象的属性是随时都可以发生改变的，这也就造成了鱼与熊掌不可兼得的问题。

解决方式：

删除掉final 关键字，这是最便捷最安全最快速的方式，你要使用clone 方法就在类

的成员变量上不要增加final 关键字

原型模式应用和注意事项

首先说优点吧：

1：原型模式是在内存的二进制流中进行的拷贝动作，。所以它会比new对象来的更快一些，也就是性能上会优化很多，尤其是在一个循环体内部产生大量对象的时候，这个时候非常推荐使用原型模式

2：原型模式在拷贝的时候构造函数是不会去执行的。

场景：

当一个类在初始化的时候比较消耗资源的时候，这个时候原型模式是一个好的选择

当在循环体中大量创建一个对象的时候，这个时候原型模式也是一个极佳的选择

注意：

浅拷贝和深拷贝的区别…不要在拷贝的时候，犯错

欢迎继续访问，我的博客