Java设计模式--原型模式（ProtoType）

概述

---

• 定义：使用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
• 原型模式是一种对象创建型模式。
• 实现：需要实现Cloneable接口；
• 核心：clone()方法。通过clone()方式，返回对应的对象；clone()方法不会执行类的构造方法；ShadowCopy & DeepCopy
• 学习难度：★★★☆☆
• 使用频率：★★★☆☆

优缺点

---

• 优点
  • 使用clone 能够动态的抽取当前对象运行时的状态并且克隆到新的对象中，新对象就可以在此基础上进行操作而不损坏原有对象。
• 缺点
  • 就是每个原型必须含有clone 方法，由于clone方法在java 实现中有着一定的弊端和风险，所以clone 方法是不建议使用的。

类图

---

组成角色

---

• 抽象原型角色（Prototype）
• 具体原型角色（ConcretePrototype）
• 客户角色（Client）
• 原型管理器（可选）（PrototypeManager）

Code Example

---

抽象原型角色（Prototype）

/**
 * 抽象原型角色<br>
 * 原型必须实现clone方法：<br>
 * 1、实现Cloneable接口，这个接口下是没有方法的，只有实现了这个接口，利用object的clone()才会返回拷贝，
 * 否则会抛出CloneNotSupportedException 。<br>
 * 2、重写clone()方法：调用Object的clone()方法进行克隆。 <br>
 * 3、clone()是不会调用构造方法的
 * 
 * 
 * @author yanbin
 * 
 */
public class Prototype implements Cloneable {

   @Override
   public Object clone() {
      Prototype p = null;
      try {
         p = (Prototype) super.clone();
      } catch (CloneNotSupportedException e) {
         e.printStackTrace();
      }
      return p;
   }

}

具体原型角色（ConcretePrototype）

/**
 * 具体原型角色
 * 
 * @author yanbin
 * 
 */
public class ConcretePrototype extends Prototype {

   public ConcretePrototype() {
      System.out.println("具体原型角色！");
   }

}

客户角色（Client）

/**
 * 客户角色
 * 
 * @author yanbin
 * 
 */
public class Client {

   public void test() {
      ConcretePrototype concretePrototype = new ConcretePrototype();
      Prototype prototype = (Prototype) concretePrototype.clone();
      System.out.println(concretePrototype);
      System.out.println(prototype);

      // 通过原型管理器角色
      Prototype p = PrototypeManager.getManager().getPrototype("prototype.ConcretePrototype");
      Prototype pClone = PrototypeManager.getManager().getPrototype("prototype.ConcretePrototype");
      System.out.println(p);
      System.out.println(pClone);
   }

}

原型管理器（可选）（PrototypeManager）

/**
 * 原型管理器：创建原型角色、拷贝原型角色就与客户程序分离开来 （可选）<br>
 * 1、保存一个原型对象的清单，我们可以使用一个HashMap 来实现<br>
 * 2、原型管理器只需要一个就够了，所以可以使用单例模式来实现控制
 * 
 * @author yanbin
 * 
 */
public class PrototypeManager {

   private static PrototypeManager pm;

   private Map<String, Object> prototypes = null;

   private PrototypeManager() {
      prototypes = new HashMap<String, Object>();
   }

   // (饿汉单例)使用单例模式来得到原型管理器的唯一实例
   public static PrototypeManager getManager() {
      if (pm == null) {
         pm = new PrototypeManager();
      }
      return pm;
   }

   /**
    * 添加原型
    * 
    * @param name
    * @param prototype
    */
   public void add(String name, Object prototype) {
      prototypes.put(name, prototype);
   }

   /**
    * 删除原型
    * 
    * @param name
    */
   public void delete(String name) {
      prototypes.remove(name);
   }

   /**
    * 获取需要的原型
    * 
    * @param name
    * @return
    */
   public Prototype getPrototype(String name) {
      Prototype object = null;
      // 如果清单中包含需要的原型名称
      if (prototypes.containsKey(name)) {
         // 将清单中对应原型的复制品返回给客户
         Prototype p = (Prototype) prototypes.get(name);
         // 克隆
         object = (Prototype) p.clone();
      } else {
         // 清单中不存在需要的原型
         try {
            // 利用反射创建需要的势力
            object = (Prototype) Class.forName(name).newInstance();
            // 并将实例添加到原型清单中
            add(name, object);
         } catch (Exception e) {
            System.err.println("Class " + name + "没有定义!");
         }
      }
      return object;
   }

}

客户端

/**
 * 原型模式（clone）：属于对象创建模式，用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。<br>
 * 组成：客户角色，抽象原型角色，具体原型角色。原型管理器（可选）。<br>
 * 原型模式和工厂模式很类似：可以说原型模式就是在工厂模式的基础上加入了克 隆方法。<br>
 * 使用 clone 方法产生对象和new 一个对象的区别：原型模式使用clone 能够动态的抽取当前对象运行时的状态并且克隆到新的对象中，新
 * 对象就可以在此基础上进行操作而不损坏原有对象；而new 只能得到一个刚初始化的对象， 而在实际应用中，这往往是不够的。<br>
 * 原型模式主要的缺陷：就是每个原型必须含有clone 方法，在 已有类的基础上来添加clone 操作是比较困难的；而且当内部包括一些不支持copy 或者循
 * 环引用的对象时，实现就更加困难了。<br>
 * 由于 clone 方法在java 实现中有着一定的弊端和风险，所以clone 方法是不建议使用的。
 * 
 * @author yanbin
 * 
 */
public class PrototypePatten {

   public static void main(String[] args) {
      Client client = new Client();
      client.test();
   }

}