故事 还记得大四那年找工作，无意中我得从网上找到一份相对漂亮的程序员简历模板，然后全班同学开启疯狂的简历拷贝（u盘）。同时也闹出了一个笑话，有几位同学，拷贝过去的简历，内容完全没改，名字都没有改，截止投给面试官（校招面试官）。后来，结果大家也应该能猜出来，大家都去实习了，部分人还在找工作。后面公司面试官和同伴的其他同学反馈：收到一毛一样的简历，好几份，回来大家一聊就知道问题出哪里了，承认了自己拷贝过去完全没改就拿出去投了，害，尴尬的一匹。
把简历拷贝分为为两种：
一种是拷贝简历，然后把信息修改成自己的另外一种是，拷贝简历，内容什么都不改。原型模式定义 specify the kinds of objects to create using a prototype instance ,and create new objects by coping this prototype
大致意思：用原型实例指定创建对象的种类，并且通过复制这些原型创建新的对象。
原型模式：prototype pattern，属于创建型模式。
调用者不需要知道任何创建细节，也不用调用构造方法来创建对象。
使用场景 原型模式有如下使用场景：
类初始化消耗资源较多new产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）构造函数比较复杂循环体内生成大量对象时在spring中，原型模式应用的非常广泛，例如:scope='prototype'我们可以将一些getter和setter之类封装成一个工厂方法，然后对于使用的人来说，调用方法就可以了，不需要知道里面的getter和setter是怎么处理的。我们也可以使用jdk提供的实现cloneable接口，实现快速复制。
创建对象的四种方式：
new、反射、克隆、序列化
实际案例 大家是否有遇到过这种常见，就是项目中规定，不能把与数据库表映射的entity类返回给前端，所以通常返回给前端的有各种o，比如：xxxvo、xxxbo、xxxdto...
这时候就会出现下面的场景，大家也想已经猜到了。
下面是与数据库表映射的userentity实体类。
public class userentity { private long id; private string name; private integer age; //....可能还有很多属性 //省略getter setter}
返回给前端或者调用方的uservo实体类。
public class uservo { private long id; private string name; private integer age; //....可能还有很多属性 //省略getter setter}
此时，从数据库里查出来的userentity需要转换成uservo，然后再返回给前端（或者调用方）。
public class objectconvertutil { public static uservo convertuserentitytouservo(userentity userentity) { if (userentity == null) { return null; } uservo uservo = new uservo(); uservo.setid(userentity.getid()); uservo.setname(userentity.getname()); uservo.setage(userentity.getage()); //如果还有更多属性呢？ return uservo; }}
从这个util类中，我们可以看出，如果一个类的属性有几十个，上百个的，这代码量是不是有点恐怖？
于是，我们通常都会使用一些工具类来处理，比如常见有以下：
beanutils.copy();json.parseobject()guava工具类.....
这些工具类就用到了原型模式。
通过一个对象，创建一个新的对象。
也把原型模式称之为对象的拷贝、克隆。
其实对象的克隆分浅克隆和深克隆，下面我们就来聊聊浅克隆和深克隆。
浅克隆：创建一个新对象，新对象的属性和原来对象完全相同，对于非基本类型属性，仍指向原来对象的属性所指向的对象的内存地址。深克隆：创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。我们先来聊聊浅克隆，都喜欢由浅入深。
浅克隆 比如，我现在相对用户信息user进行克隆，但是user中有用户地址信息useraddress属性。
以下是代码的实现：
//用户地址信息public class useraddress implements serializable{ private string province; private string citycode; public useraddress(string province, string citycode) { this.province = province; this.citycode = citycode; }}//用户信息public class user implements cloneable { private int age; private string name; //用户地址信息 private useraddress useraddress; //getter setter 省略 @override protected object clone() throws clonenotsupportedexception { return super.clone(); }}//测试public class usertest { public static void main(string[] args) throws exception { user user = new user(); user.setage(20); user.setname("田维常"); useraddress useraddress = new useraddress("贵州", "梵净山"); user.setuseraddress(useraddress); user clone = (user) user.clone(); system.out.println("克隆前后useraddress比较：" + (user.getuseraddress() == clone.getuseraddress())); }}
输出结果
克隆前后 useraddress 比较：true
两个对象属性 useraddress 指向的是同一个地址。
这就是所谓的浅克隆，只是克隆了对象，对于该对象的非基本类型属性，仍指向原来对象的属性所指向的对象的内存地址。
关系如下：
深克隆 关于深克隆，我们来用一个很经典的案例，西游记里的孙悟空。一个孙悟空能变成n多个孙悟空，手里都会拿着一个金箍棒。
按照前面的浅克隆，结果就是：孙悟空倒是变成很多孙悟空，但是金箍棒用的是同一根。
深克隆的结果是：孙悟空变成了很多个，金箍棒也变成很多个根。
下面我们用代码来实现：
//猴子，有身高体重和生日public class monkey { public int height; public int weight; public date birthday;}
孙悟空也是猴子，兵器 孙悟空有个金箍棒：
import java.io.serializable;//孙悟空的金箍棒public class jingubang implements serializable{ public float h=100; public float d=10; //金箍棒变大 public void big(){ this.h *=10; this.d *=10; } //金箍棒变小 public void small(){ this.h /=10; this.d /=10; }}
齐天大圣孙悟空：
import java.io.*;import java.util.date;//孙悟空有七十二变,拔猴毛生成一个金箍棒//使用jdk的克隆机制，//实现cloneable并重写clone方法public class qitiandasheng extends monkey implements cloneable, serializable { public jingubang jingubang; public qitiandasheng() { this.birthday = new date(); this.jingubang = new jingubang(); } @override protected object clone() throws clonenotsupportedexception { return this.deepclone(); } //深克隆 public qitiandasheng deepclone() { try { //内存中操作完成、对象读写，是通过字节码直接操作 //与序列化操作类似 bytearrayoutputstream bos = new bytearrayoutputstream(); objectoutputstream oos = new objectoutputstream(bos); oos.writeobject(this); bytearrayinputstream bais = new bytearrayinputstream(bos.tobytearray()); objectinputstream bis = new objectinputstream(bais); //完成一个新的对象,底层是使用new创建的一个对象 //详情可以了解readobject方法 qitiandasheng qitiandasheng = (qitiandasheng) bis.readobject(); //每个猴子的生日不一样，所以每次拷贝的时候，把生日改一下 qitiandasheng.birthday = new date(); return qitiandasheng; } catch (exception ex) { ex.printstacktrace(); return null; } } //浅克隆，就是简单的赋值 public qitiandasheng shalllowclone(qitiandasheng target) { qitiandasheng qitiandasheng = new qitiandasheng(); qitiandasheng.height = target.height; qitiandasheng.weight = target.weight; qitiandasheng.jingubang = target.jingubang; qitiandasheng.birthday = new date(); return qitiandasheng; }}
接着我们就来测试一下：
public class deepclonetest { public static void main(string[] args) { qitiandasheng qitiandasheng = new qitiandasheng(); try { qitiandasheng newobject = (qitiandasheng) qitiandasheng.clone(); system.out.print("深克隆后 "); system.out.println("金箍棒是否一直：" + (qitiandasheng.jingubang == newobject.jingubang)); } catch (exception ex) { ex.printstacktrace(); } qitiandasheng newobject=qitiandasheng.shalllowclone(qitiandasheng); system.out.print("浅克隆后 "); system.out.println("金箍棒是否一直：" + (qitiandasheng.jingubang == newobject.jingubang)); }}
输出结果为：
深克隆后 金箍棒是否一直：false浅克隆后 金箍棒是否一直：true
结论
深克隆后每个孙悟空都有自己的金箍棒，而浅克隆后每个孙悟空用的金箍棒实质上还是同一根。
总结 切记：深和浅，指的是克隆对象里的属性（引用类型）是否指向同一个内存地址。
为了更深刻的理解深克隆和浅克隆，我们回答文中的简历拷贝的故事。
深拷贝：拷贝一份简历，然后对简历中的信息进行修改成自己的浅拷贝：拷贝一份简历，简历内容完全不变优点：
java 原型模式基于内存二进制流复制，比直接 new 的性能会更好一些。可以利用深克隆保存对象状态，存一份旧的（克隆出来），在对其修改，可以充当一个撤销功能。缺点：
需要配置 clone 方法，改造时需要对已有类进行修改，违背 “开闭原则”。如果对象间存在多重嵌套引用时，每一层都需要实现克隆。我们从原型模式的定义，使用场景，真实案例、浅克隆、深克隆、优缺点等方面，对原型模式进行了一个全面的讲解。
以上就是五分钟 掌握 原型模式的详细内容。