java 注解 @?(name="username"),原型（Prototype）模式 != Object.clone()

5.1 概述

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

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

5.2 原型模式

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

原型模式的静态类图非常简单，如下所示：

Client使用Prototype的clone()方法得到这个对象的拷贝，其实拷贝原型对象不一定是指从内存中进行拷贝，我们的原型数据可能保存在数据库里。

一般情况下，OOP语言都提供了内存中对象的复制，Java语言提供了对象的浅拷贝(Shallow copy)，也就是说复制一个对象时，如果它的一个属性是引用，则复制这个引用，使之指向内存中同一个对象；但如果为此属性创建了一个新对象，让其引用指向它，即是深拷贝(Deep copy)。

5.3 寄个快递

下面是一个邮寄快递的场景：

“给我寄个快递。”顾客说。

“寄往什么地方？寄给……？”你问。

“和上次差不多一样，只是邮寄给另外一个地址，这里是邮寄地址……”顾客一边说一边把写有邮寄地址的纸条给你。

“好！”你愉快地答应，因为你保存了用户的以前邮寄信息，只要复制这些数据，然后通过简单的修改就可以快速地创建新的快递数据了。

5.4 实现

我们在复制新的数据时，需要特别注意的是，我们不能把所有数据都复制过来，例如，当对象包含主键时，不能使用原型数据的主键，必须创建一个新的主键。我们这里提供一个静态工厂方法，来获得原型数据，然后拷贝这些数据，最后做相应的初始化。为了操作安全起见，我们不直接使用原型数据，而是使用clone()方法从内存克隆这条原型数据做后续操作。我们使用Java提供java.lang.Cloneable接口克隆数据，它实现对象的浅拷贝，关于java.lang.Cloneable接口的使用请看后续介绍。

5.4.1 UML静态类图

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()方法的速度了，然而这并没有使原型模式使用失去多少光泽，使用原型模式有以下优点：

创建大的聚合对象图时，没必要为每个层次的子对象创建相应层次的工厂类。

方便实例化，只要复制对象，然后初始化对象，就可以得到你想要的对象，并不不需要过多的编程。