原型模式
原型模式(Prototype Pattern) 是指原型实例指定创建对象的种类,并且通过拷贝这些原型创建新的对象,属于创建型模式。
原型模式的核心在于拷贝原型对象。以系统中已存在的一个对象为原型,直接基于内存二进制流进行拷贝,无需再经历耗时的对象初始化过程(不调用构造函数),性能提升很多。当对象的构建过程比较耗时时,可以利用当前系统中已经存在的对象作为原型,对其进行克隆(一般是基于二进制流的复制),躲避初始化过程,使得新对象的创建时间大大减少。
原型模式主要包含三个角色:
客户(Client):客户类剔除创建对象的请求。
抽象原型(ProtoType):规定拷贝接口。
具体原型(Concrete Prototype):被拷贝对象。
注:对不听过new关键字,而是通过对象拷贝来实现创建对象的模式就称为原型模式。
原型模式应用场景
-
类初始化消耗资源较多。
-
new产生的一个对象需要非常繁琐的过程(数据准备、访问权限等)
-
构造函数比较复杂。
-
循环体中产生大量对象时
在Spring中,原型模式应用非常广泛。例如 scope = “prototype”,在我们经常用的 JSON.parseObject() 也是一种原型模式。
原型模式的通用写法
先创建原型接口
public interface IPrototype<T> {
T 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 class Client {
public static void main(String[] args) {
//创建原型对象
ConcretePrototype prototype = new ConcretePrototype();
prototype.setAge(18);
prototype.setName("java");
System.out.println(prototype);
//拷贝原型对象
ConcretePrototype cloneType = prototype.clone();
System.out.println(cloneType);
}
}
在实际编码中,JDK 已经帮我们实现了一个API,我们只需要实现Cloneable接口即可
浅克隆
@Data
public class ConcretePrototype implements Cloneable {
private int age;
private String name;
private List<String> hobbies;
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
......
}
这种克隆 属于浅克隆,只是完整复制了值类型数据,没有复制应用对象
使用序列化实现深度克隆
在上面的基础上我们继续改造,增加一个deepClone()方法
@Data
public class ConcretePrototype implements Cloneable,Serializable {
private int age;
private String name;
private List<String> hobbies;
@Override
public ConcretePrototype clone() {
try {
return (ConcretePrototype)super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
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 ConcretePrototype deepClone(){
try {
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(this);
ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
ObjectInputStream ois = new ObjectInputStream(bis);
return (ConcretePrototype)ois.readObject();
}catch (Exception e){
e.printStackTrace();
return null;
}
}
......
}
运行deepCloneHobbies() 也能得到期望结果,但是这属于硬编码,如果对象中声明有各种集合类型,每种情况都要单独处理。因此深克隆的写法,一般是直接序列化来操作
克隆破坏单例模式
如果我们克隆的目标对象是单例对象,那意味着深克隆会破坏单例。实际上防止克隆破坏单例解决思路非常简单,禁止深克隆即可。要么我们单例类不实现Cloneable接口;要么我们重写clone()方法,在clone方法中 返回单例对象即可。
@Override
public ConcretePrototype clone() {
return instance;
}
原型模式优缺点
优点:
- 性能优良,java自带的原型模式是基于内存二进制的拷贝,比直接new一个对象性能提升了很多。
- 可以使用深克隆方式保存对象的状态,使用原型模式将对象复制一份并将其保存起来,简化了创建对象的过程,以便早需要的时候使用(例如恢复到历史某一状态),可辅助实现撤销操作。
缺点:
- 需要为每一个类配置一个克隆方法。
- 克隆方法位于类的内部,当对一有的类进行改造的时候,需要修改代码,违反了开闭原则。
- 在实现深克隆时需要编写较为复杂的代码,而且当对象之间存在多重嵌套引用时,为了实现深克隆,每一层对应的类都必须支持深克隆,实现起来比较麻烦。因此深拷贝、浅拷贝需要运用得当。