使用场景:通过new产生一个对象需要非常繁琐的数据准备或访问权限,则可以使用原型模式。
实质:该模式实质是使用java中的克隆技术,以某个对象为原型,复制出新的对象。显然,新的对象具备原型对象的特点。
优势:效率高(直接克隆,避免了重新执行构造过程步骤)。
与new的区别:克隆类似于new,但是不同于new。new创建新的对象属性采用的是默认值。克隆出的对象的属性值完全和原型对象相同。并且克隆出的新对象改变不会影响原型对象。然后,再修改克隆对象的值。
实现方式
Cloneable接口和clone方法
Prototype模式中实现起来最困难的地方就是内存复制操作,所幸在java中提供了clone()方法替我们做了绝大部分的事情。
案例
浅克隆
package edu.yunyu.factory.prototype;
import java.io.Serializable;
import java.util.Date;
/**
* @author huangyzh
* @create 2020-05-15 20:10
*/
public class Sheep implements Cloneable{
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();//直接调用Object对象的clone()方法
}
public Sheep(){}
public Sheep(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
// 省略 getter setter toString方法
}
package edu.yunyu.factory.prototype;
import java.util.Date;
/**
* 原型模式 -- 浅克隆
* @author huangyzh
* @create 2020-05-15 20:15
*/
public class Test01 {
public static void main(String[] args) throws CloneNotSupportedException {
Date date = new Date(1248238325832583L);
Sheep s1 = new Sheep("Bans",date);
System.out.println(s1);
Object s2 = s1.clone();
if(s2 instanceof Sheep){
s2 = (Sheep)s2;
System.out.println(s2);
((Sheep) s2).setName("Nans");
System.out.println(s2);
}
//以上为浅克隆,date对象进行修改后,s1与s2对象中的时间都被改变,如下代码所示
date.setTime(3454657457474574745L);
System.out.println("=======以下代码说明浅克隆遇到对象时,拷贝的是其地址值==========");
System.out.println(s1);
System.out.println(s2);
}
}
深克隆
1)clone方式实现
改造代码
package edu.yunyu.factory.prototype;
import java.io.Serializable;
import java.util.Date;
/**
* @author huangyzh
* @create 2020-05-15 20:10
*/
public class Sheep02 implements Cloneable {
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
Object obj = super.clone();//直接调用Object对象的clone()方法
//添加如下代码实现深克隆
Sheep02 s = (Sheep02)obj;
s.birthday = (Date)this.birthday.clone();//意味着把属性也进行克隆
return obj;
}
public Sheep02(){}
public Sheep02(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
// 省略 getter setter toString方法
}
package edu.yunyu.factory.prototype;
import java.util.Date;
/**
* 原型模式 -- 深克隆
* @author huangyzh
* @create 2020-05-15 20:15
*/
public class Test02 {
public static void main(String[] args) throws CloneNotSupportedException {
Date date = new Date(1248238325832583L);
Sheep02 s1 = new Sheep02("Bans",date);
System.out.println(s1);
Object s2 = s1.clone();
if(s2 instanceof Sheep02){
s2 = (Sheep02)s2;
System.out.println(s2);
((Sheep02) s2).setName("Nans");
System.out.println(s2);
}
//以上为浅克隆,date对象进行修改后,s1与s2对象中的时间都被改变,如下代码所示
date.setTime(3454657457474574745L);
System.out.println("=======以下代码说明深克隆对其属性创建了一个新的时间对象==========");
System.out.println(s1);
System.out.println(s2);
}
}
此时再执行测试代码,克隆的对象与原型对象互不影响。
2)序列化和反序列化实现
package edu.yunyu.factory.prototype;
import java.io.Serializable;
import java.util.Date;
/**
* @author huangyzh
* @create 2020-05-15 20:10
*/
public class Sheep03 implements Cloneable, Serializable {
private String name;
private Date birthday;
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();//直接调用Object对象的clone()方法
}
public Sheep03(){}
public Sheep03(String name, Date birthday) {
this.name = name;
this.birthday = birthday;
}
// 省略 getter setter toString方法
}
package edu.yunyu.factory.prototype;
import java.io.*;
import java.util.Date;
/**
* 原型模式 -- 序列化反序列化实现深克隆
* @author huangyzh
* @create 2020-05-15 20:15
*/
public class Test03 {
public static void main(String[] args) throws Exception {
Date date = new Date(1248238325832583L);
Sheep03 s1 = new Sheep03("Bans",date);
System.out.println("原型对象:"+s1);
//使用序列化反序列化实现深克隆
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);
Sheep03 s2 = (Sheep03)ois.readObject();
date.setTime(395798437598435934L);
System.out.println("原型对象:"+s1);
System.out.println("克隆对象:"+s2);
}
}
效率测试
短时间大量创建对象,原型模式和普通new方式效率对比测试
public class Laptop implements Cloneable{
public Laptop(){
try {
//模拟场景对象耗时的过程
Thread.sleep(10);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
@Override
protected Object clone() throws CloneNotSupportedException {
return super.clone();
}
}
/**
* 普通new方式创建对象 和 clone创建对象的效率差异
* 如果需要短时间创建大量对象,且new对象比较耗时,可以使用原型模式
* @author huangyzh
* @create 2020-05-15 21:32
*/
public class Test04 {
public static void main(String[] args) {
int size = 1000;
testClone(size);
testNew(size);
}
public static void testNew(int size){
long start = System.currentTimeMillis();
for (int i = 0; i < size; i++) {
Laptop l = new Laptop();
}
long end = System.currentTimeMillis();
System.out.println("new方式创建耗时时间:"+(end-start));
}
public static void testClone(int size){
long start = System.currentTimeMillis();
Laptop l = new Laptop();
for (int i = 0; i < size; i++) {
try {
Laptop l1 = (Laptop) l.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
}
}
long end = System.currentTimeMillis();
System.out.println("clone方式创建耗时时间:"+(end-start));
}
}
应用场景
原型模式很少单独出现,一般是和工厂方法模式一起出现,通过clone的方法创建一个对象, 然后由工厂方法提供给调用者。
spring中bean的创建实际就是两种:单例模式和原型模式。(当然,原型模式需要和工厂模式搭配起来)