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

• 创建大的聚合对象图时，没必要为每个层次的子对象创建相应层次的工厂类。
• 方便实例化，只要复制对象，然后初始化对象，就可以得到你想要的对象，并不不需要过多的编程。

更多其他模式的讲解，请参见博文http://redhat.iteye.com/blog/1007884，代码和书籍都在该博文的附件里，这是其中的第5章。

 

 

参考：

 

[1]   Erich Gamma, Richard Helm, Ralph Johnson and John Vlissides. Design Patterns: Elements of Reusable Object-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-Driven Design: Tackling Complexity in the Heart of Software. Addison-Wesley, August, 2003.

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