【设计模式系列(三)】彻底搞懂原型模式
文章中涉及到的代码,可到这里来拿:https://gitee.com/daijiyong/DesignPattern
原型模式(Prototype Pattern)是用于创建重复的对象,同时又能保证性能
调用者不需要知道任何创建细节,不调用构造函数
属于创建型模式
说白了就是克隆,其核心就是拷贝模型,减少拷贝对象的复杂度,提高性能和可维护性
举个栗子,有这么一个类
public class ExamPaper {
private String examinationPaperId;//试卷主键
private String leavTime;//剩余时间
private String organizationId;//单位主键
private String id;//考试主键
private String examRoomId;//考场主键
private String userId;//用户主键
private String specialtyCode;//专业代码
private String postionCode;//报考岗位
private String gradeCode;//报考等级
private String examStartTime;//考试开始时间
private String examEndTime;//考试结束时间
private String singleSelectionImpCount;//单选选题重要数量
private String multiSelectionImpCount;//多选题重要数量
private String judgementImpCount;//判断题重要数量
private String examTime;//考试时长
private String fullScore;//总分
private String passScore;//及格分
private String userName;//学员姓名
private String score;//考试得分
private String resut;//是否及格
private String singleOkCount;//单选题答对数量
private String multiOkCount;//多选题答对数量
private String judgementOkCount;//判断题答对数量
//构造方法
//get、set方法
}
这个类的成员变量特别多,如果手动创建的话需要写大量的代码
如果创建相同对象的需求也比较多
那该怎么办呢?
我们可以再这个类中新增一个clone的方法
public ExamPaper copy() {
ExamPaper examPaper = new ExamPaper();
//剩余时间
examPaper.setLeavTime(this.getLeavTime());
//单位主键
examPaper.setOrganizationId(this.getOrganizationId());
//考试主键
examPaper.setId(this.getId());
//用户主键
examPaper.setUserId(this.getUserId());
//专业
examPaper.setSpecialtyCode(this.getSpecialtyCode());
//岗位
examPaper.setPostionCode(this.getPostionCode());
//等级
examPaper.setGradeCode(this.getGradeCode());
//考试开始时间
examPaper.setExamStartTime(this.getExamStartTime());
//考试结束时间
examPaper.setExamEndTime(this.getExamEndTime());
//单选题重要数量
examPaper.setSingleSelectionImpCount(this.getSingleSelectionImpCount());
//多选题重要数量
examPaper.setMultiSelectionImpCount(this.getMultiSelectionImpCount());
//判断题重要数量
examPaper.setJudgementImpCount(this.getJudgementImpCount());
//考试时间
examPaper.setExamTime(this.getExamTime());
//总分
examPaper.setFullScore(this.getFullScore());
//及格分
examPaper.setPassScore(this.getPassScore());
//学员姓名
examPaper.setUserName(this.getUserName());
//分数
examPaper.setScore(this.getScore());
//单选答对数量
examPaper.setSingleOkCount(this.getSingleOkCount());
//多选答对数量
examPaper.setMultiOkCount(this.getMultiOkCount());
//判断答对数量
examPaper.setJudgementOkCount(this.getJudgementOkCount());
return examPaper;
}
这样在复制对象的时候就可以不那么繁琐了
但是这样维护和看起来还是太过笨重了,不够优雅
想到复制对象无非就是遍历这个对象的所有成员属性
很容易就能联想到Java的反射机制
我们就可以利用Java的反射机制写一个工具类用来复制对象
1. Bean复制工具类
public class BeanUtils {
/**
* 通过反射机制实现遍历属性并赋值,克隆对象
*
* @param prototype 对象
* @return 新对象
*/
public static Object copy(Object prototype) {
Class clazz = prototype.getClass();
Object returnValue = null;
try {
returnValue = clazz.newInstance();
for (Field field : clazz.getDeclaredFields()) {
field.setAccessible(true);
field.set(returnValue, field.get(prototype));
}
} catch (Exception e) {
e.printStackTrace();
}
return returnValue;
}
}
然后再使用的时候就可以这样调用了
看起来就不那么繁琐了
写一个测试类测试一下
public class Test {
public static void main(String[] args) {
ExamPaper examPaper = new ExamPaper();
System.out.println(examPaper);
ExamPaper examPaperCopy = (ExamPaper) BeanUtils.copy(new ExamPaper());
System.out.println(examPaperCopy);
}
}
结果肯定复制成功
但是这样其实是有一个问题的,我们下面再说
先说一下如果使用原型模式,怎么实现对象的复制
2. 一般形式
首先我们需要创建一个接口
并定义一个clone()的方法
public interface Iprototype<T> {
T clone();
}
然后创建一个类,并实现这个原型模式方法
public class Man implements IPrototype {
private int age;
private String name;
public int getAge() {
return age;
}
public void setAge(int age) {
this.age = age;
}
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
@Override
public Man clone() {
//在这里边写复制本对象的逻辑
//可以这样手动创建
Man concretePrototype = new Man();
concretePrototype.setAge(this.age);
concretePrototype.setName(this.name);
return concretePrototype;
//也可以使用这种方式也行
// return (ConcretePrototype) BeanUtils.copy(this);
}
@Override
public String toString() {
return "ConcretePrototype{" +
"age=" + age +
", name='" + name + '\'' +
'}';
}
}
写一个测试类测试一下
“完美”克隆
这就是原型模式的一般形式
Java本身也带有一个Cloneable的接口
3. 浅克隆
进入Cloneable可以看到这个接口没有定义任何方法
clone()方法是定义在了Object类中
在上边例子的基础上,实现Java的Cloneable接口
并重写调用Object类的clone()接口
@Override
public Man clone() {
try {
return (Man) super.clone();
} catch (CloneNotSupportedException e) {
e.printStackTrace();
return null;
}
}
然后再加一个成员属性friends
使用List的类型
private List<String> friends;
然后再写一个测试类测试一下
public class Test {
public static void main(String[] args) {
//创建原型对象
Man man = new Man();
man.setAge(18);
man.setName("daijiyong");
List<String> friends = new ArrayList<String>();
friends.add("张三");
friends.add("李四");
man.setFriends(friends);
//拷贝原型对象
Man cloneMan = man.clone();
cloneMan.getFriends().add("王五");
System.out.println(man);
System.out.println(cloneMan);
}
}
然后打印结果却发现一个问题
我是对赋值后的man对象添加了一个朋友
并将年龄修改为了20岁
根据打印的结果
发现原始对象的年龄没有变化
但是朋友却跟着也增加了
这就是因为浅克隆的原因
当我们使用基本数据类型进行直接赋值操作的时候
原对象和复制对象的值是相互不影响的
但是,如果是非基本数据类型,则会是引用赋值
本本质就是仅仅是复制了一个指针,指向的实际对象是同一个
那么如何实现复制出来的对象时一个全新的对象,跟原对象没有任何关系呢?
这个时候就引出另外一个概念:深克隆
4. 深克隆
实现深克隆一般有两个方法
利用json的方式
引入json的工具类
<dependency>
<groupId>com.alibaba</groupId>
<artifactId>fastjson</artifactId>
<version>1.2.32</version>
</dependency>
新增json深克隆方法
public Man deepCloneJson() {
try {
String json = JSONObject.toJSONString(this);
return JSONObject.parseObject(json, Man.class);
} catch (Exception e) {
e.printStackTrace();
return null;
}
}
修改测试类进行测试
完美解决
序列化的方式
如果一个对象想实现序列化,毕业要实现Serializable接口
public class Man implements Cloneable, Serializable {
//......
}
新增一个通过序列化深克隆的方法
public Man deepCloneSerialise() {
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);
return (Man) ois.readObject();
} catch (Exception e) {
e.printStackTrace();
return null;
} finally {
try {
if (bos != null) {
bos.close();
}
if (oos != null) {
oos.close();
}
if (bis != null) {
bis.close();
}
if (ois != null) {
ois.close();
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
修改测试类,并执行
完美解决
推荐使用序列化的方式实现深克隆
5. 源码实现
Java底层有些类也重写了clone()方法,实现深克隆
比如ArrayList的clone()方法其实就是深克隆
我们都知道ArrayList的底层是基于数组实现
这个clone()方法就是在浅克隆的基础上
使用数组又新建了一个新的数组
并将新数组的内容复制给当前ArrayList,返回
6. 问题
原型模式的基本原理和使用方法基本都明白了
但是有一个致命的问题,如果使用原型模式去创建单例模式的对象
岂不是会破坏单例模式对象的唯一性?
其实这个问题也非常好解决
办法就是,如果是单例模式的类,那就不要实现克隆接口,不要提供clone()方法
你都单例了就为什么还要实现原型模式接口呢?
这样就能从源头上解决这个问题了
7. 总结
使用场景:
类的初始化消耗资源较多
new产生的一个对象需要非常繁琐的过程(数据准备,访问权限)等
构造函数比较复杂
循环体中产生大量对象
优点:
性能优良,Java自带的原型模式是基于内存二进制流的拷贝,比直接new一个对象性能上提升了很多
可以是用深克隆方式保存对象的状态,使用原型模式将对象复制一份并将其状态保存起来,简化创建过程
缺点:
必须配备克隆方法
违反了开闭原则
深拷贝和浅拷贝运用需要得当
文/戴先生@2020年7月29日
—end—
本文地址:https://blog.csdn.net/dai_jiyong/article/details/107671369