【设计模式系列（三）】彻底搞懂原型模式

你好戴先生

发布于 2020-09-01 23:41:03

5090

发布于 2020-09-01 23:41:03

文章被收录于专栏：戴言泛滥戴言泛滥

文章中涉及到的代码，可到这里来拿：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();            }        }    }

修改测试类，并执行