1. 「引例」

发送广告信，需要一个模块，然后从数据库中把客户的信息一个一个取出来，放到模板中生成一份完整邮件。

广告信模板

public class AdvTemplate {
  //广告信名称
  private String advSubject = "XX银行国庆信用卡抽奖活动";
  // 广告信内容
  private String advContext = "国庆抽奖活动通知：只要刷卡就送你一百万！...";
  // 取得广告信的名称
  public String getAdvSubject() {
      return this.advSubject;
  }
  //取得广告信的内容
  public String getAdvContext() {
      return this.advContext;
  }
}

邮件类Mail

public class Mail {
  //收件人
  private String receiver;
  // 邮件名称
  private String subject;
  // 称谓
  private String appellation;
  // 邮件内容
  private String contxt;
  // 邮件的尾部，一般都是加上"XXX版权所有"等信息
  private String tail;
  // 构造函数
  public Mail(AdvTemplate advTemplate) {
      this.contxt = advTemplate.getAdvContext();
      this.subject = advTemplate.getAdvSubject();
  }
  // getter & setter 下面省略...
}

Test

class Client {
  //发送账单的数量，这个值是从数据库中获得
  private static int MAX_COUNT = 6;
  @Test
  public void test() {
      //模拟发送邮件
      int i = 0;
      // 把模板定义出来，这个是从数据库中获得
      Mail mail = new Mail(new AdvTemplate());
      mail.setTail("XX银行版权所有");
      while (i < MAX_COUNT) {
          // 以下是每封邮件不同的地方
          mail.setAppellation(getRandString(5) + " 先生（女士）");
          mail.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
          // 然后发送邮件
          sendMail(mail);
          i++;
      }
  }
  //发送邮件
  public static void sendMail(Mail mail) {
      System.out.println("标题：" + mail.getSubject() + "\t收件人： " + mail.getReceiver() + "\t...发送成功！");
  }
  //获得指定长度的随机字符串
  public static String getRandString(int maxLength) {
      String source = "abcdefghijklmnopqrskuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ";
      StringBuffer sb = new StringBuffer();
      Random rand = new Random();
      for (int i = 0; i < maxLength; i++) {
          sb.append(source.charAt(rand.nextInt(source.length())));
      }
      return sb.toString();
  }
}

标题：XX银行国庆信用卡抽奖活动收件人： kaoXV@sPmBeZNU.com…发送成功！标题：XX银行国庆信用卡抽奖活动收件人： FRzgw@ngzzDbcX.com …发送成功！标题：XX银行国庆信用卡抽奖活动收件人： zRSoD@YDVkdekn.com …发送成功！标题：XX银行国庆信用卡抽奖活动收件人： uPghN@sdxcHCfr.com …发送成功！标题：XX银行国庆信用卡抽奖活动收件人： kOPkq@ZWiRZfFk.com …发送成功！标题：XX银行国庆信用卡抽奖活动收件人： XyLcO@jAvkRpvk.com …发送成功！

由于是随机数，每次运行都有所差异，不管怎么样，这个电子账单发送程序是编写出来了，也能正常发送。我们再来仔细地想想，这个程序是否有问题？这是一个线程在运行，也就是你发送的是单线程的，那按照一封邮件发出去需要0.02秒（够小了，还要到数据库中取数据），600万封邮件需要33个小时，也就是一个整天都发送不完。
现在把sendMail修改为多线程，但是只把sendMail修改为多线程还是有问题的，产生第一封邮件对象，放到线程1中运行，还没有发送出去；线程2也启动了，直接就把邮件对象mail的收件人地址和称谓修改掉了，线程不安全。说到这里，你会说这有N多种解决办法，其中一种是使用一种新型模式来解决这个问题：通过对象的复制功能来解决这个问题：

增加了一个Cloneable接口（Java自带的一个接口）， Mail实现了这个接口，在Mail类中覆写clone()方法。

public class Mail implements Cloneable {
  //收件人
  private String receiver;
  // 邮件名称
  private String subject;
  // 称谓
  private String appellation;
  // 邮件内容
  private String contxt;
  // 邮件的尾部，一般都是加上"XXX版权所有"等信息
  private String tail;
  // 构造函数
  public Mail(AdvTemplate advTemplate) {
      this.contxt = advTemplate.getAdvContext();
      this.subject = advTemplate.getAdvSubject();
  }
  @Override
  public Mail clone() {
      Mail mail = null;
      try {
          mail = (Mail) super.clone();
      } catch (CloneNotSupportedException e) {
          e.printStackTrace();
      }
      return mail;
  }
  // getter & setter
}

实现了一个接口，并重写了clone方法

@Test
public void test2() {
  //模拟发送邮件
  int i = 0;
  // 把模板定义出来，这个是从数据库中获得
  Mail mail = new Mail(new AdvTemplate());
  mail.setTail("XX银行版权所有");
  while (i < MAX_COUNT) {
      //以下是每封邮件不同的地方
      Mail cloneMail = mail.clone();
      cloneMail.setAppellation(getRandString(5) + " 先生（女士）");
      cloneMail.setReceiver(getRandString(5) + "@" + getRandString(8) + ".com");
      // 然后发送邮件
      sendMail(cloneMail);
      i++;
  }
}

运行结果不变，一样完成了电子广告信的发送功能，而且sendMail即使是多线程也没有关系。
📌注意，看Client类中的mail.clone()这个方法，把对象复制一份，产生一个新对象，和原有对象一样，然后再修改细节的数据，如设置称谓、设置收件人地址等。这种不通过new关键字来产生一个对象，而是通过对象复制来实现的模式就叫做原型模式。

2. 「定义」

Specify the kinds of objects to create using a prototypical instance,and create new objects by copying this prototype.

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

原型模式（Prototype Pattern）的简单程度仅次于单例模式和迭代器模式。正是由于简单，使用的场景才非常地多。

通用类图

原型模式的核心是一个clone方法，通过该方法进行对象的拷贝，Java提供了一个Cloneable接口来「标示」这个对象是可拷贝的。
「标示」的理解：public interface Cloneable {}是一个空接口。这个接口只是一个标记作用，在JVM中具有这个标记的对象才有可能被拷贝。
怎么才能从“有可能被拷贝”转换为“可以被拷贝”？方法是覆盖clone()方法，是的，是重写clone()方法，看看上面Mail类中的clone方法。@Override public Mail clone() {}
在clone()方法上增加了一个注解@Override，没有继承一个类为什么可以覆写？因为覆写的是Object类（所有类的父类），所以用覆写是正确的——覆写Object类中的clone方法。

通用源码

public class PrototypeClass implements Cloneable {
  @Override
  public PrototypeClass clone() {
      PrototypeClass prototypeClass = null;
      try {
          prototypeClass = (PrototypeClass) super.clone();
      } catch (CloneNotSupportedException e) {
          //异常处理
      }
      return prototypeClass;
  }
}

3. 「应用」

1. 「优点」

性能优良
- 原型模式是在内存二进制流的拷贝，要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
逃避构造函数的约束
- 这既是它的优点也是缺点，直接在内存中拷贝，构造函数是不会执行的（参见下面的「注意事项」）。优点就是减少了约束，缺点也是减少了约束，需要在实际应用时考虑。

2. 「使用使用场景」

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

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

4. 「注意事项」

1. 「构造函数不会被执行」

一个实现了Cloneable并重写了clone方法的类A，有一个无参构造或有参构造B，通过 new关键字产生了一个对象S，再然后通过S.clone()方式产生了一个新的对象T，那么在对象拷贝时构造函数B是不会被执行的。

public class Thing implements Cloneable {
    public Thing() {
        System.out.println("构造函数被执行了...");
    }
    @Override
    public Thing clone() {
        Thing thing = null;
        try {
            thing = (Thing) super.clone();
        } catch (CloneNotSupportedException e) {
            e.printStackTrace();
        }
        return thing;
    }
}
// Test
class Client {
    @Test
    public void test() {
        //产生一个对象
        Thing thing = new Thing();
        // 拷贝一个对象
        Thing cloneThing = thing.clone();
    }
}

构造函数被执行了…

对象拷贝时构造函数确实没有被执行，这点从原理来讲也是可以讲得通，Object类的 clone方法的原理是从内存中（具体地说就是堆内存）以二进制流的方式进行拷贝，重新分配一个内存块，那构造函数没有被执行也是非常正常的。

2. 「浅拷贝和深拷贝」

浅拷贝

public class Thing implements Cloneable {
  //定义一个私有变量
  private ArrayList<String> arrayList = new ArrayList<String>();
  // @Override
  public Thing clone() {
      Thing thing = null;
      try {
          thing = (Thing) super.clone();
      } catch (CloneNotSupportedException e) {
          e.printStackTrace();
      }
      return thing;
  }
  //设置HashMap的值
  public void setValue(String value) {
      this.arrayList.add(value);
  } 
  //取得arrayList的值
  public ArrayList<String> getValue() {
      return this.arrayList;
  }
}

在Thing类中增加一个私有变量arrayList，类型为ArrayList，然后通过setValue和getValue分别进行设置和取值，看场景类是如何拷贝的。

public class Thing implements Cloneable {
  //定义一个私有变量
  private ArrayList<String> arrayList = new ArrayList<String>();
  // @Override
  public Thing clone() {
      Thing thing = null;
      try {
          thing = (Thing) super.clone();
      } catch (CloneNotSupportedException e) {
          e.printStackTrace();
      }
      return thing;
  }
  //设置HashMap的值
  public void setValue(String value) {
      this.arrayList.add(value);
  }
  //取得arrayList的值
  public ArrayList<String> getValue() {
      return this.arrayList;
  }
}
// Test
class Client {
  @Test
  public void test() {
      //产生一个对象
      Thing thing = new Thing();
      // 设置一个值
      thing.setValue("张三");
      // 拷贝一个对象
      Thing cloneThing = thing.clone();
      cloneThing.setValue("李四");
      System.out.println(thing.getValue());
  }
}

[张三, 李四]

怎么会有李四？因为Java做了一个偷懒的拷贝动作，Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向原生对象的内部元素地址，这种拷贝就叫做「浅拷贝」。
两个对象共享了一个私有变量，是一种非常不安全的方式，在实际项目中使用还是比较少的。
为什么在Mail那个类中就可以使用String类型，而不会产生由浅拷贝带来的问题？内部的数组和引用对象才不拷贝，其他的原始类型比如int、long、char等都会被拷贝，但是对于String类型，Java就希望你把它认为是基本类型，它是没有clone方法的，处理机制也比较特殊，通过字符串池（stringpool）在需要的时候才在内存中创建新的字符串，在使用的时候就把String当做基本类使用即可。

再来看下「深拷贝」

public class Thing2 implements Cloneable {
  //定义一个私有变量
  private ArrayList<String> arrayList = new ArrayList<String>();
  @Override
  public Thing2 clone() {
      Thing2 thing = null;
      try {
          thing = (Thing2) super.clone();
          thing.arrayList = (ArrayList<String>) this.arrayList.clone();
      } catch (CloneNotSupportedException e) {
          e.printStackTrace();
      }
      return thing;
  }
  //设置HashMap的值
  public void setValue(String value) {
      this.arrayList.add(value);
  }
  //取得arrayList的值
  public ArrayList<String> getValue() {
      return this.arrayList;
  }
}
// Test
@Test
public void test2() {
  //产生一个对象
  Thing2 thing = new Thing2();
  // 设置一个值
  thing.setValue("张三");
  // 拷贝一个对象
  Thing2 cloneThing = thing.clone();
  cloneThing.setValue("李四");
  System.out.println(thing.getValue());
}

[张三]

深拷贝还有一种实现方式就是通过自己写二进制流来操作对象，然后实现对象的深拷贝。

📌注：深拷贝和浅拷贝建议不要混合使用，特别是在涉及类的继承时，父类有多个引用的情况就非常复杂，建议的方案是深拷贝和浅拷贝分开实现。

3. 「clone与final两个冤家」

对象的clone与对象内的final关键字是有冲突的。

public class Thing implements Cloneable {
  //定义一个私有变量 
  private final ArrayList<String> arrayList = new ArrayList<String>();
  // @Override 
  public Thing clone() {
      Thing thing = null;
      try {
          thing = (Thing) super.clone();
          this.arrayList = (ArrayList<String>) this.arrayList.clone(); // error!
      } catch (CloneNotSupportedException e) {
          e.printStackTrace();
      }
      return thing;
  }
}

final类型还想重赋值？要使用clone方法，在类的成员变量上就不要增加final关键字。

5. 「最佳实践」

原型模式先产生出一个包含大量共有信息的类，然后可以拷贝出副本，修正细节信息，建立了一个完整的个性对象。
可以这样理解：一个对象的产生可以不由零起步，直接从一个已经具备一定雏形的对象克隆，然后再修改为生产需要的对象。也就是说，产生一个人，可以不从1岁长到2岁，再到3岁……也可以直接找一个人，从其身上获得DNA，然后克隆一个，直接修改一下就是30岁了！原型模式也就是这样的功能。

Java 设计模式

4 『原型模式』