介绍
原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象，这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
代码演示
简单工厂将getter，setter封装到某个方法中，JDK提供的实现Cloneable 接口，实现快速复制。
浅克隆
案例：孙悟空有72变，拔一根毫毛就是一只猴子猴孙。
只是利用getter，setter的场景
定义Monkey类，只有名字的属性
@Getter
@Setter
public class Monkey {
public String name;
}
定义金箍棒的类，金箍棒有高度和重量两个属性
@Getter
@Setter
@AllArgsConstructor
public class JinGuBang {
//高度
private int height;
// 重量
private int weight;
}
定义孙悟空的类，孙悟空的武器就是金箍棒。
@Getter
@Setter
public class SunWuKong extends Monkey {
private JinGuBang jinGuBang;
}
孙悟空拔一根毫毛，生出跟自己长得一模一样的猴子猴孙
public class Client {
public static void main(String[] args) {
SunWuKong sunwukong = new SunWuKong();
sunwukong.setName("齐天大圣");
sunwukong.setJinGuBang(new JinGuBang(1000, 30000));
// 造一个跟孙悟空一模一样的猴子猴孙
SunWuKong copy = new SunWuKong();
copy.setName(sunwukong.getName());
copy.setJinGuBang(sunwukong.getJinGuBang());
}
}
我造一只猴子猴孙，我直接通过set，get就可以完成，但是如果我想要造几千只几万只呢？
不着急，请看下面的分解
使用Cloneable的代码
Monkey类，JinGuBang 类与不使用设计模式代码一致。所以下面代码就不贴这两个类了。
孙悟空类
@Getter
@Setter
public class SunWuKong extends Monkey implements Cloneable {
private JinGuBang jinGuBang;
@Override
public Object clone() {
SunWuKong sunWuKong = new SunWuKong();
sunWuKong.setName(this.getName());
sunWuKong.setJinGuBang(this.getJinGuBang());
return sunWuKong;
}
}
测试类
public class Client {
public static void main(String[] args) {
SunWuKong sunWuKong=new SunWuKong();
JinGuBang jinGuBang=new JinGuBang(100,3000);
sunWuKong.setJinGuBang(jinGuBang);
sunWuKong.setName("齐天大圣");
SunWuKong copy=(SunWuKong) sunWuKong.clone();
System.out.println("孙悟空和拷贝的孙悟空指向同一个引用地址嘛？ "+(sunWuKong==copy));
System.out.println("孙悟空和拷贝的孙悟空有同一根金箍棒嘛？"+(sunWuKong.getJinGuBang()==copy.getJinGuBang()));
System.out.println("孙悟空的名字和拷贝的孙悟空名字是同一个嘛？" +(sunWuKong.getName()==sunWuKong.getName()));
}
}
打印结果
孙悟空和拷贝的孙悟空指向同一个引用地址嘛？ false
孙悟空和拷贝的孙悟空有同一根金箍棒嘛？true
孙悟空的名字和拷贝的孙悟空名字是同一个嘛？true
根据打印结果，可以知道，孙悟空和拷贝，两个对象并不是同一个对象，但是他们拥有同一根金箍棒。但是呢，金箍棒只有一根，两个人争着用肯定是会有问题的。
我们再写一个类来验证下，拷贝的金箍棒变了，孙悟空的金箍棒是不是也会变
public class ShadowPrototypeTest {
public static void main(String[] args) {
SunWuKong sunWuKong = new SunWuKong();
sunWuKong.setJinGuBang( new JinGuBang(100, 3000));
sunWuKong.setName("齐天大圣");
SunWuKong copy = (SunWuKong) sunWuKong.clone();
copy.getJinGuBang().setHeight(1);
System.out.println(JSON.toJSONString(sunWuKong.getJinGuBang()));
}
}
打印结果
{"height":1,"weight":3000}
浅克隆类图
通过验证，说明，拷贝的孙悟空 金箍棒变大变小了，也会影响到本体的孙悟空。这个时候肯定是会有问题了，先不说金箍棒就只有龙宫有那么一根绝版，就说我们的齐天大圣跟妖怪作战的时候，突然金箍棒受到了其他人的控制，变大变小了，那孙悟空岂不是都要抓狂了。
于是这个时候深克隆来了，深克隆解决了什么问题呢，没错，就是copy的对象，可以跟本体一样拥有一根"金箍棒"，但是他的金箍棒跟本体孙悟空的真的金箍棒可不是同一根。金箍棒全世界就那么一根呐。copy的"金箍棒"可以是一根棍子，可以是其他的。
深克隆
对浅克隆中对金箍棒类进行修改,使用序列化
@Getter
@Setter
@AllArgsConstructor
public class JinGuBang implements Serializable {
private static final long serialVersionUID = 1L;
//高度
private int height;
// 重量
private int weight;
}
对浅克隆中的孙悟空类进行修改,使用序列化，将对象写入到流中
@Getter
@Setter
public class SunWuKong extends Monkey implements Cloneable,Serializable {
private static final long serialVersionUID = 1L;
private JinGuBang jinGuBang;
@Override
public Object clone() {
return this.deepClone();
}
// 克隆会破坏单例
private Object deepClone() {
SunWuKong copy = null;
ObjectOutputStream out=null;
ObjectInputStream in=null;
try {
//内存中完成操作，对象读写，是通过字节码直接操作
ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
out = new ObjectOutputStream(byteOut);
out.writeObject(this);
ByteArrayInputStream byteIn = new ByteArrayInputStream(byteOut.toByteArray());
in = new ObjectInputStream(byteIn);
// 完整的新的对象，new 一个对象
copy = (SunWuKong) in.readObject();
} catch (IOException e) {
e.printStackTrace();
} catch (ClassNotFoundException e) {
e.printStackTrace();
}finally {
if (out!=null){
try {
out.close();
} catch (IOException e) {
e.printStackTrace();
}
}
if (in!=null){
try {
in.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
return copy;
}
}
深克隆测试类
public class DeepPrototypeTest {
public static void main(String[] args) {
SunWuKong sunWuKong = new SunWuKong();
sunWuKong.setJinGuBang(new JinGuBang(100, 3000));
sunWuKong.setName("齐天大圣");
SunWuKong copy = (SunWuKong) sunWuKong.clone();
System.out.println("本体的金箍棒引用地址：" + sunWuKong.getJinGuBang());
if (copy != null) {
System.out.println("copy的金箍棒引用地址：" + copy.getJinGuBang());
}
}
}
打印结果展示
本体的金箍棒引用地址：com.example.teach.designpatterns.prototype.simple.simple1.JinGuBang@5b480cf9
copy的金箍棒引用地址：com.example.teach.designpatterns.prototype.simple.simple1.JinGuBang@4b9af9a9
通过打印结果我们可以看到，本体和拷贝对金箍棒并不是同一根。
深克隆类图
个人的理解是Java中定义的clone()没有深浅克隆之分，都是统一的调用Object的clone方法。
通过深克隆和浅克隆两个模型，可以知道
浅克隆不会克隆原对象中的引用类型，仅仅拷贝了引用类型的指向。
深克隆则拷贝了所有。拷贝的这个对象完全是不一样的对象。深克隆能够做到原对象和新对象之间完全没有影响。
使用场景
1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
8、循环体中生产大量对象时。
优缺点
优点：
1、性能提高。
2、逃避构造函数的约束。
缺点：
1、配备克隆方法需要对类的功能进行通盘考虑，这对于全新的类不是很难，但对于已有的类不一定很容易，特别当一个类引用不支持串行化的间接对象，或者引用含有循环结构的时候。
2、必须实现 Cloneable 接口。
应用实例
应用实例：
1:JAVA 中的 Object clone() 方法
2：BeanUtils.copy()
3:JSON.parseObject()
4:Guava
5：spring中的配置scope="prototype";
6: ArrayList扩容的时候，调用的grow()方法，里面有一个逻辑是调用到
elementData = Arrays.copyOf(elementData, newCapacity);
ArrayList 克隆的时候，是对它内部元素一个一个的迭代，再进行赋值
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
主要的逻辑在System.arraycopy();
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
