从零开始学设计模式（五）——原型模式（Prototype Pat

原型模式

此模式难度系数为初级，由Gang Of Four提出。

原型模式是用于创建重复的对象，提高性能。这种模式实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。

例如一个对象需要在一个高代价的数据库操作或者远程连接之后被创建，我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库或者通知远程连接，以此来减少数据库或远程连接的调用。

意图

用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。

主要解决：在运行期建立和删除原型。

何时使用：
1、当一个系统应该独立于它的产品创建，构成和表示时。
2、当要实例化的类是在运行时刻指定时，例如，通过动态装载。
3、为了避免创建一个与产品类层次平行的工厂类层次时。
4、当一个类的实例只能有几个不同状态组合中的一种时。建立相应数目的原型并克隆它们可能比每次用合适的状态手工实例化该类更方便一些。

如何解决：利用已有的一个原型对象，快速地生成和原型对象一样的实例。

关键代码：
1、实现克隆操作，在 JAVA 中实现 Cloneable接口，重写 clone()方法。在 .NET 中可以使用 Object 类的 MemberwiseClone() 方法来实现对象的浅拷贝或通过序列化的方式来实现深拷贝。
2、原型模式同样用于隔离类对象的使用者和具体类型（易变类）之间的耦合关系，它同样要求这些"易变类"拥有稳定的接口。

解释

现实世界的例子

记得多莉吗？克隆的羊！让我们不要谈细节，这里的关键点全是克隆

简而言之

通过克隆基于现有对象来创建新对象

维基百科

原型模式是软件开发中一种创造性的设计模式。当要创建的对象类型由一个原型实例确定并使用时，该原型实例被克隆以产生新的对象。

简而言之，它允许你创建一个现有对象的副本，并根据你的需要修改它，而不是从头开始创建一个对象并设置它

程序示例

在Java中，可以通过实现java.lang.Cloneable接口并重写clone方法来轻易的做到克隆对象

class Sheep implements Cloneable {
  private String name;
  public Sheep(String name) { this.name = name; }
  public void setName(String name) { this.name = name; }
  public String getName() { return name; }
  @Override
  public Sheep clone() throws CloneNotSupportedException {
    return new Sheep(name);
  }
}

然后上面这个Sheep类对象可以被克隆如下：

Sheep original = new Sheep("Jolly");
System.out.println(original.getName()); // Jolly

// Clone and modify what is required
Sheep cloned = original.clone();
cloned.setName("Dolly");
System.out.println(cloned.getName()); // Dolly

应用场景

1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用

Java中的现实例子

• java.lang.Object#clone()

写在最后

注意事项：与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。
浅拷贝实现 Cloneable接口，重写clone方法，深拷贝是通过实现 Serializable接口 读取二进制流来实现

在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，我们可以随手拿来使用。

接下来我们就来编写一个原型模式与工厂方法模式相结合的程序代码示例。

我们有一个HeroFactory工厂，这个工厂可以生产不同类型的（兽族、精灵族）Mage(魔法师)、Warlord(军队)、Beast(兽王)，只是这些类型的产物在工厂中都不是直接New出来的，而是采用原型模式通过已有类型对象clone出来的。

首先我们画出这个程序的UML类图如下：

diagram-prototype

接下来根据类图，步骤一：编写Prototype抽象类

/**
 * 
 * Prototype
 *
 */
public abstract class Prototype implements Cloneable {

  public abstract Object copy() throws CloneNotSupportedException;

}

步骤二：编写继承Prototype的Beast、Warlord、Mage抽象类

/**
 * 
 * Beast
 *
 */
public abstract class Beast extends Prototype {

  @Override
  public abstract Beast copy() throws CloneNotSupportedException;

}
/**
 * 
 * Mage
 *
 */
public abstract class Mage extends Prototype {

  @Override
  public abstract Mage copy() throws CloneNotSupportedException;

}

/**
 * 
 * Warlord
 *
 */
public abstract class Warlord extends Prototype {

  @Override
  public abstract Warlord copy() throws CloneNotSupportedException;

}

步骤三：编写精灵族和兽人族具体子类，继承步骤二定义的抽象类

public class ElfBeast extends Beast {
  
  private String helpType;

  public ElfBeast(String helpType) {
    this.helpType = helpType;
  }

  public ElfBeast(ElfBeast elfBeast) {
    this.helpType = elfBeast.helpType;
  }

  @Override
  public Beast copy() throws CloneNotSupportedException {
    return new ElfBeast(this);
  }

  @Override
  public String toString() {
    return "Elven eagle helps in " + helpType;
  }

}

public class ElfMage extends Mage {

  
  private String helpType;
  
  public ElfMage(String helpType) {
    this.helpType = helpType;
  }

  public ElfMage(ElfMage elfMage) {
    this.helpType = elfMage.helpType;
  }

  @Override
  public ElfMage copy() throws CloneNotSupportedException {
    return new ElfMage(this);
  }

  @Override
  public String toString() {
    return "Elven mage helps in " + helpType;
  }

}

/**
 * 
 * ElfWarlord
 *
 */
public class ElfWarlord extends Warlord {

  private String helpType;
  
  public ElfWarlord(String helpType) {
    this.helpType = helpType;
  }

  public ElfWarlord(ElfWarlord elfWarlord) {
    this.helpType = elfWarlord.helpType;
  }

  @Override
  public ElfWarlord copy() throws CloneNotSupportedException {
    return new ElfWarlord(this);
  }

  @Override
  public String toString() {
    return "Elven warlord helps in " + helpType;
  }

}

public class OrcBeast extends Beast {
  
  private String weapon;

  public OrcBeast(String weapon) {
    this.weapon = weapon;
  }
  
  public OrcBeast(OrcBeast orcBeast) {
    this.weapon = orcBeast.weapon;
  }

  @Override
  public Beast copy() throws CloneNotSupportedException {
    return new OrcBeast(this);
  }

  @Override
  public String toString() {
    return "Orcish wolf attacks with " + weapon;
  }
  

}
//剩下的兽人OrcMage、OrcWarlord与上面的Elf类似编写即可...

步骤四：编写HeroFactory接口和它的实现类：

/**
 * 
 * Interface for the factory class.
 * 
 */
public interface HeroFactory {

  Mage createMage();

  Warlord createWarlord();

  Beast createBeast();

}

/**
 * 
 * Concrete factory class.
 * 
 */
public class HeroFactoryImpl implements HeroFactory {

  private Mage mage;
  private Warlord warlord;
  private Beast beast;

  /**
   * Constructor
   */
  public HeroFactoryImpl(Mage mage, Warlord warlord, Beast beast) {
    this.mage = mage;
    this.warlord = warlord;
    this.beast = beast;
  }

  /**
   * Create mage
   */
  public Mage createMage() {
    try {
      return mage.copy();
    } catch (CloneNotSupportedException e) {
      return null;
    }
  }

  /**
   * Create warlord
   */
  public Warlord createWarlord() {
    try {
      return warlord.copy();
    } catch (CloneNotSupportedException e) {
      return null;
    }
  }

  /**
   * Create beast
   */
  public Beast createBeast() {
    try {
      return beast.copy();
    } catch (CloneNotSupportedException e) {
      return null;
    }
  }

}

步骤五：编写App客户端类：

public class App {

  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);

  /**
   * Program entry point
   * 
   * @param args command line args
   */
  public static void main(String[] args) {
    HeroFactory factory;
    Mage mage;
    Warlord warlord;
    Beast beast;

    factory = new HeroFactoryImpl(new ElfMage("cooking"), new ElfWarlord("cleaning"), new ElfBeast("protecting"));
    mage = factory.createMage();
    warlord = factory.createWarlord();
    beast = factory.createBeast();
    LOGGER.info(mage.toString());
    LOGGER.info(warlord.toString());
    LOGGER.info(beast.toString());

    factory = new HeroFactoryImpl(new OrcMage("axe"), new OrcWarlord("sword"), new OrcBeast("laser"));
    mage = factory.createMage();
    warlord = factory.createWarlord();
    beast = factory.createBeast();
    LOGGER.info(mage.toString());
    LOGGER.info(warlord.toString());
    LOGGER.info(beast.toString());
  }
}

最后运行App类，程序输出如下：

17:04:21.430 [main] INFO com.iluwatar.prototype.App - Elven mage helps in cooking
17:04:21.433 [main] INFO com.iluwatar.prototype.App - Elven warlord helps in cleaning
17:04:21.434 [main] INFO com.iluwatar.prototype.App - Elven eagle helps in protecting
17:04:21.434 [main] INFO com.iluwatar.prototype.App - Orcish mage attacks with axe
17:04:21.434 [main] INFO com.iluwatar.prototype.App - Orcish warlord attacks with sword
17:04:21.434 [main] INFO com.iluwatar.prototype.App - Orcish wolf attacks with laser

原型模式中主要有三个登场角色：
1、原型角色：定义用于复制现有实例来生成新实例的方法，上面的例子中Prototype类即是。
2、具体原型角色：实现用于复制现有实例来生成新实例的方法，上面的例子中ElfBeast、ElfMage、ElfWarlord、Orc...等都是。
3、使用者角色：维护一个注册表，并提供一个找出正确实例原型的方法。最后，提供一个获取新实例的方法，用来委托复制实例的方法生成新实例。上面的例子中HeroFactoryImpl即是。

以上，原型模式我就在这里介绍完毕，至此设计模式中创建型模式我们已全部学习完毕。

大家可以试着去把工厂模式、抽象工厂模式、单例模式、建造者模式和今天学习的原型模式组合起来使用，每次组合1-2种设计模式来设计你的应用程序吧，自主设计出来你肯定会有意想不到的收获和体验的。

下一篇文章我们将学习结构性模式中的适配器模式（Adapter Pattern）

码字不易，各位看官如果喜欢的话，请给点个喜欢❤️，关注下我，我将努力持续不断的更新