版权声明：本文为博主原创文章，未经博主允许不得转载。 https://blog.csdn.net/qq1021979964/article/details/88102023
原型模式
原型模式（Prototype Pattern）是用于创建重复的对象，同时又能保证性能。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口，该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时，则采用这种模式。例如，一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象，在下一个请求时返回它的克隆，在需要的时候更新数据库，以此来减少数据库调用。
场景：
1、资源优化场景。
2、类初始化需要消化非常多的资源，这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问，而且各个调用者可能都需要修改其值时，可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中，原型模式很少单独出现，一般是和工厂方法模式一起出现，通过 clone 的方法创建一个对象，然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体，大家可以随手拿来使用。
原型模式：
通过new产生一个对象需要非常繁琐的数据准备或访问权限，则可以使用原型模式。
就是java中的克隆技术，以某个对象为原型，复制出新的对象。显然，新的对象具备原型对象的特点。优势有：效率高（直接克隆，避免了重新执行构造过程步骤）。
克隆类似于new，但是不同于new。new创建新的对象属性采用的是默认值，克隆出的对象属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后，再修改克隆对象的值。
原型模式实现：
Cloneable接口和clone方法
Prototype模式中实现起来最困难的地方就是内存复制操作，所幸在Java中提供了clone()方法替我们做了绝大部分事情。
浅克隆存在的问题
被赋值的对象的所有变量都含有与原来的对象相同的值，而所有的对其他对象的引用都仍然指向原来的对象。
深克隆如何实现
1.深克隆把引用的变量执行赋值过的新对象，而不是原有的被引用的对象。
2.深克隆：让已实现Clonable接口的类中的属性也实现Clonable接口。
3.基本数据类型和String能够自动实现深度克隆（值的复制）。
注意：
与通过对一个类进行实例化来构造新对象不同的是，原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable，重写，深拷贝是通过实现 Serializable 读取二进制流。
浅克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.io.Serializable;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 浅克隆
* @createDate 2019/2/21
*/
public class Sheep implements Cloneable,Serializable {
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); // 直接调用object对象的clone()方法
return obj;
}
public Sheep() {
}
public Sheep(String sname, Date birthday) {
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
测试浅克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 测试原型模式（浅克隆）
* @createDate 2019/1/18
*/
public class Test {
public static void main(String[] args) throws Exception {
Date date = new Date(15504546456L);
Sheep s1 = new Sheep("少利", date);
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
Sheep s2 = (Sheep) s1.clone(); // 克隆s1对象
s2.setSname("多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
深克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 深克隆
* @createDate 2019/2/21
*/
public class Sheep2 implements Cloneable{
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); // 直接调用object对象的clone()方法
// 添加如下代码实现深复制（deep Clone）
Sheep2 s = (Sheep2) obj;
s.birthday = (Date) this.birthday.clone(); // 将属性也进行克隆
return obj;
}
public Sheep2() {
}
public Sheep2(String sname, Date birthday) {
this.sname = sname;
this.birthday = birthday;
}
public String getSname() {
return sname;
}
public void setSname(String sname) {
this.sname = sname;
}
public Date getBirthday() {
return birthday;
}
public void setBirthday(Date birthday) {
this.birthday = birthday;
}
}
测试深克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 测试原型模式（深克隆）
* @createDate 2019/2/21
*/
public class Test2 {
public static void main(String[] args) throws Exception {
Date date = new Date(15504546456L);
Sheep2 s1 = new Sheep2("少利", date);
Sheep2 s2 = (Sheep2) s1.clone(); // 实现深复制，b2对象的birthday是一个新对象
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
date.setTime(28404549436L);
System.out.println(s1.getBirthday());
s2.setSname("多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
使用序列化和反序列化的方式进行深克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.io.*;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 原型模式（深复制，使用序列化和反序列化的方式实现深复制）
* @createDate 2019/2/21
*/
public class Test3 {
public static void main(String[] args) throws Exception {
Date date = new Date(15504546456L);
Sheep s1 = new Sheep("少利", date);
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(s1);
byte[] bytes = bos.toByteArray();
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
Sheep s2 = (Sheep) ois.readObject(); //克隆好的对象
System.out.println("修改原型对象的属性值");
date.setTime(28404549436L);
System.out.println(s1.getBirthday());
s2.setSname("多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
短时间大量创建对象，使用原型程序克隆对象和new方式创建对象比较性能
package com.kevin.创建型模式.原型模式.prototype;
/**
* @author kevin
* @version 1.0
* @description 测试普通new方式创建对象和clone方式创建对象的效率差异
* 如果需要短时间创建大量对象，并且new的过程比较耗时，那么可以使用原型模式
* @createDate 2019/2/21
*/
public class Test4 {
public static void testNew(int size){
long start = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
Laptop t = new Laptop();
}
long end = System.currentTimeMillis();
System.out.println("new的方式创建耗时: " + (end-start));
}
public static void testClone(int size) throws Exception {
long start = System.currentTimeMillis();
Laptop t = new Laptop();
for (int i = 0; i < size; i++) {
Laptop tClone = (Laptop)t.clone();
}
long end = System.currentTimeMillis();
System.out.println("clone的方式创建耗时: " + (end-start));
}
public static void main(String[] args) throws Exception {
testClone(1000);
testNew(1000);
}
}
class Laptop implements Cloneable{ // 笔记本电脑
public Laptop(){
try {
Thread.sleep(10); // 模拟创建对象耗时的过程
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); // 直接调用object对象的clone()方法
return obj;
}
}
原型模式UML类图
开发中的应用场景
原型模式很少单独出现，一般是和工厂方法模式一起出现，通过clone的方法创建一个对象，然后由工厂方法提供给调用者。
Spring中的Bean的创建实际就是两种：单例模式和原型模式（原型模式需要和工厂模式搭配起来）