使用原型模式来复制一个对象,从而克隆出多个与原型对象一模一样的对象。
在某些系统中,有些对象的创建过程很昂贵很复杂,而且有时候需要频繁创建。
可以用原型模式解决。
原型模式(Prototype Pattern):原型模式是一种对象创建型模式,用原型实例,指定创建对象的种类,并且通过复制这些原型,创建新的对象。
在原型模式结构中定义了一个抽象原型类,所有的Java类都继承自java.lang.Object,而Object类提供一个clone()方法,可以将一个Java对象复制一份。因此在Java中可以直接使用Object提供的clone()方法来实现对象的克隆(浅拷贝),Java语言中的原型模式实现很简单。
能够实现克隆的Java类必须实现一个标识接口Cloneable,表示这个Java类支持复制。如果一个类没有实现这个接口但是调用了clone()方法,Java编译器将抛出一个CloneNotSupportedException异常。
浅拷贝是指拷贝对象时仅仅拷贝对象本身(包括对象中的基本变量,引用变量地址),而不拷贝对象包含的引用指向的对象。
深拷贝不仅拷贝对象本身,而且拷贝对象包含的引用指向的所有对象。
若不对clone()方法进行改写,则调用此方法得到的对象即为浅拷贝(Object的clone为浅拷贝)。
深拷贝方法,就是将对象串行化。
package com.ez;
import java.io.Serializable;
/**
* 浅拷贝,通过Object提供的clone方法,就可以实现浅拷贝。
* 对象必须继承Cloneable接口。
* @author 窗外赏雪(EZ编程网)
*/
public class People implements Cloneable,Serializable{
private static final long serialVersionUID = -4084944705840672303L;
private int age;
private String name;
public People(int age,String name) {
this.age=age;
this.name=name;
}
public int getAge() {
return age;
}
public String getName() {
return name;
}
public void setAge(int age) {
this.age = age;
}
public void setName(String name) {
this.name = name;
}
/**
* 子类默认实现方式:覆盖重写父类的方法,默认使用super.xxx
* 所以在子类中,可以调用父类的方法。
*/
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
public static void main(String[] args) {
People p0=new People(15,"李四");
System.out.println("age:"+p0.getAge()+",name:"+p0.getName());;
try {
People p1=(People)p0.clone();
System.out.println("age:"+p1.getAge()+",name:"+p1.getName());
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
}
package com.ez;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;
import java.io.OptionalDataException;
import java.io.Serializable;
/**
* 深拷贝和浅拷贝的区别
* @author 窗外赏雪(EZ编程网)
*/
public class Student implements Serializable,Cloneable{
/**
* 反序列化的时候,需要对照这个ID,如果不匹配就反序列化异常。
*/
private static final long serialVersionUID = 3457679362463213165L;
private String name;// 常量对象。
private int age;
private People people;// 学生1和学生2的引用值都是一样的。
Student(String name, int age, People p) {
this.name = name;
this.age = age;
this.people = p;
}
public String getName() {
return name;
}
public int getAge() {
return age;
}
public People getPeople() {
return people;
}
public Object deepClone() throws IOException, OptionalDataException,
ClassNotFoundException {
// 将对象写到流里
ByteArrayOutputStream bo = new ByteArrayOutputStream();
ObjectOutputStream oo = new ObjectOutputStream(bo);
oo.writeObject(this);
// 从流里读出来
ByteArrayInputStream bi = new ByteArrayInputStream(bo.toByteArray());
ObjectInputStream oi = new ObjectInputStream(bi);
return (oi.readObject());
}
public static void main(String[] args) throws CloneNotSupportedException, OptionalDataException, ClassNotFoundException, IOException {
People p0=new People(18, "窗外赏雪");
Student stu=new Student("李四", 15, p0);
//浅拷贝只拷贝p0的引用
Student stu1=(Student)stu.clone();
System.out.println("age:"+stu1.getAge()+",name:"+stu1.getName());
stu1.getPeople().setAge(111);
stu1.getPeople().setName("大刀关羽");
System.out.println("======"+p0.getAge()+p0.getName()+"======");
//深拷贝会拷贝p0的真实对象
Student stu2=(Student)stu.deepClone();
System.out.println("age:"+stu2.getAge()+",name:"+stu2.getName());
stu2.getPeople().setAge(222);
stu2.getPeople().setName("小刀关胜");
System.out.println("======"+p0.getAge()+p0.getName()+"======");
}
}
原型模式的优点
当创建新的对象实例较为复杂时,使用原型模式可以简化对象的创建过程。(通过一个已有实例可以提高新实例的创建效率)
原型模式应用:
Struts2中为了保证线程的安全性,Action对象的创建使用了原型模式,访问一个已经存在的Action对象时将通过克隆的方式创建出一个新的对象,从而保证其中定义的变量无须进行加锁实现同步,每一个Action中都有自己的成员变量,避免Struts1因使用单例模式而导致的并发和同步问题。
Spring中,用户也可以采用原型模式来创建新的bean实例,从而实现每次获取的是通过克隆生成的新实例,对其进行修改时对原有实例对象不造成任何影响。