java学习笔记之原型模式及深浅拷贝
一、原型模式的基本介绍
在聊原型模式之前,我们来思考一个小问题,传统的方式我们是如何克隆对象呢?
那我们以多利羊(Sheep)为例,来说明上述这个问题,具体代码见下面:
多利羊(Sheep)
public class Sheep {
private String sname;
private Date birthday;
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;
}
}
测试类(Client)
public class Client {
public static void main(String[] args) {
Sheep sheep=new Sheep("多利",new Date());
Sheep sheep2=new Sheep(sheep.getSname(),sheep.getBirthday());
System.out.println("sheep:"+sheep.getSname()+sheep.getBirthday());
System.out.println("sheep2:"+sheep2.getSname()+sheep2.getBirthday());
}
}
那我们来分析一下:
1、在创建新对象时,总是需要获取原始对象的属性,如果我们在实际项目中创建的对象复杂的话,效率是很低的。
2、总是需要重新初始化对象,而不是动态地获取对象运行时的状态,不够灵活。
有什么方法可以改进吗?,原型模式闪亮登场
大家都知道在Java中有一个Object类,这个类提供了一个clone()方法,该方法可以将Java对象复制一份,前提是该类实现一个Cloneable接口,这就是原型模式的源头。
什么是原型模式:
用原型实例指定创建对象的种类,并且通过拷贝这些原型来创建新的对象。
看了这个定义可能有的小伙伴们比较蒙,那我们来撸一把代码来说明(多利羊克隆):
多利羊(Sheep)实现Cloneable
public class Sheep implements Cloneable {
private String sname;
private Date birthday;
private Sheep mother;
public Sheep getMother() {
return mother;
}
public void setMother(Sheep mother) {
this.mother = mother;
}
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;
}
@Override
public String toString() {
return "Sheep{" +
"sname='" + sname + '\'' +
", birthday=" + birthday +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Sheep sheep=null;
try {
sheep=(Sheep) super.clone();
}catch (Exception e){
e.printStackTrace();
}
return sheep;
}
}
克隆方法的测试(Client)
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheep=new Sheep("多利",new Date());
Sheep mother=new Sheep("多利的妈妈",new Date());
sheep.setMother(mother);
Sheep sheep1=(Sheep) sheep.clone();
System.out.println("sheep:"+sheep);
System.out.println("sheep1:"+sheep1);
System.out.println("sheep:"+sheep.getMother().hashCode());
System.out.println("sheep1:"+sheep1.getMother().hashCode());
}
}
运行结果:hashcode 的值一样
sheep:Sheep{sname='多利', birthday=Sun May 17 11:56:58 CST 2020}
sheep1:Sheep{sname='多利', birthday=Sun May 17 11:56:58 CST 2020}
sheephashcode:2061475679
sheep1hashcode:2061475679
二、原型模式实现浅克隆和深克隆
浅克隆的介绍:
对于数据类型是基本数据类型的成员变量,浅拷贝会直接进行值传递,也就是将该属性值复制一份给新的对象。
对于数据类型是引用数据类型的成员变量(数组,对象),浅拷贝会进行引用传递,也就是将成员变量的引用值(内存地址)复制一份给新的对象,因为实际上两个对象的该成员变量都指向同一个实例(前面克隆羊就是浅拷贝,使用clone()方法实现)。
再次说明:其实就是克隆多利羊之后,克隆的对象没有被真正的复制一份,而是引用指向第一个对象的属性空间。
画图说明:
具体代码如下见上面(多利羊克隆)
深克隆的介绍:
1、对对象进行深拷贝要对整个对象(包括对象的引用类型)进行拷贝。
深克隆实现的方式:
1、重写clone()方法实现深克隆
2、通过对象序列化实现深克隆
第一种方式:重写clone()方法实现深克隆,参考下面代码实现:
public class Sheep implements Cloneable {
private String sname;
private Date birthday;
public Mother mother;
public Sheep() {
}
public Sheep(String sname, Date birthday,Mother mother ) {
this.sname = sname;
this.birthday = birthday;
this.mother=mother;
}
@Override
public String toString() {
return "Sheep{" +
"sname='" + sname + '\'' +
", birthday=" + birthday +
", mother=" + mother +
'}';
}
@Override
protected Object clone() throws CloneNotSupportedException {
Sheep sheep=null;
try {
Object obj= super.clone();
sheep=(Sheep) obj;
sheep.mother=(Mother) mother.clone();
} catch (Exception e) {
e.printStackTrace();
}
return sheep;
}
}
多利的妈咪
public class Mother implements Cloneable {
private int age;
private String name;
public Mother(int age, String name) {
this.age = age;
this.name = name;
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
客户端测试:
public class Client {
public static void main(String[] args) throws CloneNotSupportedException {
Sheep sheep=new Sheep("多利",new Date(),new Mother(12,"多利的妈妈"));
Sheep sheep1=(Sheep) sheep.clone();
System.out.println("sheep:"+sheep);
System.out.println("sheep1:"+sheep1);
System.out.println("sheephashcode:"+sheep.mother.hashCode());
System.out.println("sheep1hashcode:"+sheep1.mother.hashCode());
}
}
运行结果:hashcode 的值不一样
sheep:Sheep{sname='多利', birthday=Sun May 17 13:20:51 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@7adf9f5f}
sheep1:Sheep{sname='多利', birthday=Sun May 17 13:20:51 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@85ede7b}
sheephashcode:2061475679
sheep1hashcode:140435067
第二种方式:序列化和反序列化
需要在Sheep ,Mother 类实现一个序列化 Serializable,具体代码和上面第一种方式的代码一样,就是这Sheep代码中增加以下这段核心代码:
// 通过对象的序列化实现
public Object deepClone() throws Exception {
ByteArrayOutputStream bos=new ByteArrayOutputStream();
ObjectOutputStream oos=new ObjectOutputStream(bos);
oos.writeObject(this);
ObjectInputStream ois=new ObjectInputStream(new ByteArrayInputStream(bos.toByteArray()));
Sheep sheep=(Sheep) ois.readObject();
return sheep;
}
运行结果:
sheep:Sheep{sname='多利', birthday=Sun May 17 13:51:23 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@72ea2f77}
sheep1:Sheep{sname='多利', birthday=Sun May 17 13:51:23 CST 2020, mother=com.designpattern.pattern.prototypepattern.sprototype.Mother@17f052a3}
sheephashcode:1927950199
sheep1hashcode:401625763
三、原型模式的应用场景
Spring 中bean 的scope 属性的声明:
<bean id="student" class="com.Student" scope="prototype"/>
public class ProtoType {
public static void main(String[] args) {
// TODO Auto-generated method stub
ApplicationContext applicationContext = new ClassPathXmlApplicationContext("beans.xml");
// 获取monster[通过id获取monster]
Object bean = applicationContext.getBean("student");
System.out.println("bean:" + bean);
Object bean2 = applicationContext.getBean("student");
System.out.println("bean1" + bean2);
System.out.println(bean == bean2);
}
}
运行结果
bean:com.atguigu.spring.bean.Student@52bf72b5
bean1com.atguigu.spring.bean.Student@37afeb11
false
四、小结
优点:
1、创建新的对象比较复杂时,可以利用原型模式创建新的对象,不用重新初始化对象,而是动态地获得对象运行时的状态。
2、如果原始对象发生变化,其克隆的对象也会发生响应的变化,不需要修改代码来实现
缺点:
需要为每一个类配置一个克隆方法,需要器修改源代码,不符合OCP原则。
技术之路还很长,慢慢来吧,时间会证明一切。