目录
原型模式的定义
- 原型模式(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):被拷贝的对象。