创建型模式之原型模式(Java版)

设计模式概述及分类:https://blog.csdn.net/qq_34896730/article/details/105324092

面向对象设计原则：https://editor.csdn.net/md/?articleId=105352240

      原型模式是一种特殊的创建型模式，它通过复制一个已有对象来获取更多相同或者相似的对象。原型模式可以提高相同类型对象的创建效率，简化创建过程。

1 原型模式概述

      《西游记》中孙悟空“拔毛变小猴”，孙悟空可以用猴毛根据自己的形象复制出很多跟自己长得一模一样的“身外身”来，如图1-1所示。

图1-1 孙悟空拔毛变小猴

      孙悟空这种根据自己的形状复制(克隆)出多个身外身的技巧在面向对象软件设计领域被称为原型模式，孙悟空则被称为原型对象。在面向对象系统中也可以通过复制一个原型对象得到多个与原型对象一模一样的新对象，这就是原型模式的动机。

      原型模式的定义如下：使用原型实例指定待创建对象的类型，并且通过复制这个原型来创建新的对象。
      原型模式是一种对象创建型模式，它的工作原理：将一个原型对象传给要发动创建的对象(即客户端对象)，这个要发动创建的对象通过请求原型对象复制自己来实现创建过程。由于在软件系统中经常会遇到需要创建多个相同或者相似对象的情况，因此原型模式在软件开发中具有较高的使用频率。原型模式是一种“另类”的创建型模式，创建新对象(也称克隆对象)的工厂就是原型类自身，工厂方法由负责复制原型对象的克隆方法来实现。
      需要注意的是通过克隆方法所创建的对象是全新的对象，它们在内存中拥有新的地址，通常对克隆所产生的对象进行修改不会对原型对象造成任何影响，每一个克隆对象都是相互独立的，通过不同的方法对克隆对象进行修改以后，可以得到一系列相似但不完全相同的对象。

2 原型模式结构与实现

2.1 原型模式结构

      原型模式结构如图2-1所示。

图2-1 原型模式结构图

      由图2-1可知，原型模式包含以下3个角色。

      （1）Prototype(抽象原型类) ：它是声明克隆方法的接口，是所有具体原型类的公共父类，它可以是抽象类也可以是接口，甚至还可以是具体实现类。
      （2）ConcretePrototype(具体原型类)：它实现在抽象原型类中声明的克隆方法，在克隆方法中返回自己的一个克隆对象。
      （3）Client(客户类)：在客户类中，让一个原型对象克隆自身从而创建一个新的对象，只需要直接实例化或通过工厂方法等方式创建一个原型对象，再通过调用该对象的克隆方法即可得到多个相同的对象。由于客户类针对抽象原型类Prototype编程，因此用户可以根据需要选择具体原型类，系统具有较好的可扩展性，增加或更换具体原型类都很方便。

2.2 浅克隆与深克隆

      根据在复制原型对象的同时是否复制包含在原型对象中引用类型的成员变量，原型模式的克隆机制分为两种，即浅克隆(Shallow Clone)和深克隆(Deep Clone)。
      1. 浅克隆
      在浅克隆中，如果原型对象的成员变量是值类型(如int、double、byte、boolean、char等基本数据类型)，将复制一份给克隆对象；如果原型对象的成员变量是引用类型(如类、接口、数组等复杂数据类型)，则将引用对象的地址复制一份给克隆对象，也就是说原型对象和克隆对象对的成员变量指向相同的内存地址。简单来说，在浅克隆中，当原型对象被复制时只复制它本身和其中包含的值类型的成员变量，而引用类型的成员变量并没有复制，如图2-2所示。

图2-2 浅克隆示意图

      2. 深克隆
      在深克隆中，无论原型对象的成员变量是值类型还是引用类型，都将复制一份给克隆对象，深克隆将原型对象的所有引用对象也复制一份给克隆对象。简单来说，在深克隆中，除了对象本身被复制外，对象所包含的所有成员变量也将被复制，如图2-3所示。

图2-3 深克隆示意图

2.3 原型模式实现

      实现原型模式的关键在于如何实现克隆方法，下面介绍两种在Java语言中常用的克隆实现方法。
      1. 通用实现方法
      通用的克隆实现方法是在具体原型类的克隆方法中实例化一个与自身类型相同的对象并将其返回，同时将相关的参数传入新创建的对象中，保证它们的成员变量相同。示意代码如下：

public abstract class Prototype{
   public abstract Prototype clone();
}

public class ConcretePrototype extends Prototype{
    private String attr;
    public void setAttr(String attr){
       this.attr = attr;
    }
    public void getAttr(){
        return this.attr;
    }
    //克隆方法
    public Prototype clone(){
       Prototype prototype = new ConcretePrototype ();//创建对象
       prototype.setAttr(this.attr);
       return prototype;
    }
}

      在客户类中只需要创建一个ConcretePrototype对象作为原型对象，然后调用其clone()方法即可得到对应的克隆对象，例如：

...
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAttr("Sunny");
ConcretePrototype copy = (ConcretePrototype)prototype.clone();
...

      此方法是原型模式的通用实现，它与编程语言本身的特性无关，其他面向对象编程语言也可以使用这种形式来实现对原型对象的克隆。
      在原型模式的通用实现方法中，可通过手动编写clone()方法来实现浅克隆和深克隆。对于引用类型的对象，可以在clone()方法中通过赋值的方式来实现复制，这是一种浅克隆实现方案；如果在clone()方法中通过创建一个全新的成员对象来实现复制，则是一种深克隆实现方案。
      2. Java语言中的clone()方法和Cloneable接口
      在Java语言中，所有的Java类均继承自java.lang.Object类，Object类提供了一个clone()方法，可以将一个Java对象复制一份。因此在Java中可以直接使用Object提供的clone()方法来实现对象的浅克隆。
      需要注意的是能够实现克隆的Java类必须实现一个标识接口Cloneable,标识这个Java类支持被复制。如果一个类没有实现这个接口但是调用了clone()方法，Java编译器将抛出一个CloneNotSupportedException异常。如下代码所示：

public class ConcretePrototype implements Cloneable{
...
public Prototype clone(){
  Object object = null;
  try{
      object = super.clone();//浅克隆
  }catch(CloneNotSupportedException exception){
    System.err.println("Not support cloneable");
 } 
 return (Prototype)object;
}
...
}

      在客户端创建原型对象和克隆对象，如下代码所示：

Prototype prototype = new ConcretePrototype();
Prototype copy = prototype.clone();

      Java语言中的clone()方法满足以下几点：
      (1) 对任何对象x,都有x.clone()!=x,即克隆对象与原型对象不是一个对象。
      (2) 对任何对象x,都有x.clone().getClass() == x.getClass(),即克隆对象与原型对象的类型一样。
      (3) 如果对象x的equals()方法定义恰当，那么x.clone.equals(x)应该成立。
      为了获取对象的一个克隆，可以直接利用Object类的clone()方法，具体步骤如下：
      (1) 在派生类中覆盖基类的clone()方法，并声明为public。
      (2) 在派生类的clone()方法中调用super.clone()。
      (3) 派生类需实现Cloneable接口。
      此时，Object类相当于抽象原型类，所有实现了Cloneable接口的类相当于具体原型类。

3 原型模式应用实例

      下面通过一个应用实例来学习和理解原型模式。
      1. 实例说明
      在使用某OA系统时，有些岗位的员工发现他们每周的工作都大同小异，因此在填写工作周报时很多内容都是重复的，为了提高工作周报的创建效率，大家迫切希望有一种机制能够快速创建相同或者相似的周报，包括创建周报的附件。
      2. 实例类图

图3-1 工作周报创建模块结构图(浅克隆)

      在图3-1中，WeeklyLog充当具体原型类，Object类充当抽象原型类，Attachment充当成员类，WeeklyLog中的clone()方法为克隆方法，用于实现原型对象的克隆。

      3. 实例代码
      (1) Attachment : 附件类。

public class Attachment{
    private String name;//附件名
    public void setName(String name){
       this.name = name;
    }
    public String getName(){
       return this.name;
    }
    public void download(){
      System.out.println("下载附件，文件名为"+name);
    }
}

      (2) WeeklyLog:工作周报类，充当原型角色。在真实环境下该类比较复杂，考虑到代码的可读性，在此只列出部分与模式相关的核心代码。

public class WeeklyLog implements Cloneable{
   //为了简化设计和实现，假设一份工作周报中只有一个附件对象，在实际情况中可以包含多个附件，可以通过List等集合对象来实现
   private Attachment attachment;
   private String name;
   private String date;
   private String content;
   public void setAttachment(Attachment attachment){
     this.attachment = attachment;
  }
  public void setName(String name){
     this.name = name;
  }
  public void setDate(String date){
     this.date = date;
  }
  public void setContent(String content){
     this.content = content;
  }
  public Attachment getAttachment(){
     return (this.attachment);
  }
  public String getName(){
     return (this.name);
  }
  public String getDate(){
     return (this.date);
  }
  public String getContent(){
     return (this.content);
  }
  //使用clone()方法实现浅克隆
  public WeeklyLog clone(){
    Object obj = null;
    try{
      obj = super.clone();
      return (WeeklyLog)obj;
    }catch(CloneNotSupportedException e){
      System.out.println("不支持复制！");
      return null;
    }
  }
}

      (3) Client:客户端测试类。

public class Client{
  public static void main(String args[]){
    WeeklyLog log_previous,log_new;
    log_previous = new WeeklyLog();//创建原型对象
    Attachment attachment =  new Attachment();//创建附件对象
    log_previous.setAttachment(attachment);//将附件添加到周报中
    log_new = log_previous.clone();//调用克隆方法创建克隆对象
    //比较周报
    System.out.println("周报是否相同？"+(log_previous==log_new));
    System.out.println("附件是否相同？"+(log_previous.getAttachment()==log_new.getAttachment()))
  }
}

      4. 结果及分析
      编辑并运行程序，输出结果如下：

周报是否相同？false
附件是否相同？true

      从输出结果可以得知，在本实例中周报对象被成功复制，但是附件对象并没有被复制，实现了浅克隆。
      5. 深克隆解决方案
      为了能够在复制周报的同时也能复制附件对象，需要采用深克隆机制。在Java语言中可以通过序列化(Serialization)等方式来实现深克隆。序列化就是将对象写到流的过程，写到流中的对象是原有对象的一个复制，而原对象仍然存在于内存中。通过序列化实现的复制不仅可以复制对象本身，而且可以复制其引用的成员对象，因此通过序列化将对象写到一个流中，再从流中将其读出来，可以实现深克隆。需要注意的是能够实现序列化的对象其类必须实现Serializable接口，否则无法实现序列化操作。
      下面使用深克隆技术来实现工作周报和附件对象的复制，由于要将附件对象和工作周报对象写入到流中，因此这两个类均需要实现Serializable接口，其结构如图3-1所示。

图3-2 工作周报创建模块结构图(深克隆)

      修改后的附件类Attachment的代码如下：

public class Attachment implements Serializable{
   private String name;//附件名
   public void setName(String name){
     this.name = name;
   }
   public String getName(){
     return this.name;
   }
   public void download(){
      System.out.println("下载附件，文件名"+name);
   }
}

      工作周报WeeklyLog不再使用Java自带的克隆机制，而是通过序列化从头实现对象的深克隆，编写deepClone()方法实现深克隆。修改后的WeeklyLog类的代码如下：

public class WeeklyLog implements Serializable{
   private Attachment attachment;
   private String name;
   private String date;
   private String content;
   public void setAttachment(Attachment attachment){
     this.attachment = attachment;
  }
  public void setName(String name){
     this.name = name;
  }
  public void setDate(String date){
     this.date = date;
  }
  public void setContent(String content){
    this.content = content;
  }
   public Attachment getAttachment(){
     return (this.attachment);
  }
  public String getName(){
     return (this.name);
  }
  public String getDate(){
     return (this.date);
  }
  public String getContent(){
     return (this.content);
  }
  //使用序列化技术实现深克隆
  public WeeklyLog deepClone()throws IOEXCeption,ClassNotFoundException,OptionalDataException{
   //将对象写入流中
   ByteArrayOutputStream bao = new ByteArrayOutputStream();
   ObjectOutputStream oos = new ObjectOutputStream(bao);
   oos.writeObject(this);
   //将对象从流中去除
   ByteArrayInputStream bis = new ByteArrayInputStream(bao.toByteArray());
   ObjectInputStream ois = new ObjectInputStream(bis);
   return (WeeklyLog)ois.readObject;
 }
}

      客户端测试类Client的代码修改如下：

public class Client{
  public static void main(String args[]){
    WeeklyLog log_previous,log_new=null;
    log_previous = new WeeklyLog;//创建原型对象
    Attachment attachment = new Attachment();//创建附件对象；
    log_previous.setAttachment(attachment);//将附件添加到周报中
    try{
       log_new = log_previous.deepClone();//调用深克隆方法创建对象
    }catch(Exception e){
      System.err.println("克隆失败！");
    }
    //比较周报
    System.out.println("周报是否相同？"+(log_previous==log_new));
    System.out.println("附件是否相同？"+(log_previous.getAttachment()==log_new.getAttachment()))
  }
}

      运行程序，输出结果如下：

周报是否相同？false
附件是否相同？false

      从输出结果可以得知，本实例中在成功复制周报对象的同时附件对象也被复制，实现了深克隆。
      在上述深克隆实现代码中，首先使用序列化将当前对象写入流中，然后使用反序列化从流中获取对象。由于序列化时一个对象的成员对象将伴随该对象一起被写入流中，在反序列化时将得到一个包含成员对象的新对象，因此可采用序列化和反序列化联用来实现深克隆。

4 原型管理器

      原型管理器(Prototype Manager)将多个原型对象存储在一个集合中供客户端使用，它是一个专门负责克隆对象的工厂，其中定义了一个集合用于存储原型对象，如果需要某个原型对象的一个克隆，可以通过复制集合中对应的原型对象来获得。在原型管理器中针对抽象原型类进行编程，以便扩展，其结构如图4-1所示。

图4-1 带原型管理器的原型模式

      在图4-1中，典型的原型管理器PrototypeManager类的实现代码片段如下：

public class PrototypeManager{
   private Hashtable prototypeTable = new Hashtable();//使用Hashtable存储原型对象
   public PrototypeManager(){
      prototypeTable.put("A",new ConcretePrptotypeA());
      prototypeTable.put("B",new ConcretePrptotypeB());
   }
   public void add(String key,Prototype prototype){
     prototypeTable.put(key,prototype);
  }
  public Prototype get(String key){
      Prototype clone = null;
      clone = (Prototype)prototypeTable.get(key)).clone();//通过克隆方法创建新对象
      return clone;
  }
}

      在实际开发中可以将PrototypeManager设计为单例类，确保系统中有且仅有一个PrototypeManager对象，这样既有利于节省系统资源，还可以更好地对原型管理器对象进行控制。

5 原型模式优/缺点与适用环境

       原型模式作为一种快速创建大量相同或相似对象的方式，在软件开发中的应用较为广泛，很多软件提供的复制(Ctrl+C)和粘贴(Ctrl+V)操作就是原型模式的典型应用。

5.1 原型模式优点

       (1) 当创建新的对象实例较为复杂时，使用原型模式可以简化对象的创建过程，通过复制一个已有实例可以提高新实例的创建效率。
       (2) 扩展性较好，由于在原型模式中提供了抽象原型类，在客户端可以针对抽象原型类进行编程，而将具体原型类写在配置文件中，增加或减少产品类对原有系统没有任何影响。
       (3) 原型模式提供了简化的创建结构，工厂方法模式常常需要有一个与产品类等级结构相同的工厂等级结构，而原型模式就不需要这样，原型模式中产品的复制是通过封装在原型类中的克隆方法实现的，无须专门的工厂类来创建产品。
       (4) 可以使用深克隆的方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，以便需要的时候使用(例如恢复到某一历史状态)，可辅助实现撤销操作。

5.2 原型模式缺点

      (1) 需要为每一个类配备一个克隆方法，而且该克隆方法位于一个类的内部，当对已有的类进行改造时需要修改源代码，违背了开闭原则。
      (2) 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重的嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来可能会比较麻烦。

5.3 原型模式适用环境

      (1) 创建新对象成本较大(例如初始化需要占用较长的时间，占用太多的CPU资源或网络资源)，新对象可以通过复制已有对象来获得，如果是相似对象，则可以对其成员变量稍作修改。
      (2) 系统要保存对象的状态，而对象的状态变化很小。
      (3) 需要避免使用分层次的工厂类来创建分层次的对象，并且类的实例对象只有一个或很少的几个组合状态，通过复制原型对象得到新实例可能比使用构造函数创建一个新实例更加方便。