原型模式
原型模式(Prototype Pattern)是用于创建重复的对象,同时又能保证性能。这种类型的设计模式属于创建型模式,它提供了一种创建对象的最佳方式。
这种模式是实现了一个原型接口,该接口用于创建当前对象的克隆。当直接创建对象的代价比较大时,则采用这种模式。例如,一个对象需要在一个高代价的数据库操作之后被创建。我们可以缓存该对象,在下一个请求时返回它的克隆,在需要的时候更新数据库,以此来减少数据库调用。
场景:
1、资源优化场景。
2、类初始化需要消化非常多的资源,这个资源包括数据、硬件资源等。
3、性能和安全要求的场景。
4、通过 new 产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
5、一个对象多个修改者的场景。
6、一个对象需要提供给其他对象访问,而且各个调用者可能都需要修改其值时,可以考虑使用原型模式拷贝多个对象供调用者使用。
7、在实际项目中,原型模式很少单独出现,一般是和工厂方法模式一起出现,通过 clone 的方法创建一个对象,然后由工厂方法提供给调用者。原型模式已经与 Java 融为浑然一体,大家可以随手拿来使用。
原型模式:
通过new产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
就是java中的克隆技术,以某个对象为原型,复制出新的对象。显然,新的对象具备原型对象的特点。优势有:效率高(直接克隆,避免了重新执行构造过程步骤)。
克隆类似于new,但是不同于new。new创建新的对象属性采用的是默认值,克隆出的对象属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后,再修改克隆对象的值。
原型模式实现:
Cloneable接口和clone方法
Prototype模式中实现起来最困难的地方就是内存复制操作,所幸在Java中提供了clone()方法替我们做了绝大部分事情。
浅克隆存在的问题
被赋值的对象的所有变量都含有与原来的对象相同的值,而所有的对其他对象的引用都仍然指向原来的对象。
深克隆如何实现
1.深克隆把引用的变量执行赋值过的新对象,而不是原有的被引用的对象。
2.深克隆:让已实现Clonable接口的类中的属性也实现Clonable接口。
3.基本数据类型和String能够自动实现深度克隆(值的复制)。
注意:
与通过对一个类进行实例化来构造新对象不同的是,原型模式是通过拷贝一个现有对象生成新对象的。浅拷贝实现 Cloneable,重写,深拷贝是通过实现 Serializable 读取二进制流。
浅克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.io.Serializable;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 浅克隆
* @createDate 2019/2/21
*/
public class Sheep implements Cloneable,Serializable {
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); // 直接调用object对象的clone()方法
return obj;
}
public Sheep() {
}
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;
}
}
测试浅克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 测试原型模式(浅克隆)
* @createDate 2019/1/18
*/
public class Test {
public static void main(String[] args) throws Exception {
Date date = new Date(15504546456L);
Sheep s1 = new Sheep("少利", date);
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
Sheep s2 = (Sheep) s1.clone(); // 克隆s1对象
s2.setSname("多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
深克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 深克隆
* @createDate 2019/2/21
*/
public class Sheep2 implements Cloneable{
private String sname;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); // 直接调用object对象的clone()方法
// 添加如下代码实现深复制(deep Clone)
Sheep2 s = (Sheep2) obj;
s.birthday = (Date) this.birthday.clone(); // 将属性也进行克隆
return obj;
}
public Sheep2() {
}
public Sheep2(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;
}
}
测试深克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 测试原型模式(深克隆)
* @createDate 2019/2/21
*/
public class Test2 {
public static void main(String[] args) throws Exception {
Date date = new Date(15504546456L);
Sheep2 s1 = new Sheep2("少利", date);
Sheep2 s2 = (Sheep2) s1.clone(); // 实现深复制,b2对象的birthday是一个新对象
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
date.setTime(28404549436L);
System.out.println(s1.getBirthday());
s2.setSname("多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
使用序列化和反序列化的方式进行深克隆
package com.kevin.创建型模式.原型模式.prototype;
import java.io.*;
import java.util.Date;
/**
* @author kevin
* @version 1.0
* @description 原型模式(深复制,使用序列化和反序列化的方式实现深复制)
* @createDate 2019/2/21
*/
public class Test3 {
public static void main(String[] args) throws Exception {
Date date = new Date(15504546456L);
Sheep s1 = new Sheep("少利", date);
System.out.println(s1);
System.out.println(s1.getSname());
System.out.println(s1.getBirthday());
ByteArrayOutputStream bos = new ByteArrayOutputStream();
ObjectOutputStream oos = new ObjectOutputStream(bos);
oos.writeObject(s1);
byte[] bytes = bos.toByteArray();
ByteArrayInputStream bis = new ByteArrayInputStream(bytes);
ObjectInputStream ois = new ObjectInputStream(bis);
Sheep s2 = (Sheep) ois.readObject(); //克隆好的对象
System.out.println("修改原型对象的属性值");
date.setTime(28404549436L);
System.out.println(s1.getBirthday());
s2.setSname("多利");
System.out.println(s2);
System.out.println(s2.getSname());
System.out.println(s2.getBirthday());
}
}
短时间大量创建对象,使用原型程序克隆对象和new方式创建对象比较性能
package com.kevin.创建型模式.原型模式.prototype;
/**
* @author kevin
* @version 1.0
* @description 测试普通new方式创建对象和clone方式创建对象的效率差异
* 如果需要短时间创建大量对象,并且new的过程比较耗时,那么可以使用原型模式
* @createDate 2019/2/21
*/
public class Test4 {
public static void testNew(int size){
long start = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
Laptop t = new Laptop();
}
long end = System.currentTimeMillis();
System.out.println("new的方式创建耗时: " + (end-start));
}
public static void testClone(int size) throws Exception {
long start = System.currentTimeMillis();
Laptop t = new Laptop();
for (int i = 0; i < size; i++) {
Laptop tClone = (Laptop)t.clone();
}
long end = System.currentTimeMillis();
System.out.println("clone的方式创建耗时: " + (end-start));
}
public static void main(String[] args) throws Exception {
testClone(1000);
testNew(1000);
}
}
class Laptop implements Cloneable{ // 笔记本电脑
public Laptop(){
try {
Thread.sleep(10); // 模拟创建对象耗时的过程
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone(); // 直接调用object对象的clone()方法
return obj;
}
}
原型模式UML类图
开发中的应用场景
原型模式很少单独出现,一般是和工厂方法模式一起出现,通过clone的方法创建一个对象,然后由工厂方法提供给调用者。
Spring中的Bean的创建实际就是两种:单例模式和原型模式(原型模式需要和工厂模式搭配起来)