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

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