【设计模式系列(三)】彻底搞懂原型模式

文章中涉及到的代码,可到这里来拿: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方法

}

这个类的成员变量特别多,如果手动创建的话需要写大量的代码

如果创建相同对象的需求也比较多

那该怎么办呢?

image

我们可以再这个类中新增一个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 + '\'' +
                '}';
    }
}

写一个测试类测试一下

image

“完美”克隆

这就是原型模式的一般形式

Java本身也带有一个Cloneable的接口

3. 浅克隆

进入Cloneable可以看到这个接口没有定义任何方法

clone()方法是定义在了Object类中

image

image

在上边例子的基础上,实现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岁

image

根据打印的结果

发现原始对象的年龄没有变化

但是朋友却跟着也增加了

这就是因为浅克隆的原因

当我们使用基本数据类型进行直接赋值操作的时候

原对象和复制对象的值是相互不影响的

但是,如果是非基本数据类型,则会是引用赋值

本本质就是仅仅是复制了一个指针,指向的实际对象是同一个

那么如何实现复制出来的对象时一个全新的对象,跟原对象没有任何关系呢?

这个时候就引出另外一个概念:深克隆

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;
        }
    }

修改测试类进行测试

image

完美解决

序列化的方式

如果一个对象想实现序列化,毕业要实现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();
            }
        }
    }

修改测试类,并执行

image

完美解决

推荐使用序列化的方式实现深克隆

5. 源码实现

Java底层有些类也重写了clone()方法,实现深克隆

比如ArrayList的clone()方法其实就是深克隆

image

我们都知道ArrayList的底层是基于数组实现

这个clone()方法就是在浅克隆的基础上

使用数组又新建了一个新的数组

并将新数组的内容复制给当前ArrayList,返回

6. 问题

原型模式的基本原理和使用方法基本都明白了

但是有一个致命的问题,如果使用原型模式去创建单例模式的对象

岂不是会破坏单例模式对象的唯一性?

其实这个问题也非常好解决

办法就是,如果是单例模式的类,那就不要实现克隆接口,不要提供clone()方法

你都单例了就为什么还要实现原型模式接口呢?

这样就能从源头上解决这个问题了

image

7. 总结

使用场景:

类的初始化消耗资源较多

new产生的一个对象需要非常繁琐的过程(数据准备,访问权限)等

构造函数比较复杂

循环体中产生大量对象

优点:

性能优良,Java自带的原型模式是基于内存二进制流的拷贝,比直接new一个对象性能上提升了很多

可以是用深克隆方式保存对象的状态,使用原型模式将对象复制一份并将其状态保存起来,简化创建过程

缺点:

必须配备克隆方法

违反了开闭原则

深拷贝和浅拷贝运用需要得当

文/戴先生@2020年7月29日

—end—

image

©️2020 CSDN 皮肤主题: 1024 设计师:上身试试 返回首页