十四、原型模式Prototype（创建型模式）

1：原型模式的本质

原型模式的本质：克隆生成对象。

克隆是手段，目的还是生成新的对象实例。正是因为原型的目的是为了生成新的对象实例，原型模式通常是被归类为创建型的模式。

原型模式也可以用来解决“只知接口而不知实现的问题”，使用原型模式，可以出现一种独特的“接口造接口”的景象，这在面向接口编程中很有用。同样的功能也可以考虑使用工厂来实现。

另外，原型模式的重心还是在创建新的对象实例，至于创建出来的对象，其属性的值是否一定要和原型对象属性的值完全一样，这个并没有强制规定，只不过在目前大多数实现中，克隆出来的对象和原型对象的属性值是一样的。

也就是说，可以通过克隆来创造值不一样的实例，但是对象类型必须一样。可以有部分甚至是全部的属性的值不一样，可以有选择性的克隆，就当是标准原型模式的一个变形使用吧。

2：何时选用原型模式

建议在如下情况中，选用原型模式：

• 如果一个系统想要独立于它想要使用的对象时，可以使用原型模式，让系统只面向接口编程，在系统需要新的对象的时候，可以通过克隆原型来得到
• 如果需要实例化的类是在运行时刻动态指定时，可以使用原型模式，通过克隆原型来得到需要的实例

 原型模式和抽象工厂模式
    功能上有些相似，都是用来获取一个新的对象实例的。
    不同之处在于，原型模式的着眼点是在如何创造出实例对象来，最后选择的方案是通过克隆；而抽象工厂模式的着眼点则在于如何来创造产品簇，至于具体如何创建出产品簇中的每个对象实例，抽象工厂模式不是很关注。
    正是因为它们的关注点不一样，所以它们也可以配合使用，比如在抽象工厂模式里面，具体创建每一种产品的时候就可以使用该种产品的原型，也就是抽象工厂管产品簇，具体的每种产品怎么创建则可以选择原型模式。

原型模式和生成器模式
    这两种模式可以配合使用。
    生成器模式关注的是构建的过程，而在构建的过程中，很可能需要某个部件的实例，那么很自然地就可以应用上原型模式，通过原型模式来得到部件的实例

1）原型模式的功能 

原型模式的功能实际上包含两个方面：

• 一个是通过克隆来创建新的对象实例
• 另一个是为克隆出来的新的对象实例复制原型实例属性的值

原型模式要实现的主要功能就是：通过克隆来创建新的对象实例。一般来讲，新创建出来的实例的数据是和原型实例一样的。但是具体如何实现克隆，需要由程序自行实现，原型模式并没有统一的要求和实现算法。

（2）原型与new

原型模式从某种意义上说，就像是new操作，在前面的例子实现中，克隆方法就是使用new来实现的，但请注意，只是“类似于new”而不是“就是new”。

克隆方法和new操作最明显的不同就在于：new一个对象实例，一般属性是没有值的，或者是只有默认值；如果是克隆得到的一个实例，通常属性是有值的，属性的值就是原型对象实例在克隆的时候，原型对象实例的属性的值。

（3）原型实例和克隆的实例

原型实例和克隆出来的实例，本质上是不同的实例，克隆完成后，它们之间是没有关联的，如果克隆完成后，克隆出来的实例的属性的值发生了改变，是不会影响到原型实例的。下面写个示例来测试一下，示例代码如下

public class Client {
    public static void main(String[] args) {
       //先创建原型实例
       OrderApi oa1 = new PersonalOrder();
       //设置原型实例的订单数量的值
       oa1.setOrderProductNum(100);
       //为了简单，这里仅仅输出数量
        System.out.println("这是第一次获取的对象实例==="
+oa1.getOrderProductNum());      
       //通过克隆来获取新的实例
        OrderApi oa2 = (OrderApi)oa1.cloneOrder();
       //修改它的数量
       oa2.setOrderProductNum(80);
       //输出克隆出来的对象的值
       System.out.println("输出克隆出来的实例==="+oa2.getOrderProductNum());
       //再次输出原型实例的值
       System.out.println("再次输出原型实例==="+oa1.getOrderProductNum());  
    }
}

运行一下，看看结果：

这是第一次获取的对象实例===100

输出克隆出来的实例===80

再次输出原型实例===100

仔细观察上面的结果，会发现原型实例和克隆出来的实例是完全独立的，也就是它们指向不同的内存空间。因为克隆出来的实例的值已经被改变了，而原型实例的值还是原来的值，并没有变化，这就说明两个实例是对应的不同内存空间。

（4）原型模式的调用顺序示意图

原型模式的调用顺序如图所示：

Java中的克隆方法

在Java语言中已经提供了clone方法，定义在Object类中。关于Java中clone方法的知识，这里不去赘述，下面看看怎么使用Java里面的克隆方法来实现原型模式。

       需要克隆功能的类，只需要实现java.lang.Cloneable接口，这个接口没有需要实现的方法，是一个标识接口。因此在前面的实现中，把订单接口中的克隆方法去掉，现在直接实现Java中的接口就好了。新的订单接口实现，示例代码如下：

public interface OrderApi {

    public int getOrderProductNum();

    public void setOrderProductNum(int num);

    public OrderApi cloneOrder();

}

另外在具体的订单实现对象里面，实现方式上会有一些改变，个人订单和企业订单的克隆实现是类似的，因此示范一个就好了，看看个人订单的实现吧，示例代码如下：

/**
 * 个人订单对象,利用Java的Clone功能
 */
public class PersonalOrder implements Cloneable  , OrderApi{
    private String customerName;
    private String productId;
    private int orderProductNum = 0;
    public int getOrderProductNum() {
       return this.orderProductNum;
    }  

    public void setOrderProductNum(int num) {
       this.orderProductNum = num;
    }  

    public String getCustomerName() {
       return customerName;
    }

    public void setCustomerName(String customerName) {
       this.customerName = customerName;
    }

    public String getProductId() {
       return productId;
    }

    public void setProductId(String productId) {
       this.productId = productId;
    }

    public String toString(){
       return "本个人订单的订购人是="+this.customerName+"，订购产品是="+this.productId+"，订购数量为="+this.orderProductNum;
    }

    public OrderApi cloneOrder() {
       // 创建一个新的订单，然后把本实例的数据复制过去
       PersonalOrder order = new PersonalOrder();
       order.setCustomerName(this.customerName);
      order.setProductId(this.productId);
      order.setOrderProductNum(this.orderProductNum);
       return order;
    }

    public Object clone(){
       //克隆方法的真正实现，直接调用父类的克隆方法就可以了
       Object obj = null;
       try {
           obj = super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
       }
       return obj;
    }
}

看起来，比完全由自己实现原型模式要稍稍简单点，是否好用呢？还是测试一下，看看效果。客户端跟上一个示例相比，作了两点修改：

• 一个是原来的“OrderApi oa1 = new PersonalOrder();”这句话，要修改成：“PersonalOrder oa1 = new PersonalOrder();”。原因是现在的接口上并没有克隆的方法，因此需要修改成原型的类型
• 另外一个是“通过克隆来获取新的实例”的实现，需要修改成使用原型来调用在Object里面定义的clone()方法了，不再是调用原来的cloneOrder()了。

看看测试用的代码，示例代码如下：

public class Client {
    public static void main(String[] args) {
       //先创建原型实例
       PersonalOrder oa1 = new PersonalOrder();     
       //设置原型实例的订单数量的值
       oa1.setOrderProductNum(100);
        System.out.println("这是第一次获取的对象实例==="+oa1.getOrderProductNum());      
       //通过克隆来获取新的实例
        PersonalOrder oa2 = (PersonalOrder)oa1.clone();
       oa2.setOrderProductNum(80);
       System.out.println("输出克隆出来的实例==="+oa2.getOrderProductNum());     
       //再次输出原型实例的值
       System.out.println("再次输出原型实例==="+oa1.getOrderProductNum());  
    }
}

浅度克隆和深度克隆

无论你是自己实现克隆方法，还是采用Java提供的克隆方法，都存在一个浅度克隆和深度克隆的问题，那么什么是浅度克隆？什么是深度克隆呢？简单地解释一下：

• 浅度克隆：只负责克隆按值传递的数据（比如：基本数据类型、String类型）
• 深度克隆：除了浅度克隆要克隆的值外，还负责克隆引用类型的数据，基本上就是被克隆实例所有的属性的数据都会被克隆出来。
      深度克隆还有一个特点，如果被克隆的对象里面的属性数据是引用类型，也就是属性的类型也是对象，那么需要一直递归的克隆下去。这也意味着，要想深度克隆成功，必须要整个克隆所涉及的对象都要正确实现克隆方法，如果其中有一个没有正确实现克隆，那么就会导致克隆失败。

       在前面的例子中实现的克隆就是典型的浅度克隆，下面就来看看如何实现深度克隆。

1：自己实现原型的深度克隆

（1）要演示深度克隆，需要给订单对象添加一个引用类型的属性，这样实现克隆过后，才能看出深度克隆的效果来。

那就定义一个产品对象，也需要让它实现克隆的功能，产品对象实现的是一个浅度克隆。先来定义产品的原型接口，示例代码如下：

/**
 * 声明一个克隆产品自身的接口
 */
public interface ProductPrototype {
    /**
     * 克隆产品自身的方法
     * @return 一个从自身克隆出来的产品对象
     */
    public ProductPrototype cloneProduct();
}

/**
 * 产品对象
 */
public class Product implements ProductPrototype{
    /**
     * 产品编号
     */
    private String productId;  

    /**
     * 产品名称
     */

    private String name;
    public String getName() {
       return name;
    }

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

    public String getProductId() {
       return productId;
    }

    public void setProductId(String productId) {
       this.productId = productId;
    }

    public String toString(){
       return "产品编号="+this.productId+"，产品名称="+this.name;
    }

    public ProductPrototype cloneProduct() {
       //创建一个新的订单，然后把本实例的数据复制过去
       Product product = new Product();
       product.setProductId(this.productId);
       product.setName(this.name);    
       return product;
    }
}

（2）订单的具体实现上也需要改变一下，需要在其属性上添加一个产品类型的属性，然后也需要实现克隆方法，示例代码如下：

public class PersonalOrder implements OrderApi{
    private String customerName;
    private int orderProductNum = 0;
    /**
     * 产品对象
     */
    private Product product = null;
    public int getOrderProductNum() {
       return this.orderProductNum;
    }  

    public void setOrderProductNum(int num) {
       this.orderProductNum = num;
    }  

    public String getCustomerName() {
       return customerName;
    }

    public void setCustomerName(String customerName) {
       this.customerName = customerName;
    }

    public Product getProduct() {
       return product;
    }

    public void setProduct(Product product) {
       this.product = product;
    }  

    public String toString(){
       //简单点输出
       return "订购产品是="+this.product.getName()+"，订购数量为="+this.orderProductNum;
    }

    public OrderApi cloneOrder() {
       //创建一个新的订单，然后把本实例的数据复制过去
       PersonalOrder order = new PersonalOrder();
       order.setCustomerName(this.customerName);
      order.setOrderProductNum(this.orderProductNum);
       //对于对象类型的数据，深度克隆的时候需要继续调用这个对象的克隆方法
       order.setProduct((Product)this.product.cloneProduct());
       return order;
    }
}

（3）写个客户端来测试看看，是否深度克隆成功，示例代码如下：

public class Client {

    public static void main(String[] args) {
       //先创建原型实例
       PersonalOrder oa1 = new PersonalOrder();
       //设置原型实例的值
       Product product = new Product();
       product.setName("产品1");
       oa1.setProduct(product);
       oa1.setOrderProductNum(100);
        System.out.println("这是第一次获取的对象实例="+oa1);
       //通过克隆来获取新的实例
        PersonalOrder oa2 = (PersonalOrder)oa1.cloneOrder();
       //修改它的值
        oa2.getProduct().setName("产品2");
       oa2.setOrderProductNum(80);
       //输出克隆出来的对象的值
       System.out.println("输出克隆出来的实例="+oa2);
       //再次输出原型实例的值
       System.out.println("再次输出原型实例="+oa1);
    }
}

（4）运行结果如下，很明显，我们自己做的深度克隆是成功的：

这是第一次获取的对象实例=订购产品是=产品1，订购数量为=100

输出克隆出来的实例=订购产品是=产品2，订购数量为=80

再次输出原型实例=订购产品是=产品1，订购数量为=100

（5）小结

看来自己实现深度克隆也不是很复杂，但是比较麻烦，如果产品类里面又有属性是引用类型的话，在产品类实现克隆方法的时候，又需要调用那个引用类型的克隆方法了，这样一层一层调下去，如果中途有任何一个对象没有正确实现深度克隆，那将会引起错误，这也是深度克隆容易出错的原因。

2：Java中的深度克隆

利用Java中的clone方法来实现深度克隆，大体上和自己做差不多，但是也有一些需要注意的地方，一起看看吧。

（1）产品类没有太大的不同，主要是把实现的接口变成了Cloneable，这样一来，实现克隆的方法就不是cloneProduct，而是变成clone方法了；另外一个是克隆方法的实现变成了使用“super.clone();”了，示例代码如下：

public class Product implements Cloneable{
    private String productId;  
    private String name;
    public String getName() {
       return name;
    }

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

    public String getProductId() {
       return productId;
    }

    public void setProductId(String productId) {
       this.productId = productId;
    }

    public String toString(){
       return "产品编号="+this.productId+"，产品名称="+this.name;
    }

    public Object clone() {
       Object obj = null;
       try {
           obj = super.clone();
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
       }
       return obj;
    }  
}

（2）具体的订单实现类，除了改变接口外，更重要的是在实现clone方法的时候，除了调用“super.clone();”外，必须显示的调用引用类型属性的clone方法，也就是产品的clone方法，示例代码如下：

public class PersonalOrder implements Cloneable , OrderApi{
    private String customerName;
    private Product product = null;
    private int orderProductNum = 0;  
    public int getOrderProductNum() {
       return this.orderProductNum;
    }  

    public void setOrderProductNum(int num) {
       this.orderProductNum = num;
    }  

    public String getCustomerName() {
       return customerName;
    }

    public void setCustomerName(String customerName) {
       this.customerName = customerName;
    }

    public Product getProduct() {
       return product;
    }

    public void setProduct(Product product) {
       this.product = product;
    }  

    public String toString(){
       //简单点输出
       return "订购产品是="+this.product.getName()+"，订购数量为="+this.orderProductNum;
    }

    public Object clone(){
       PersonalOrder obj=null;
       try {
           obj =(PersonalOrder)super.clone();
           //下面这一句话不可少
           obj.setProduct((Product)this.product.clone());
       } catch (CloneNotSupportedException e) {
           e.printStackTrace();
       }     
       return obj;
    }
}

（3）特别强调：

不可缺少“obj.setProduct((Product)this.product.clone());”这句话。为什么呢？

原因在于调用super.clone()方法的时候，Java是先开辟一块内存的空间，然后把实例对象的值原样拷贝过去，对于基本数据类型这样做是没有问题的，而属性product是一个引用类型，把值拷贝过去的意思就是把对应的内存地址拷贝过去了，也就是说克隆后的对象实例的product和原型对象实例的product指向的是同一块内存空间，是同一个产品实例。

       因此要想正确的执行深度拷贝，必须手工的对每一个引用类型的属性进行克隆，并重新设置，覆盖掉super.clone()所拷贝的值。

（4）客户端测试类跟刚才自己做的深度拷贝差不多，只是调用克隆的方法，原来是调用的cloneOrder方法，现在变成调用clone()。运行测试看看，运行结果如下：

这是第一次获取的对象实例=订购产品是=产品1，订购数量为=100

输出克隆出来的实例=订购产品是=产品2，订购数量为=80

再次输出原型实例=订购产品是=产品1，订购数量为=100

注意观察上面的数据，很明显这是正确的，修改克隆出来的实例的属性值，不会影响到原对象实例的属性的值。

（5）下面去掉“obj.setProduct((Product)this.product.clone());”这句话，看看会发生什么，运行结果如下：

这是第一次获取的对象实例=订购产品是=产品1，订购数量为=100

输出克隆出来的实例=订购产品是=产品2，订购数量为=80

再次输出原型实例=订购产品是=产品2，订购数量为=100

仔细观察一下，尤其是加粗的两行，你就会发现，修改克隆对象实例的产品名称属性的值，影响了原型对象实例的值，这说明没有正确深度克隆。

原型管理器

       如果一个系统中原型的数目不固定，比如系统中的原型可以被动态的创建和销毁，那么就需要在系统中维护一个当前可用的原型的注册表，这个注册表就被称为原型管理器。

       其实如果把原型当成一个资源的话，原型管理器就相当于一个资源管理器，在系统开始运行的时候初始化，然后运行期间可以动态的添加资源和销毁资源。从这个角度看，原型管理器就可以相当于一个缓存资源的实现，只不过里面缓存和管理的是原型实例而已。

       有了原型管理器过后，一般情况下，除了向原型管理器里面添加原型对象的时候是通过new来创造的对象，其余时候都是通过向原型管理器来请求原型实例，然后通过克隆方法来获取新的对象实例，这就可以实现动态管理、或者动态切换具体的实现对象实例。

       还是通过示例来说明，如何实现原型管理器。

（1）先定义原型的接口，非常简单，除了克隆方法，提供一个名称的属性，示例代码如下：

public interface Prototype {
    public Prototype clone();
    public String getName();
    public void setName(String name);
}

（2）再来看看两个具体的实现，实现方式基本上是一样的，分别看看。先看第一个原型的实现，示例代码如下：

public class ConcretePrototype1 implements Prototype {

    private String name;

    public String getName() {
       return name;
    }

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

    public Prototype clone() {
       ConcretePrototype1 prototype = new ConcretePrototype1();
       prototype.setName(this.name);
       return prototype;
    }

    public String toString(){
       return "Now in Prototype1，name="+name;
    }
}

再看看第二个原型的实现，示例代码如下：

public class ConcretePrototype2 implements Prototype {

    private String name;

    public String getName() {
       return name;
    }

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

    public Prototype clone() {
       ConcretePrototype2 prototype = new ConcretePrototype2();
       prototype.setName(this.name);
       return prototype;
    }  

    public String toString(){
       return "Now in Prototype2，name="+name;
    }
}

（3）接下来看看原型管理器的实现示意，示例代码如下：

/**
 * 原型管理器
 */
public class PrototypeManager {
    /**
     * 用来记录原型的编号和原型实例的对应关系
     */
    private static Map<String,Prototype> map = new HashMap<String,Prototype>();

    /**
     * 私有化构造方法，避免外部无谓的创建实例
     */

    private PrototypeManager(){

    }
    /*
     * 向原型管理器里面添加或是修改某个原型注册
     * @param prototypeId 原型编号
     * @param prototype 原型实例
     */

    public synchronized static void setPrototype(
String prototypeId,Prototype prototype){
       map.put(prototypeId, prototype);
    }

    /**
     * 从原型管理器里面删除某个原型注册
     * @param prototypeId 原型编号
     */
    public synchronized static void removePrototype(String prototypeId){
       map.remove(prototypeId);
    }

    /**
     * 获取某个原型编号对应的原型实例
     * @param prototypeId 原型编号
     * @return 原型编号对应的原型实例
     * @throws Exception 如果原型编号对应的原型实例不存在，报出例外
     */
    public synchronized static Prototype getPrototype(String prototypeId)throws Exception{
       Prototype prototype = map.get(prototypeId);
       if(prototype == null){
           throw new Exception("您希望获取的原型还没有注册或已被销毁");
       }
       return prototype;
    }
}

 大家会发现，原型管理器是类似一个工具类的实现方式，而且对外的几个方法都是加了同步的，这主要是因为如果在多线程环境下使用这个原型管理器的话，那个map属性很明显就成了大家竞争的资源，因此需要加上同步。

（4）接下来看看客户端，如何使用这个原型管理器，示例代码如下：

public class Client {

    public static void main(String[] args) {

       try {

           // 初始化原型管理器

           Prototype p1 = new ConcretePrototype1();

           PrototypeManager.setPrototype("Prototype1", p1);

 

           // 获取原型来创建对象

           Prototype p3 = PrototypeManager

.getPrototype("Prototype1").clone();

           p3.setName("张三");

           System.out.println("第一个实例：" + p3);

 

           // 有人动态的切换了实现

           Prototype p2 = new ConcretePrototype2();

           PrototypeManager.setPrototype("Prototype1", p2);

 

           // 重新获取原型来创建对象

           Prototype p4 = PrototypeManager

.getPrototype("Prototype1").clone();

           p4.setName("李四");

           System.out.println("第二个实例：" + p4);

 

           // 有人注销了这个原型

           PrototypeManager.removePrototype("Prototype1");

 

           // 再次获取原型来创建对象

           Prototype p5 = PrototypeManager

.getPrototype("Prototype1").clone();

           p5.setName("王五");

           System.out.println("第三个实例：" + p5);

       } catch (Exception err) {

           System.err.println(err.getMessage());

       }

    }

}

运行一下，看看结果，结果示例如下：

第一个实例：Now in Prototype1，name=张三

第二个实例：Now in Prototype2，name=李四

您希望获取的原型还没有注册或已被销毁

原型模式的优缺点

 对客户端隐藏具体的实现类型
    原型模式的客户端，只知道原型接口的类型，并不知道具体的实现类型，从而减少了客户端对这些具体实现类型的依赖。

在运行时动态改变具体的实现类型

    原型模式可以在运行期间，由客户来注册符合原型接口的实现类型，也可以动态的改变具体的实现类型，看起来接口没有任何变化，但其实运行的已经是另外一个类实例了。因为克隆一个原型就类似于实例化一个类。

深度克隆方法实现会比较困难
    原型模式最大的缺点就在于每个原型的子类都必须实现clone的操作，尤其在包含引用类型的对象时，clone方法会比较麻烦，必须要能够递归的让所有的相关对象都要正确的实现克隆。