《深入剖析原型模式：浅克隆、深克隆与单例模式的碰撞》

Nonullpoint.2024-08-20 18:00

3.原型模式

一、引言

在 Java 编程中，原型模式（Prototype）是一种创建对象的方式，通过拷贝原型实例来创建新的对象，为对象的创建提供了一种高效且灵活的途径。本文将详细探讨原型模式的概念、包含的角色、浅克隆与深克隆的实现，以及克隆对单例模式的影响和相应的解决办法。

二、原型模式的定义

原型模式是指原型实例指定创建对象的种类，并且通过拷贝这些原型创建新的对象。调用者不需要知道任何创建细节，不调用构造函数。

三、原型模式的角色

  1. 抽象原型类 ：规定了具体原型对象必须实现的 clone() 方法。
  2. 具体原型类 ：实现抽象原型类的 clone() 方法，是可被复制的对象。
  3. 访问类 ：使用具体原型类中的 clone() 方法来复制新的对象。

四、简单的原型模式示例

java 复制代码 
@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Cloneable {
    private String name;
    private String sex;
    private Integer age;

    /**
     * 重写 clone 方法，实现对象的复制
     * @return 复制后的对象
     * @throws CloneNotSupportedException 若不支持克隆则抛出此异常
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    /**
     * 主函数，用于测试原型模式的基本用法
     * @param args 命令行参数
     * @throws Exception 可能抛出的异常
     */
    public static void main(String[] args) throws Exception{
        Student stu1 = new Student("小明", "男", 18);
        // 通过克隆创建 stu2 对象
        Student stu2 = (Student)stu1.clone();
        stu2.setName("小红");
        // 输出 stu1 的信息
        System.out.println(stu1); // Student(name=小明, sex=男, age=18)
        // 输出 stu2 的信息
        System.out.println(stu2); // Student(name=小红, sex=男, age=18)
    }
}

可以看到，把一个学生复制过来，只是改了姓名而已，其他属性完全一样没有改变。需要注意的是，一定要在被拷贝的对象上实现 Cloneable 接口，否则会抛出 CloneNotSupportedException 异常。

四、浅克隆

浅克隆的定义：浅克隆创建一个新对象，新对象的属性和原来对象完全相同，但对于非基本类型属性，仍指向原有属性所指向的对象的内存地址。

java 复制代码 
@Data
public class Clazz implements Cloneable {
    private String name;
    private Student student;

    /**
     * 重写 clone 方法，实现浅克隆
     * @return 浅克隆后的对象
     * @throws CloneNotSupportedException 若不支持克隆则抛出此异常
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }
}

@Data
@AllArgsConstructor
@NoArgsConstructor
public class Student implements Serializable {
    private String name;
    private String sex;
    private Integer age;
}

/**
 * 主函数，用于测试浅克隆
 * @param args 命令行参数
 * @throws Exception 可能抛出的异常
 */
public static void main(String[] args) throws Exception{
    Clazz clazz1 = new Clazz();
    clazz1.setName("大一");
    Student stu1 = new Student("小明", "男", 18);
    clazz1.setStudent(stu1);
    // 输出 clazz1 的信息
    System.out.println(clazz1); // Clazz(name=大一, student=Student(name=小明, sex=男, age=18))
    Clazz clazz2 = (Clazz)clazz1.clone();
    Student stu2 = clazz2.getStudent();
    stu2.setName("小红");
    // 输出 clazz1 的信息
    System.out.println(clazz1); // Clazz(name=大一, student=Student(name=小红, sex=男, age=18))
    // 输出 clazz2 的信息
    System.out.println(clazz2); // Clazz(name=大一, student=Student(name=小红, sex=男, age=18))
}

可以看到，当修改了 stu2 的姓名时，stu1 的姓名同样也被修改了，这说明 stu1 和 stu2 是同一个对象，这就是浅克隆的特点，对具体原型类中的引用类型的属性进行引用的复制。同时，这也可能是浅克隆所带来的弊端，因为结合该例子的原意，显然是想在班级中新增一名叫小红的学生，而非让所有的学生都改名叫小红，于是我们这里就要使用深克隆。

五、深克隆

深克隆的定义：深克隆创建一个新对象，属性中引用的其他对象也会被克隆，不再指向原有对象地址。

java 复制代码 
@Data
public class Clazz implements Cloneable, Serializable {
    private String name;
    private Student student;

    /**
     * 重写 clone 方法，实现浅克隆
     * @return 浅克隆后的对象
     * @throws CloneNotSupportedException 若不支持克隆则抛出此异常
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return super.clone();
    }

    /**
     * 实现深克隆的方法
     * @return 深克隆后的对象
     * @throws IOException 输入输出异常
     * @throws ClassNotFoundException 类未找到异常
     */
    protected Object deepClone() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return ois.readObject();
    }
}

/**
 * 主函数，用于测试深克隆
 * @param args 命令行参数
 * @throws Exception 可能抛出的异常
 */
public static void main(String[] args) throws Exception{
    Clazz clazz1 = new Clazz();
    clazz1.setName("大一");
    Student stu1 = new Student("小明", "男", 18);
    clazz1.setStudent(stu1);
    Clazz clazz3 = (Clazz)clazz1.deepClone();
    Student stu3 = clazz3.getStudent();
    stu3.setName("王五");
    // 输出 clazz1 的信息
    System.out.println(clazz1); // Clazz(name=大一, student=Student(name=小明, sex=男, age=18))
    // 输出 clazz3 的信息
    System.out.println(clazz3); // Clazz(name=大一, student=Student(name=王五, sex=男, age=18))
}

可以看到，当修改了 stu3 的姓名时，stu1 的姓名并没有被修改了，这说明 stu3 和 stu1 已经是不同的对象了，说明 Clazz 中的 Student 也被克隆了，不再指向原有对象地址，这就是深克隆。这里需要注意的是，Clazz 类和 Student 类都需要实现 Serializable 接口，否则会抛出 NotSerializableException 异常。

六、克隆破坏单例与解决办法

java 复制代码 
// Clazz 类
@Data
public class Clazz implements Cloneable, Serializable {
    private static Clazz clazz = new Clazz();
    private String name;
    private Student student;

    /**
     * 私有构造函数，防止外部创建实例
     */
    private Clazz(){}

    /**
     * 获取单例实例的方法
     * @return 单例实例
     */
    public static Clazz getInstance() {
        return clazz;
    }

    /**
     * 重写 clone 方法，解决克隆破坏单例的问题
     * @return 单例实例
     * @throws CloneNotSupportedException 若不支持克隆则抛出此异常
     */
    @Override
    protected Object clone() throws CloneNotSupportedException {
        return clazz;
    }
}

/**
 * 测试克隆是否破坏单例
 * @param args 命令行参数
 * @throws Exception 可能抛出的异常
 */
public static void main(String[] args) throws Exception{
    Clazz clazz1 = Clazz.getInstance();
    Clazz clazz2 = (Clazz)clazz1.clone();
    // 输出比较结果
    System.out.println(clazz1 == clazz2); // false

    // 重写 clone 方法后的测试
    Clazz clazz3 = Clazz.getInstance();
    Clazz clazz4 = (Clazz)clazz3.clone();
    System.out.println(clazz3 == clazz4); // true
}

可以看到 clazz1 和 clazz2 并不相等，也就是说他们并不是同一个对象，单例被破坏了。

解决办法：

  1. 不实现 Cloneable 接口即可，但不实现 Cloneable 接口进行 clone 则会抛出 CloneNotSupportedException 异常。
  2. 重写 clone() 方法，返回单例对象。

另外我们知道，单例就是只有一个实例对象，如果重写了 clone() 方法保证单例的话，那么通过克隆出来的对象则不可以重新修改里面的属性，因为修改以后就会连同克隆对象一起被修改，所以是需要单例还是克隆，在实际应用中需要好好衡量。

七、总结

  1. 适用场景：
    • 类初始化消耗资源较多。
    • new 产生的一个对象需要非常繁琐的过程（数据准备、访问权限等）。
    • 构造函数比较复杂。
    • 循环体中生产大量对象时。
  2. 优点：
    • 性能优良，Java 自带的原型模式是基于内存二进制流的拷贝，比直接 new 一个对象性能上提升了许多。
    • 可以使用深克隆方式保存对象的状态，使用原型模式将对象复制一份并将其状态保存起来，简化了创建的过程。
  3. 缺点：
    • 必须配备克隆（或者可拷贝）方法。
    • 当对已有类进行改造的时候，需要修改代码，违反了开闭原则。
    • 深克隆、浅克隆需要运用得当。
相关推荐
Zhangzy@8 小时前
仓颉的空安全基石：Option类型的设计与实践
java·开发语言·安全
IDOlaoluo9 小时前
FindBugs-IDEA-1.0.1.zip安装使用教程（IntelliJ IDEA插件手动安装查Bug）
java·bug·intellij-idea
你的人类朋友14 小时前
设计模式的原则有哪些？
前端·后端·设计模式
程序员小凯14 小时前
Spring Boot文件处理与存储详解
java·spring boot·后端
Miraitowa_cheems15 小时前
LeetCode算法日记 - Day 88: 环绕字符串中唯一的子字符串
java·数据结构·算法·leetcode·深度优先·动态规划
黑云压城After15 小时前
vue2实现图片自定义裁剪功能(uniapp)
java·前端·javascript
zcl_199117 小时前
记一次ThreadLocal导致的生产事故
java
RoboWizard17 小时前
怎么判断我的电脑是否支持PCIe 5.0 SSD？Kingston FURY Renegade G5
java·spring·智能手机·电脑·金士顿
毕设源码-钟学长17 小时前
【开题答辩全过程】以 儿童游泳预约系统为例，包含答辩的问题和答案
java·eclipse
皮皮林55118 小时前
5种接口频率监控方案实战对比，性能、成本、复杂度全解析！
java
热门推荐
01GitHub 镜像站点02UV安装并设置国内源03BongoCat - 跨平台键盘猫动画工具04GitLab 零基础入门指南：从安装到项目管理全流程05Linux下V2Ray安装配置指南06NVIDIA显卡驱动、CUDA、cuDNN 和 TensorRT 版本匹配指南07Labelme从安装到标注：零基础完整指南08安娜的档案(Anna’s Archive) 镜像网站/国内最新可访问入口（持续更新）09在VSCode配置Java开发环境的保姆级教程（适配各类AI编程IDE）10jdk21下载、安装（Windows、Linux、macOS）