目录
原型模式的定义
- 原型模式（Prototype Pattern）是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。原型模式实际上就是不通过 new 关键字，而是通过对象拷贝来实现创建另一个新的对象，使新的对象有具有原对象的特征。原型模式可分为两种形式：简单克隆、深度克隆
原型模式的使用场景
- 类初始化消耗的资源较多；
-
new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）
-
构造函数比较复杂；
-
循环体中生产大量对象时。
-
在 Spring 中，原型模式应用得非常广泛。例如 scope=“prototype”，在我们经常用的 JSON.parseObject()也是一种原型模式。
简单克隆
先创建原型 Prototype 接口
public interface Prototype {
Prototype clone();
}创建具体需要克隆的对象 ConcretePrototype
public class ConcretePrototype implements IPrototype {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public ConcretePrototype clone() {
ConcretePrototype concretePrototype = new ConcretePrototype();
concretePrototype.setAge(this.age);
concretePrototype.setName(this.name);
return concretePrototype;
}
@Override
public String toString() {
return "ConcretePrototype{" + "age=" + age + ", name='" + name + '\'' + '}';
}
}测试代码
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("Tom");
System.out.println(prototype);
//拷贝原型对象
ConcretePrototype cloneType = prototype.clone();
System.out.println(cloneType);
}运行结果
这时候，有小伙伴就问了，原型模式就这么简单吗？对，就是这么简单。在这个简单的场景之下，看上去操作好像变复杂了。但如果有几百个属性需要复制，那我们就可以一劳永逸。但是，上面的复制过程是我们自己完成的，在实际编码中，我们一般不会浪费这样的体力劳动，JDK 已经帮我们实现了一个现成的 API，我们只需要实现 Cloneable 接口即可。来改造一下代码，修改 ConcretePrototype 类
public class ConcretePrototype implements Cloneable {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype{" + "age=" + age + ", name='" + name + '\'' + '}';
}
}
重新运行，也会得到同样的结果。有了 JDK 的支持再多的属性复制我们也能轻而易举地搞定了。下面我们再来做一个测试，给 ConcretePrototype 增加一个个人爱好的属性 hobbies：
public class ConcretePrototype implements Cloneable {
private int age;
private String name;
private List<String> hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype [age=" + age + ", name=" + name + ", hobbies=" + hobbies + "]";
}
}
测试代码
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("prototype");
List<String> hobbies = new ArrayList<String>();
hobbies.add("复制");
hobbies.add("拷贝");
prototype.setHobbies(hobbies);
System.out.println(prototype);
//拷贝原型对象 ConcretePrototype
ConcretePrototype cloneType = prototype.clone();
cloneType.getHobbies().add("不留痕迹");
System.out.println("原型对象：" + prototype);
System.out.println("克隆对象：" + cloneType);
}运行结果
我们给复制后的克隆对象新增一项爱好，发现原型对象也发生了变化，这显然不符合我们的预期。 因为我们希望克隆出来的对象应该和原型对象是两个独立的对象，不应该再有联系了。从测试结果分析来看，应该是 hobbies 共用了一个内存地址，意味着复制的不是值，而是引用的地址。这样的话，如果我们修改任意一个对象中的属性值，prototype 和 cloneType 的 hobbies 值都会改变。这就是我们常说的浅克隆。只是完整复制了值类型数据，没有赋值引用对象。换言之，所有的引用对象仍然指向原来的对象，显然不是我们想要的结果。那如何解决这个问题呢？下面我们来看深度克隆继续改造。
深度克隆
在上面的基础上我们继续改造，来看代码，增加一个 deepClone()方法
public class ConcretePrototype implements Cloneable,Serializable{
private int age;
private String name;
private List<String> hobbies;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public List<String> getHobbies() {
return hobbies;
}
public void setHobbies(List<String> hobbies) {
this.hobbies = hobbies;
}
//浅克隆
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
//深克隆--将对象序列化到内存中在反序列化拿出来，得到一个新的对象
public Object deepClone() {
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
oos.flush();
oos.close();
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
ConcretePrototype clone = (ConcretePrototype)ois.readObject();
ois.close();
return clone;
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
return null;
}
}
@Override
public String toString() {
return "ConcretePrototype [age=" + age + ", name=" + name + ", hobbies=" + hobbies + "]";
}
}测试代码
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("prototype");
List<String> hobbies = new ArrayList<String>();
hobbies.add("复制");
hobbies.add("拷贝");
prototype.setHobbies(hobbies);
System.out.println(prototype);
//拷贝原型对象 ConcretePrototype
ConcretePrototype cloneType = (ConcretePrototype) prototype.deepClone();
cloneType.getHobbies().add("不留痕迹");
System.out.println("原型对象：" + prototype);
System.out.println("克隆对象：" + cloneType);
System.out.println(prototype == cloneType);
System.out.println("原型对象的爱好：" + prototype.getHobbies());
System.out.println("克隆对象的爱好：" + cloneType.getHobbies());
System.out.println(prototype.getHobbies() == cloneType.getHobbies());
}运行结果
可以发现我们得到了期望的结果
克隆破坏单例模式
如果我们克隆的目标的对象是单例对象，那意味着，深克隆就会破坏单例。实际上防止克隆破坏单例解决思路非常简单，禁止深克隆便可。要么我们的单例类不实现Cloneable 接口；要么我们重写 clone()方法，在 clone 方法中返回单例对象即可，具体
代码如下
@Override
protected Object clone() throws CloneNotSupportedException {
return INSTANCE;
}Cloneable 源码分析
先来 JDK 中 Cloneable 接口
public interface Cloneable {
}
接口定义的很简单，我们找源码其实只需要找到看哪些接口实现了 Cloneable 即可。来看ArrayList 类的实现
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);
}
}
可以发现方法中只是将 List 中的元素循环遍历了一遍。那么是不是这种形式就是深克隆呢？我们来用代码验证一下，继续修改 ConcretePrototype 类，增加一个deepCloneHobbies()方法
public ConcretePrototype deepCloneHobbies(){
try {
ConcretePrototype result = (ConcretePrototype)super.clone();
result.hobbies = (List)((ArrayList)result.hobbies).clone();
return result;
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}测试代码
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("prototype");
List<String> hobbies = new ArrayList<String>();
hobbies.add("复制");
hobbies.add("拷贝");
prototype.setHobbies(hobbies);
System.out.println(prototype);
//拷贝原型对象 ConcretePrototype
ConcretePrototype cloneType = (ConcretePrototype) prototype.deepCloneHobbies();
cloneType.getHobbies().add("不留痕迹");
System.out.println("原型对象：" + prototype);
System.out.println("克隆对象：" + cloneType);
System.out.println(prototype == cloneType);
System.out.println("原型对象的爱好：" + prototype.getHobbies());
System.out.println("克隆对象的爱好：" + cloneType.getHobbies());
System.out.println(prototype.getHobbies() == cloneType.getHobbies());
}运行结果
运行也能得到期望的结果。但是这样的代码，其实是硬编码，如果在对象中声明了各种集合类型， 那每种情况都需要单独处理。因此，深克隆的写法，一般会直接用序列化来操作。
原型模式的优点
- 性能优良，Java 自带的原型模式 是基于内存二进制流的拷贝，比直接 new 一个对象性能上提升了许多。
- 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建对象的过程，以便在需要的时候使用(例如恢复到历史某一状态)，可辅助实现撤销操作
原型模式的缺点
- 每一个类必须配备一个克隆（或者可拷贝）方法。
- 克隆方法位于类的内部，当对已有类进行改造的时候，需要修改代码，违反了开闭原则
- 对克隆复杂对象或对克隆出的对象进行复杂改造时，易带来风险。
- 在实现深克隆时需要编写较为复杂的代码，而且当对象之间存在多重嵌套引用时，为了实现深克隆，每一层对象对应的类都必须支持深克隆，实现起来会比较麻烦。因此，深拷贝、浅拷贝需要运用得当。
原型模式的特点
- 不调用构造函数。
小结：
简单克隆的实现方式：
- 利用getter、setter方法直接复制
- 实现Cloneable 接口，利用的clone()方法克隆
深度克隆的实现方式：
- 序列化实现，将对象序列化到内存中在反序列化拿出来，得到一个新的对象
- 使用JSON方式（将对象与json对象互转实现），原理也是用的序列化与反序列化实现
- 循环复制每个引用类型对象中的值
原型模式包含三个角色：
- 客户(Client)：客户类提出创建对象的请求。
- 抽象原型(Prototype)：规定拷贝接口。
- 具体原型（Concrete Prototype）：被拷贝的对象。
2642
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
