首页 诗词 字典 板报 句子 名言 友答 励志 学校 网站地图
当前位置: 首页 > 教程频道 > 软件管理 > 软件架构设计 >

原形(Prototype)模式 != Object.clone()

2012-09-22 
原型(Prototype)模式 ! Object.clone()5.1 概述谈到原型模式,学过Java的人可能会想到java.lang.Cloneable

原型(Prototype)模式 != Object.clone()

5.1 概述
谈到原型模式,学过Java的人可能会想到java.lang.Cloneable这个接口,以为Java的原型模式描述的就是java.lang.Cloneable接口的使用,这就大错特错了。其实,原型模式在我们日常生活中经常可以看到,比如你刚给你的客厅做了装修,你朋友正好也希望给他的客厅做装修,那么,他可能会把你家的装修方案拿过来改改就成,你的装修方案就是原型。

由于很多OOP语言都支持对象的克隆(拷贝)以方便复制对象,但这些方式并不那么完美,后述我们将会讨论。


5.2原型模式
当创建这些对象(一般情况是一些大对象)非常耗时,或者创建过程非常复杂时,非常有用,GoF给出的原型模式定义如下:

原型模式的静态类图非常简单,如下所示:
原形(Prototype)模式 != Object.clone()
Client使用Prototype的clone()方法得到这个对象的拷贝,其实拷贝原型对象不一定是指从内存中进行拷贝,我们的原型数据可能保存在数据库里

一般情况下,OOP语言都提供了内存中对象的复制,Java语言提供了对象的浅拷贝(Shallow copy),也就是说复制一个对象时,如果它的一个属性是引用,则复制这个引用,使之指向内存中同一个对象;但如果为此属性创建了一个新对象,让其引用指向它,即是深拷贝(Deep copy)。
5.3寄个快递
下面是一个邮寄快递的场景:
“给我寄个快递。”顾客说。
“寄往什么地方?寄给……?”你问。
“和上次差不多一样,只是邮寄给另外一个地址,这里是邮寄地址……”顾客一边说一边把写有邮寄地址的纸条给你。
“好!”你愉快地答应,因为你保存了用户的以前邮寄信息,只要复制这些数据,然后通过简单的修改就可以快速地创建新的快递数据了。
5.4实现
我们在复制新的数据时,需要特别注意的是,我们不能把所有数据都复制过来,例如,当对象包含主键时,不能使用原型数据的主键,必须创建一个新的主键。我们这里提供一个静态工厂方法,来获得原型数据,然后拷贝这些数据,最后做相应的初始化。为了操作安全起见,我们不直接使用原型数据,而是使用clone()方法从内存克隆这条原型数据做后续操作。我们使用Java提供java.lang.Cloneable接口克隆数据,它实现对象的浅拷贝,关于java.lang.Cloneable接口的使用请看后续介绍。
5.4.1UML静态类图
原形(Prototype)模式 != Object.clone()
Client使用PackageInfo提供的静态工厂方法clonePackage(String userName)创建一个新对象:首先根据userName加载一条用户以前的数据作为原型数据(可以是数据库,可以是其他任何你保存数据的地方),然后在内存中克隆这条数据,最后初始化该数据并返回。
5.4.2代码实现
public class PackageInfo implements Cloneable {
??? //getters, setters and other methods...

??? public PackageInfo clone() {
??????? try {
??????????? return (PackageInfo)super.clone();
??????? } catch (CloneNotSupportedException e) {
??????????? System.out.println("Cloning not allowed.");
??????????? return null;
??????? }
??? }

??? public static PackageInfo clonePackage(String userName) {
??????? //load package as prototype data from db...
??????? PackageInfo prototype = loadPackageInfo(userName);

//clone information ...
??????? prototype = prototype.clone();
???????
//initialize copied data ...
??????? prototype.setId(null);

??????? return prototype;
??? }
}
代码注解:

?Java的java.lang.Object方法里就提供了克隆方法clone(),原则上似乎所有类都拥有此功能,但其实不然,关于它的使用有如下限制:要实现克隆,必须实现java.lang.Cloneable接口,否则在运行时调用clone()方法,会抛CloneNotSupportedException异常。返回的是Object类型的对象,所以使用时可能需要强制类型转换。该方法是protected的,如果想让外部对象使用它,必须在子类重写该方法,设定其访问范围是public的,参见PackageInfo的clone()方法。Object的clone()方法的复制是采用逐字节的方式从复制内存数据,复制了属性的引用,而属性所指向的对象本身没有被复制,因此所复制的引用指向了相同的对象。由此可见,这种方式拷贝对象是浅拷贝,不是深拷贝。静态工厂方法public static PackageInfo clonePackage(String userName)方法根据原型创建一份拷贝:首先拿出用户以前的一条数据,即这句PackageInfo prototype = loadPackageInfo(userName),然后调用方法它的clone()方法完成内存拷贝,即prototype.clone(),最后我们初始化这条新数据,比如使id为空等。

现在来看看我们的测试代码,如下所示:
public class PackageInfoTestDrive {
??? public static void main(String[] args) {
??????? PackageInfo currentInfo = PackageInfo.clonePackage("John");
??????? System.out.println("Original package information:");
??????? display(currentInfo);

??????? currentInfo.setId(10000l);
currentInfo.setReceiverName("Ryan");
??????? currentInfo.setReceiverAddress("People Square, Shanghai");
???????
??????? System.out.println("\nNew package information:");
??????? display(currentInfo);
??? }
//other methods…
}
我们通过这句,PackageInfo currentInfo = PackageInfo.clonePackage("John"),拷贝了一份快递信息出来,通过设置currentInfo.setReceiverName("Ryan")和currentInfo.setReceiverAddress("People Square, Shanghai"),便完成了第二个包裹的信息录入,测试结果如下:
Original package information:
Package id: null
Receiver name: John
Receiver address: People Square,Shanghai
Sender name: William
Sender Phone No.: 12345678901

New package information:
Package id: 10000
Receiver name: Ryan
Receiver address: People Square, Shanghai
Sender name: William
Sender Phone No.: 12345678901
在实际的应用中,使用原型模式创建对象图 (Object Graph)非常便捷。
5.5深拷贝(Deep Copy)
通过上述学习,我们知道Java提供了浅拷贝的方法,那么,如何实现一个深拷贝呢?一般情况下,我们有两种方式来实现:
1.拷贝对象时,递归地调用属性对象的克隆方法完成。读者可以根据具体的类,撰写出实现特定类型的深拷贝方法。

一般地,我们很难实现一个一般性的方法来完成任何类型对象的深拷贝。有人根据反射得到属性的类型,然后依照它的类型构造对象,但前提是,这些属性的类型必须含有一个公有的默认构造方法,否则作为一个一般性的方法,很难确定传递给非默认构造方法的参数值;此外,如果属性类型是接口或者抽象类型,必须提供查找到相关的具体类方法,作为一个一般性的方法,这个也很难办到。
2.如果类实现了java.io.Serializable接口,把原型对象序列化,然后反序列化后得到的对象,其实就是一个新的深拷贝对象。
我们整理给出第二种方法的实现,代码片段大致如下所示:
import java.io.Serializable;
//other imports…

public class DeepCopyBean implements Serializable {
??? private String objectField;
??? private int primitiveField;

??? //getters and setters …

??? public DeepCopyBean deepCopy() {
??????? try {
??????????? ByteArrayOutputStream buf = new ByteArrayOutputStream();
??????????? ObjectOutputStream o = new ObjectOutputStream(buf);
??????????? o.writeObject(this);

??????????? ObjectInputStream in = new ObjectInputStream(new ByteArrayInputStream(buf.toByteArray()));
??????????? return (DeepCopyBean) in.readObject();
??????? } catch (IOException e) {
??????????? e.printStackTrace();
??????? } catch (ClassNotFoundException e) {
??????????? e.printStackTrace();
??????? }
??????? return null;
??? }
}
代码注解:

DeepCopyBean实现了java.io.Serializable接口,它含有一个原始类型(Primitive Type)的属性primitiveField和对象属性objectField。此类的deepCopy()方法首先序列化自己到流中,然后从流中反序列化,得到的对象便是一个新的深拷贝。

为了验证是不是实现了深拷贝,我们编写了如下测试代码:
DeepCopyBean originalBean = new DeepCopyBean();

//create a String object in jvm heap not jvm string pool
originalBean.setObjectField(new String("123456"));
originalBean.setPrimitiveField(2);

//clone this bean
DeepCopyBean newBean = originalBean.deepCopy();

System.out.println("Primitive ==? " + (newBean.getPrimitiveField() == originalBean.getPrimitiveField()));
System.out.println("Object ==? " + (newBean.getObjectField() == originalBean.getObjectField()));
System.out.println("Object equal? " + (newBean.getObjectField().equals(originalBean.getObjectField())));
注意:
这句,originalBean.setObjectField(new String("123456"))和originalBean.setObjectField("123456")是不一样的,前者创建了两个String对象,其中一个是在JVM的字符串池(String pool)里,另外一个在堆中,并且属性引用指向的对象在堆里;后者属性引用指向了JVM字符串池中的"123456"对象。

如果是浅拷贝,即引用指向同一内存地址,则newBean.getObjectField() == originalBean.getObjectField()为true,如果是深拷贝,则创建了不同对象,引用指向的地址肯定不一样,即此值应为false。但是这两种方式,使用这句,newBean.getObjectField().equals(originalBean.getObjectField()),进行比较,其结果必须为true,测试结果如下所示:
Primitive ==? true
Object ==? false
Object equal? true
和我们预想的结果一样,原始类型的使用==进行比较,结果相等,而引用类型使用==比较,结果显示未指向相同的地址,但是使用equals()方法比较的结果为true,即证明我们实现了深拷贝。

使用这种方式进行深拷贝,一方面,它只能拷贝实现Serializable接口类型的对象,其属性也是可序列化的;另一方面,序列化和反序列化比较耗时。选用此方式实现深拷贝时需要做这两方面的权衡。
5.6总结
我们以前使用java.lang.Cloneable的一个很大原因是使用new创建对象的速度相对来说比较慢,如今,随着JVM性能的提升,new的速度已经很接近Object的clone()方法的速度了,然而这并没有使原型模式使用失去多少光泽,使用原型模式有以下优点:

创建大的聚合对象图时,没必要为每个层次的子对象创建相应层次的工厂类。方便实例化,只要复制对象,然后初始化对象,就可以得到你想要的对象,并不不需要过多的编程。更多其他模式的讲解,请参见博文http://redhat.iteye.com/blog/1007884,代码和书籍都在该博文的附件里,这是其中的第5章。

?

?

参考:

?

[1]???Erich Gamma, Richard Helm,Ralph Johnson and John Vlissides. Design Patterns: Elements of ReusableObject-Oriented Software. Addison-Wesley, 1995.

[2]???Alan Shalloway and James R.Trott. Design Patterns Explained: A New Perspective on Object-Oriented Design,2nd Edition. Addison-Wesley, 2004.

[3]???Eric Evans. Domain-DrivenDesign: Tackling Complexity in the Heart of Software. Addison-Wesley, August,2003.

[4]???Joshua Bloch. Effective Java:Programming Language Guide. Addison-Wesley, 2001.

?

?

?

1 楼 tenderuser 2011-05-16   太长了。。。。。。 mark 一下。。 以后回来看吧 。。 2 楼 llyzq 2011-05-17   看了一部分,收藏一下,精华部分再细读

谢谢分享 3 楼 sebatinsky 2011-05-17   看了大部分,上班时间,做个坐标,回来OK 4 楼 jekyll 2011-05-17   不错,看完了。 5 楼 href 2011-05-17   两个优点在深入说下,光说没实例有点抽象,不好理解 6 楼 redhat 2011-05-17   [quote="href"]两个优点在深入说下,光说没实例有点抽象,不好理解

我在后面说了,在我的书里,代码也在我的博客的附件里,[img]/images/smiles/icon_biggrin.gif" alt="[/img]
链接http://redhat.iteye.com/blog/1007884
这是第5章的内容。大家似乎对整个书籍可能兴趣不大,其实书里讲了好多大家经常搞错的概念。
7 楼 wuzaizhong283 2011-05-17   不错,楼主你的图是用什么工具画的 8 楼 redhat 2011-05-17   wuzaizhong283 写道不错,楼主你的图是用什么工具画的
argouml,免费工具。 9 楼 hyl1234 2011-05-17   <<漫谈设计模式>>? 10 楼 redhat 2011-05-17   hyl1234 写道<<漫谈设计模式>>?
请参见链接 11 楼 humor200 2011-05-20   先MARK一下,以后回来看。现在忙。 12 楼 jk19910410 2011-05-20   good
13 楼 yuncaiguanghui 2011-05-24   先mark一下,以后再看吧 14 楼 gudgudstudy 2011-05-29   不错,有点长了 15 楼 bugu1986 2011-05-29   redhat 写道hyl1234 写道<<漫谈设计模式>>?
请参见链接


莫非LZ是作者? 16 楼 redhat 2011-05-30   bugu1986 写道redhat 写道hyl1234 写道<<漫谈设计模式>>?
请参见链接


莫非LZ是作者?

是的,里面有些实践和体会,谢谢! 17 楼 bugu1986 2011-06-05   redhat 写道bugu1986 写道redhat 写道hyl1234 写道<<漫谈设计模式>>?
请参见链接


莫非LZ是作者?

是的,里面有些实践和体会,谢谢!

初读一下,写的很好,谢谢分享。 18 楼 Technoboy 2011-06-06   不太赞成使用序列化的方式实现deep copy
如果一个类实现了Serializable接口,那么一旦这个类发布,“改变这个类的实现”的灵活性将大大降低

热点排行