1.概述
原型模式(Prototype Pattern)适用于创建重复的对象,同时又能保证性能,它提供了一种创建对象的最佳方式。JAVA中原型模式通过实现一个原型接口,该接口用于创建对象的克隆,当创建对象的代价比较大时,采用这种模式能够有效提升系统性能。它是一种创建型设计模式,允许一个对象再创建另外一个可定制的对象,无需知道如何创建的细节,本文主要讲述JAVA中采用浅拷贝和深拷贝方式来实现原型模式。
2.原型模式
原型模式指的是:用原型实例指定创建对象的种类,并且通过拷贝这些原型,创建新的对象。它通过将一个原型对象传给那个要发动创建的对象,这个要发动创建的对象通过请求原型对象拷贝它们自己来实施创建。
案例:有一只羊名叫多利,现在需要通过克隆方式,生成3个和它一样的羊。在JAVA中的代码实现如下:
public class Sheep implements Cloneable {
private Integer age;
private String color;
private String name;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return sheep;
}
}
public class Main {
public static void main(String[] args) {
Sheep sheep = new Sheep();
sheep.setAge(3);
sheep.setName("多利");
sheep.setColor("black");
Sheep sheep1 = (Sheep) sheep.clone();
Sheep sheep2 = (Sheep) sheep.clone();
Sheep sheep3 = (Sheep) sheep.clone();
System.out.println(JSON.toJSONString(sheep1));
System.out.println(JSON.toJSONString(sheep2));
System.out.println(JSON.toJSONString(sheep3));
}
}
运行结果如下:
2.1 浅拷贝
在JAVA中,对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性值复制一份给新的对象。对于数据类型是引用数据类型的成员变量(比如说成员变量是某个数组,某个类的对象等),那么浅拷贝会进行引用传递,也就是只是将该成员变量的引用值(内存地址)复制一份给新的对象。因为实际上两个对象的该成员变量都指向同一个实例。在这种情况下,在一个对象中修改该成员变量会影响到另一个对象的该成员变量值。也就是说,浅拷贝的对象直接会互相干扰,一旦其中一个对象修改某个引用数据类型的成员变量,会改变这个对象拷贝出来的所有对象该成员变量。
案例:上述克隆羊的案例中,如果每只小羊有一个成员属性friend,用来存储自己的朋友,用原型模式生成sheep1、sheep2、sheep3时,friend的哈希地址相同。代码如下:
public class Sheep implements Cloneable {
private Integer age;
private String color;
private String name;
private Sheep friend;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Sheep getFriend() {
return friend;
}
public void setFriends(Sheep friend) {
this.friend = friend;
}
@Override
protected Object clone() {
Sheep sheep = null;
try {
sheep = (Sheep) super.clone();
} catch (Exception e) {
System.out.println(e.getMessage());
}
return sheep;
}
}
public class Main {
public static void main(String[] args) {
Sheep sheep = new Sheep();
sheep.setAge(3);
sheep.setName("多利");
sheep.setColor("black");
Sheep friend = new Sheep();
friend.setName("小羊克隆");
friend.setColor("red");
friend.setAge(1);
sheep.setFriend(friend);
Sheep sheep1 = (Sheep) sheep.clone();
Sheep sheep2 = (Sheep) sheep.clone();
Sheep sheep3 = (Sheep) sheep.clone();
System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriends().hashCode());
System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriends().hashCode());
System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriends().hashCode());
}
}
运行结果如下:
2.2 深拷贝
深拷贝与浅拷贝不同,深拷贝不仅会复制对象的所有基本数据类型的成员变量值,还会为所有引用数据类型的变量申请存储空间,并复制每个引用数据类型成员变量所引用的对象,直到该对象可达的所有对象。也就是说,对象进行深拷贝要对整个对象进行拷贝。
深拷贝主要有以下两种方式:1.重写clone方法来实现深拷贝;2.通过对象序列化实现深拷贝。
2.2.1 重写clone方法来实现深拷贝
由于引用类型不能实现深拷贝,所以将引用类型拆分成基本类型,重写每个引用类型的clone()方法。这种方式的缺陷在于如果引用类型还嵌套引用类型,那么需要在每个引用类型中重写clone()方法,有多少个引用类型就要重写多少次,代价太大且违背开闭原则。
public class Sheep implements Cloneable, Serializable {
private Integer age;
private String color;
private String name;
private Sheep friend;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Sheep getFriend() {
return friend;
}
public void setFriend(Sheep friend) {
this.friend = friend;
}
@Override
protected Object clone() {
Sheep sheep = null;
try {
//对基本数据类型(属性)和String类型的克隆
sheep = (Sheep) super.clone();
//对引用类型的属性的单独克隆
Sheep clone = (Sheep) friend.clone();
sheep.friend = clone;
} catch (Exception e) {
System.out.println(e.getMessage());
}
return sheep;
}
}
public class Main {
public static void main(String[] args) {
Sheep sheep = new Sheep();
sheep.setAge(3);
sheep.setName("多利");
sheep.setColor("black");
Sheep friend = new Sheep();
friend.setName("小羊克隆");
friend.setColor("red");
friend.setAge(1);
sheep.setFriend(friend);
Sheep sheep1 = (Sheep) sheep.clone();
Sheep sheep2 = (Sheep) sheep.clone();
Sheep sheep3 = (Sheep) sheep.clone();
System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriend().hashCode());
System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriend().hashCode());
System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriend().hashCode());
}
}
运行结果如下:
2.2.2 通过对象序列化实现深拷贝
通过序列化方式的实现原理是将原始对象利用序列化产生克隆对象,然后反序列化获取这个对象。由于序列化产生的是两个完全独立的对象,所以无论对象嵌套多少个引用类型,序列化都能够实现深拷贝。
public class Sheep implements Cloneable, Serializable {
private Integer age;
private String color;
private String name;
private Sheep friend;
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getColor() {
return color;
}
public void setColor(String color) {
this.color = color;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public Sheep getFriend() {
return friend;
}
public void setFriend(Sheep friend) {
this.friend = friend;
}
@Override
protected Object clone() throws CloneNotSupportedException {
ByteArrayOutputStream bos = null;
ObjectOutputStream oos = null;
ByteArrayInputStream bis = null;
ObjectInputStream ois = null;
try {
bos = new ByteArrayOutputStream();
oos = new ObjectOutputStream(bos);
oos.writeObject(this);
bis = new ByteArrayInputStream(bos.toByteArray());
ois = new ObjectInputStream(bis);
Sheep copyObj = (Sheep) ois.readObject();
return copyObj;
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
try {
ois.close();
bos.close();
oos.close();
bis.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}
public class Main {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheep = new Sheep();
sheep.setAge(3);
sheep.setName("多利");
sheep.setColor("black");
Sheep friend = new Sheep();
friend.setName("小羊克隆");
friend.setColor("red");
friend.setAge(1);
sheep.setFriend(friend);
Sheep sheep1 = (Sheep) sheep.clone();
Sheep sheep2 = (Sheep) sheep.clone();
Sheep sheep3 = (Sheep) sheep.clone();
System.out.println(JSON.toJSONString(sheep1) + ":" + "hashCode:" + sheep1.getFriend().hashCode());
System.out.println(JSON.toJSONString(sheep2) + ":" + "hashCode:" + sheep2.getFriend().hashCode());
System.out.println(JSON.toJSONString(sheep3) + ":" + "hashCode:" + sheep3.getFriend().hashCode());
}
}
运行结果如下:
2.2.3 原型模式的优势和缺点
1.优势
(1)创建新的对象比较复杂时,可以利用原型模式简化对象的创建过程,同时也能够提高效率;
(2)利用原型模式创建对象不用重写初始化对象,而是动态地获得对象运行时地状态;
(3)如果原始对象发生变化(增加或者减少属性),其它克隆对象的也会发生相应的变化,无需修改代码;
2.缺点
(1)在实现克隆的时候需要比较复杂的代码;
(2)需要为每一个类配备一个克隆方法,这对全新的类来说不是很难,但对已有的类进行改造时,需要修改其源代码,违背OCP原则。
3.小结
1.原型模式是期望通过一种低损耗的方式来快速创建对象,JAVA中使用这种方式,需要实现Cloneable接口并重写clone()方法;
2.浅拷贝适用于一个类只拥有基本类型,深拷贝适用于拥有基本类型和引用类型的类;
3.原型模式主要适用于创建大对象或者批量创建大量相同对象的场景。
4.参考文献
1.《设计模式-可复用面向对象软件的基础》-Erich Gamma、Richard Helm、Ralph Johnson、John Vlissides
2.《可复用物联网Web3D框架的设计与实现》-程亮(知网)
3.https://www.bilibili.com/video/BV1G4411c7N4-尚硅谷设计模式