介绍
如果没有打印机，出去找工作携带的简历很可能就是手写的。那么面试一家新公司就手写一份简历，是多么折磨人的一件事。在程序开发中，我们有可能也会碰到同样的问题。
有些对象比较复杂，或其创建过程过于复杂，而且我们又需要频繁的利用该对象，如果这个时候我们按照常规思维new该对象，那么务必会带来非常多的麻烦，这个时候我们就希望可以利用一个已经有的对象来不断对它进行复制就好了，这就是编程中的“克隆”。原型模式就可以满足我们的“克隆”。
原型模式是一个创建型的模式。原型二字表明了该模式应该有一个样板实例，用户从这个样板对象中复制出一个内部属性一致的对象，被复制的实例就是我们所称的“原型”，这个原型是可定制的。原型模式多用于创建复杂的或者构造耗时的实例，因为这种情况下，复制一个已经存在的实例可使程序运行更高效。
概念
用原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。
原型模式允许你复制现有的实例来创建新的实例。在Java中，这一般意味着实现Cloneable接口并覆写clone方法，或者反序列化。
原型模式结构图：
Prototype：抽象原型类。声明克隆自身的接口。
ConcretePrototype：具体原型类。实现克隆的具体操作。
Client：客户类。让一个原型克隆自身，从而获得一个新的对象。
模式实现
下面以简单的文档拷贝为例演示一下简单的原型模式。在这个例子中首先创建了一个文档对象「WordDocument」,这个文档中含有文字和图片。用户经过长时间的内容编辑后，打算对该文档进行进一步的编辑，但是这个编辑后的文档是否会被采用还不确定。因此为了安全起见，用户需要将当前文档拷贝一份，然后再在文档副本上进行修改。这个原型文档就是我们上述所说的样板实例，也就是将要被克隆的对象，我们称为原型。
- 浅拷贝
创建当前对象的浅表副本。方法是创建一个新对象，然后将当前对象的非静态字段复制到新对象。如果字段是值类型的，则对该字段执行逐位复制。如果字段是引用类型，则复制引用但不复制引用的对象「原始对象和副本都指向同一对象」。
public class WordDocument implements Cloneable {
/**
* 文本
*/
private String text;
/**
* 图片名列表
*/
private ArrayList<String> images = new ArrayList<>();
public WordDocument() {
System.out.println("WordDocument 构造函数");
}
@Override
protected WordDocument clone() throws CloneNotSupportedException {
WordDocument wordDocument = (WordDocument) super.clone();
wordDocument.text = this.text;
wordDocument.images = this.images;
return wordDocument;
}
public String getText() {
return text;
}
public void setText(String text) {
this.text = text;
}
public ArrayList<String> getImages() {
return images;
}
public void addImage(String image) {
this.images.add(image);
}
public void showDocument() {
System.out.println("文本：" + text);
System.out.println("图片列表：");
images.forEach(imageName -> System.out.println("image name: " + imageName));
}
}
通过WordDocument类模拟了Word文档中的基本元素，即文字和图片。
WordDocument在该原型模式示例中扮演的角色为ConcretePrototype，而Cloneable的角色则为Prototype。
WordDocument中的clone方法用以实现对象克隆。注意，这个方法并不是Cloneable接口中的，而是Object中的方法。Cloneable是一个标识接口，它表明这个类的对象是可拷贝的。如果没有实现Cloneable接口却调用了clone()方法将抛出异常。
在这个示例中，我们通过实现Cloneable接口和覆写clone方法实现原型模式。
客户端测试：
public class Test {
public static void main(String[] args) {
//构建对象
WordDocument originDoc = new WordDocument();
originDoc.setText("这是一篇文档");
originDoc.addImage("图片1");
originDoc.addImage("图片2");
originDoc.showDocument();
try {
//拷贝文档
System.out.println("\n------ 拷贝文档 ------");
WordDocument doc2 = originDoc.clone();
doc2.showDocument();
//修改文字和图片
System.out.println("\n------ 修改文档 ------");
doc2.setText("这是修改后的doc2文本");
doc2.addImage("哈哈.jpg");
doc2.showDocument();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
//原始文档
System.out.println("\n------ 原始文档 ------");
originDoc.showDocument();
}
}
输出结果：
WordDocument 构造函数
文本：这是一篇文档
图片列表：
image name: 图片1
image name: 图片2
------ 拷贝文档 ------
文本：这是一篇文档
图片列表：
image name: 图片1
image name: 图片2
------ 修改文档 ------
文本：这是修改后的doc2文本
图片列表：
image name: 图片1
image name: 图片2
image name: 哈哈.jpg
------ 原始文档 ------
文本：这是一篇文档
图片列表：
image name: 图片1
image name: 图片2
image name: 哈哈.jpg
从输出结果可以看到，doc2是通过originDoc.clone()创建的，并且doc2第一次输出的时候和origian输出是一样的，即doc2是origianDoc的一份拷贝，它们的内容是一样的，而doc2修改了文本内容并不会影响origianDoc的文本内容，这就保证了originDoc的安全性。
还需要注意的是，通过clone拷贝对象时，并不会执行构造函数！因此，如果在构造函数中需要一些特殊初始化操作的类型，在使用Cloneable实现拷贝时，需要注意构造函数不会执行的问题。
另外，我们发现名为“哈哈.jpg”的照片同时也显示在orginDoc中了，这是怎么回事呢？
因为doc2的images变量与orginDoc的images变量都指向了堆内存中的同一对象。所以，修改了其中一个文档中的图片，另一个文档也受影响。那如何解决这个问题呢？那就是采用深拷贝。
- 深拷贝
拷贝对象时，对于引用类型的字段也采用拷贝的形式「引用字段与指向的实例均进行复制」。
覆写clone方法
@Override
protected WordDocument clone() throws CloneNotSupportedException {
WordDocument wordDocument = (WordDocument) super.clone();
wordDocument.text = this.text;
//对images对象也调用clone()函数，进行深拷贝。
wordDocument.images = (ArrayList<String>) this.images.clone();
return wordDocument;
}
或者反序列化实现：
//不推荐使用，比较消耗性能。优点是类比较复杂时，不需要为每一个类配备克隆方法。
public WordDocument deepClone(){
ByteArrayOutputStream bos = new ByteArrayOutputStream();
try(ObjectOutputStream oos = new ObjectOutputStream(bos)){
oos.writeObject(this);
} catch (IOException e) {
e.printStackTrace();
}
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
try(ObjectInputStream ois = new ObjectInputStream(bis)){
return (WordDocument) ois.readObject();
} catch (IOException | ClassNotFoundException e) {
e.printStackTrace();
}
return null;
}
优点
- 原型模式是在内存中二进制流的拷贝，一般要比直接new一个对象性能好很多，特别是要在一个循环体内产生大量的对象时，原型模式可以更好地体现其优点。
- 可以使用深克隆保持对象的状态。
缺点
- 在实现深克隆的时候可能需要比较复杂的代码。
- 需要为每一个类配备一个克隆方法，而且这个克隆方法需要对类的功能进行通盘考虑，这对全新的类来说不是很难，但对已有的类进行改造时，不一定是件容易的事，必须修改其源代码，违背了“开闭原则”。
适用场景
- 类初始化需要消耗非常多的资源，这个资源包括数据、硬件资源等，通过原型拷贝避免这些消耗。
- 通过new产生一个对象需要非常繁琐的数据准备或访问权限，这时可以使用原型模式。
- 一个对象需要提供给其它对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用，即保护性拷贝。
需要注意的是，通过实现Cloneable接口的原型模式在调用clone函数构造实例时并不一定比通过new操作速度快，只有当通过new构造对象较为耗时或者成本比较高时，通过clone方法才能获得效率上的提升。因此，在使用Cloneable时需要考虑构建对象的成本以及做一些效率上的测试。
总结
使用原型模式可以解决构建复杂对象的资源消耗问题，能够在某些场景下提升创建对象的效率。还有一个重要的用途就是保护性拷贝，也就是某个对象对外可能是只读的，为了防止外部对这个只读对象的修改，通常可以通过返回一个对象拷贝的形式实现只读的限制。
源码分析（JDK 13； spring-context 5.2.5.RELEASE）
ArrayList类（浅拷贝）
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//省略无关代码...
/**
* Returns a shallow copy of this {@code ArrayList} instance. (The
* elements themselves are not copied.)
*
* @return a clone of this {@code ArrayList} instance
*/
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
}
}
HashMap类（浅拷贝）
public class HashMap<K,V> extends AbstractMap<K,V>
implements Map<K,V>, Cloneable, Serializable {
//省略无关代码...
/**
* Returns a shallow copy of this {@code HashMap} instance: the keys and
* values themselves are not cloned.
*
* @return a shallow copy of this map
*/
@Override
public Object clone() {
HashMap<K,V> result;
try {
result = (HashMap<K,V>)super.clone();
} catch (CloneNotSupportedException e) {
// this shouldn't happen, since we are Cloneable
throw new InternalError(e);
}
result.reinitialize();
result.putMapEntries(this, false);
return result;
}
}
AbstractBeanDefinition的子类ChildBenaDefinition类（深拷贝：自定义实现）
- 实现原型模式不一定非要实现Cloneable接口，也有其它的实现方式，比如前面我们有通过反序列化实现。
AbstractBeanDefinition类：
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
//省略无关代码...
@Override
public Object clone() {
return cloneBeanDefinition();
}
public abstract AbstractBeanDefinition cloneBeanDefinition();
}
来看子类ChildBenaDefinition的实现：
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
//省略无关代码...
@Override
public AbstractBeanDefinition cloneBeanDefinition() {
return new ChildBeanDefinition(this);
}
public ChildBeanDefinition(ChildBeanDefinition original) {
super(original);
}
}
又来到了父类的AbstractBeanDefinition类
public abstract class AbstractBeanDefinition extends BeanMetadataAttributeAccessor
implements BeanDefinition, Cloneable {
//省略无关代码...
/**
* Create a new AbstractBeanDefinition as a deep copy of the given
* bean definition.
* @param original the original bean definition to copy from
*/
protected AbstractBeanDefinition(BeanDefinition original) {
setParentName(original.getParentName());
setBeanClassName(original.getBeanClassName());
setScope(original.getScope());
setAbstract(original.isAbstract());
setFactoryBeanName(original.getFactoryBeanName());
setFactoryMethodName(original.getFactoryMethodName());
setRole(original.getRole());
setSource(original.getSource());
copyAttributesFrom(original);
if (original instanceof AbstractBeanDefinition) {
AbstractBeanDefinition originalAbd = (AbstractBeanDefinition) original;
if (originalAbd.hasBeanClass()) {
setBeanClass(originalAbd.getBeanClass());
}
if (originalAbd.hasConstructorArgumentValues()) {
setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
}
if (originalAbd.hasPropertyValues()) {
setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
}
if (originalAbd.hasMethodOverrides()) {
setMethodOverrides(new MethodOverrides(originalAbd.getMethodOverrides()));
}
Boolean lazyInit = originalAbd.getLazyInit();
if (lazyInit != null) {
setLazyInit(lazyInit);
}
setAutowireMode(originalAbd.getAutowireMode());
setDependencyCheck(originalAbd.getDependencyCheck());
setDependsOn(originalAbd.getDependsOn());
setAutowireCandidate(originalAbd.isAutowireCandidate());
setPrimary(originalAbd.isPrimary());
copyQualifiersFrom(originalAbd);
setInstanceSupplier(originalAbd.getInstanceSupplier());
setNonPublicAccessAllowed(originalAbd.isNonPublicAccessAllowed());
setLenientConstructorResolution(originalAbd.isLenientConstructorResolution());
setInitMethodName(originalAbd.getInitMethodName());
setEnforceInitMethod(originalAbd.isEnforceInitMethod());
setDestroyMethodName(originalAbd.getDestroyMethodName());
setEnforceDestroyMethod(originalAbd.isEnforceDestroyMethod());
setSynthetic(originalAbd.isSynthetic());
setResource(originalAbd.getResource());
}
else {
setConstructorArgumentValues(new ConstructorArgumentValues(original.getConstructorArgumentValues()));
setPropertyValues(new MutablePropertyValues(original.getPropertyValues()));
setLazyInit(original.isLazyInit());
setResourceDescription(original.getResourceDescription());
}
}
}
另外两个直接子类「RootBeanDefinition、GenericBeanDefinition」也都是深拷贝的自定义实现，大家可以自己看一下。
