设计模式-原型模式（Prototype Pattern）
我们今天来讲原型模式。我们先通过一个例子来解释一下什么是原型模式。
现在电子账单越来越流行，比如你的信用卡，到月初的时候银行就会发一份电子邮件到你的邮箱中，这个月消费多少，积分多少等等，每个月发一次，但是还有一种也是银行发的邮件你肯定有印象：广告信。电子账单系统一般包括：账单分析、账单生成器、广告信管理、发送队列管理、发送机、退信处理、报表管理等的一个子功能。我们今天来考虑游戏i啊广告信这个模块怎么开发呢，先来看一下类图：
在类图中AdvTemplate是广告信的模版，一般都是从数据库取出，生成一个BO或者是DTO，我们这里是使用一个静态的值来做代表：Mail类是一封邮件类，发送机发送的就是这个类，我们先来看看我们的程序：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/23.
*/
public class AdvTemplate {
//广告信名称
private String advSubject = "XX银行国庆信用卡抽奖活动";
//广告信内容
private String advContext = "国庆抽奖活动通知：只要刷卡就送一亿...";
//取的广告信的名称
public String getAdvSubject(){
return this.advSubject;
}
//取的广告信的内容
public String getAdvContext(){
return this.advContext;
}
}
我们再来看邮件类：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/23.
*/
public class Mail {
//收件人
private String receiver;
//邮件名称
private String subject;
//称谓
private String appellation;
//邮件内容
private String context;
//邮件的尾部，一般都是加上“xxx版权所有”等信息
private String tail;
//构造函数
public Mail(AdvTemplate advTemplate) {
this.context = advTemplate.getAdvContext();
this.subject = advTemplate.getAdvSubject();
}
public String getReceiver() {
return receiver;
}
public void setReceiver(String receiver) {
this.receiver = receiver;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getAppellation() {
return appellation;
}
public void setAppellation(String appellation) {
this.appellation = appellation;
}
public String getContext() {
return context;
}
public void setContext(String context) {
this.context = context;
}
public String getTail() {
return tail;
}
public void setTail(String tail) {
this.tail = tail;
}
}
Mail就是一个业务对象，我们再来看业务场景类是怎么调用的额：
private void Client() {
//模拟发送邮件
int i = 0;
//把模版定义出来，这个是从数据库中获取
Mail mail = new Mail(new AdvTemplate());
mail.setTail("XX银行版权所有");
while (i//一下是每封邮件不同的地方
mail.setAppellation(getRandString(5)+"先生（女士）");
mail.setReceiver(getRandString(5)+"@"+getRandString(8)+".com");
//然后发送文件
sendMail(mail);
i++;
}
} //发送邮件
public static void sendMail(Mail mail){
Log.e("xyz","标题："+mail.getSubject()+
"\t收件人:"+mail.getReceiver()+"\t....发送成功！");
}//获得指定长度的随机字符串
public static String getRandString(int maxLength){
String source = "ahkjdhsajkdhjkashdjkahsdjkahsjdhajkshdajkhdkahsdjk";
StringBuffer sb = new StringBuffer();
Random random = new Random();
for (int i = 0; i < maxLength; i++) {
sb.append(source.charAt(random.nextInt(source.length())));
}
return sb.toString();
}运行结果：
由于是随机数，每次运行都会有所差异，不管怎样，我们这个电子账单发送程序时写出来了，也能发送出来了，我们再仔细想想，这个程序是否有问题？你看，这是一个线程在运行，也就是你发送是单线程的，发送的太慢了。
好办，把sendMail修改成多线程，但是你只把sendMail修改成多线程还是有问题的，你看哦，产生第一封邮件对象，放到线程1中运行，还没有发送出去；线程2启动了，直接改掉称谓和地址，线程不安全。我们现在用原型模式来解决这个问题，使用对象的拷贝功能来解决这个问题，类图稍作修改：
增加一个Cloneable接口，Mail实现了这个接口，在Mail类中重写了clone（）方法，我们来看Mail类的改变：
package com.example.xpeng.myapplication;
/**
* Created by xpeng on 2018/6/23.
*/
public class MailChange implements Cloneable{
//收件人
private String receiver;
//邮件名称
private String subject;
//称谓
private String appellation;
//邮件内容
private String context;
//邮件的尾部，一般都是加上“xxx版权所有”等信息
private String tail;
//构造函数
public MailChange(AdvTemplate advTemplate) {
this.context = advTemplate.getAdvContext();
this.subject = advTemplate.getAdvSubject();
}
@Override
public MailChange clone(){
MailChange mail = null;
try {
mail = (MailChange) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return mail;
}
public String getReceiver() {
return receiver;
}
public void setReceiver(String receiver) {
this.receiver = receiver;
}
public String getSubject() {
return subject;
}
public void setSubject(String subject) {
this.subject = subject;
}
public String getAppellation() {
return appellation;
}
public void setAppellation(String appellation) {
this.appellation = appellation;
}
public String getContext() {
return context;
}
public void setContext(String context) {
this.context = context;
}
public String getTail() {
return tail;
}
public void setTail(String tail) {
this.tail = tail;
}
}
再看ClientChange类的改变:
private void ClientChange() {
//模拟发送邮件
int i = 0;
//把模版定义出来，这个是从数据库中获取
MailChange mailChange = new MailChange(new AdvTemplate());
mailChange.setTail("XX银行版权所有");
while (i//一下是每封邮件不同的地方
MailChange cloneMailChange = mailChange.clone();
cloneMailChange.setAppellation(getRandString(5)+"先生（女士）");
cloneMailChange.setReceiver(getRandString(5)+"@"+getRandString(8)+".com");
//然后发送文件
sendMail(cloneMailChange);
i++;
}
} public static void sendMail(MailChange mail){
Log.e("xyz","标题："+mail.getSubject()+
"\t收件人:"+mail.getReceiver()+"\t....发送成功！");
}运行结果不变，一样完成了电子广告信的发送功能，而且sendMail即使是多线程也没有关系，看到mail.clone（）这个方法了吗？把对象拷贝一份，产生一个新的对象，和原有对象一样，然后再修改细节的数据，如设置称谓，设置收件人地址。这种不通过new关键字来产生一个对象，而是通过对象拷贝来实现的模式就叫做原型模式，其通用类图如下：
这个模式的核心是一个clone方法，通过这个方法进行对象的拷贝，Java提供了一个Cloneable接口来标示这个对象是可拷贝的，为什么说是“标示”呢？翻开JDK的帮助文档看看Cloneable是一个方法都没有的，这个接口只是一个标记作用，在JVM中具有这个标记的对象才有可能被拷贝，那怎么才能从“有可能被拷贝”转换为“可以被拷贝”呢？方法是覆盖clone（）方法，是的，你没有看错是重写clone（）方法，看看我们上面的Mail类：
@Override
public Mail clone()｛｝
在clone（）方法上增加一个注解@Override，没有继承一个类为什么可以重写呢?在Java中所有的类老祖宗是谁？对嘛，Object类，每个类默认继承这个类，所以这个用上重写是非常正确的。
原型模式虽然很简单，但是在Java中使用原型模式也就是clone方法还是有一些注意事项的，我们通过几个例子一个一个解说
对象拷贝时，类的构造函数是不会被执行的。一个实现了Cloneable并重写了clone方法的类A，有一个无参构造B，通过new关键字产生了一个对象B，再然后通过S.clone()方式产生了一个新的对象T，那么在对象拷贝时构造函数B是不会被执行的，我们来写一段小段程序来说明这个问题：
package com.example.xpeng.myapplication;
import android.util.Log;
/**
* Created by xpeng on 2018/6/24.
*/
public class Thing implements Cloneable {
public Thing(){
Log.e("xyz","构造函数被执行了...");
}
public Thing clone(){
Thing thing = null;
try {
thing = (Thing) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return thing;
}
}
我们再写一个demo（）来拷贝对象:
private void demo() {
//产生一个对象
Thing thing = new Thing();
//拷贝一个对象
Thing cloneThing = thing.clone();
}对象拷贝是确实构造函数没有被执行，这个从原理来讲也是可以讲的通的，Object类的clone方法的原理是从内存中（具体的说是从堆内存）以二进制的方式进行拷贝，重新分配一个内存块，那构造函数没有被执行也是非常正常的了。
浅拷贝和深拷贝的问题。在解释什么是浅拷贝什么是深拷贝前，我们先看个例子：
package com.example.xpeng.myapplication;
import android.util.Log;
import java.util.ArrayList;
/**
* Created by xpeng on 2018/6/24.
*/
public class Thing implements Cloneable {
//定义一个私有变量
private ArrayList arrayList = new ArrayList();
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);
}
//取的aaryList的值
public ArrayList getValue() {
return this.arrayList;
}
}
private void demo() {
//产生一个对象
Thing thing = new Thing();
//设置一个值
thing.setValue("张三");
//拷贝一个对象
Thing cloneThing = thing.clone();
cloneThing.setValue("李四");
Log.e("xyz","thing.getValue"+cloneThing.getValue());
}大家猜想一下运行结果应该是什么》是就是一个“张三”吗？运行结果如下：
【张三，李四】
怎么会有李四呢？是因为Java做了一个偷懒的拷贝动作，Object类提供的方法clone只是拷贝本对象，其对象内部的数组、引用对象等都不拷贝，还是指向对象的内部元素地址，这种拷贝叫做浅拷贝。两个对象共享一个私有变量，你改我改大家改确实非常不安全的方式，在实际项目中使用还是比较少的。内部的数组和引用对象才不拷贝，其他的原始类型比如int,long,String（Java就希望你把String认为是基本类型，String是没有clone方法的）等都会被拷贝的。
浅拷贝是有风险度额，那怎么才能深入的拷贝呢？我们修改一下我们的程序：
public Thing clone(){
Thing thing = null;
try {
thing = (Thing) super.clone();
thing.arrayList = this.arrayList;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
return thing;
}
运行结果：
【张三】
这个实现了完全的拷贝，这种拷贝就叫做深拷贝。
Clone与final是两队冤家.。对象的clone与对象的final属性是有冲突的。
原型模式适合在什么场景使用？一是类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等；而是通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式；三是一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式。在实际项目中，原型模式很少单独使用，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。
原先模式DEMO下载地址：
demo下载