java23种设计模式-原型模式

原型模式（Prototype Pattern）学习笔记

🌟 定义

原型模式属于创建型设计模式，通过复制现有对象（原型）来创建新对象，避免重复进行初始化操作。该模式的核心是实现对象的克隆能力。

🎯 适用场景

1. 对象创建成本较高（如数据库连接、复杂计算后的对象）
2. 需要避免重复初始化复杂对象
3. 需要动态配置对象的生成参数
4. 需要保存对象状态快照
5. 需要隔离对象创建与使用（如对象池技术）

🔧 模式结构

📐 类图

🛠️ 核心组成

1. Prototype（抽象原型接口）

   • 声明克隆方法的接口（通常为clone()）

2. ConcretePrototype（具体原型类）

   • 实现克隆方法的具体类
   • 可包含成员变量的深度复制逻辑

3. Client（客户端）

   • 通过调用原型对象的克隆方法创建新对象

📝 代码示例

基础实现（浅拷贝）

// 1. 实现Cloneable接口
class Resume implements Cloneable {
    private String name;
    private int age;
    private WorkExperience work;

    public Resume(String name, int age) {
        this.name = name;
        this.age = age;
        this.work = new WorkExperience();
    }

    // 2. 重写clone方法（浅拷贝）
    @Override
    public Resume clone() {
        try {
            return (Resume) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    // 设置工作经验
    public void setWork(String company, int years) {
        work.setCompany(company);
        work.setYears(years);
    }

    // 显示简历信息
    public void display() {
        System.out.printf("姓名：%s 年龄：%d\n", name, age);
        System.out.printf("工作经历：%s %d年\n", work.getCompany(), work.getYears());
    }
}

class WorkExperience {
    private String company;
    private int years;

    // getter/setter省略
}

// 客户端使用
public class Client {
    public static void main(String[] args) {
        Resume proto = new Resume("张三", 28);
        proto.setWork("阿里巴巴", 3);

        // 克隆对象
        Resume clone1 = proto.clone();
        clone1.setWork("腾讯", 2);  // 修改会影响原始对象（浅拷贝问题）
        
        proto.display();    // 显示腾讯工作经历（浅拷贝问题）
        clone1.display();
    }
}

改进实现（深拷贝）

class DeepResume implements Cloneable {
    private String name;
    private int age;
    private WorkExperience work;

    public DeepResume(String name, int age) {
        this.name = name;
        this.age = age;
        this.work = new WorkExperience();
    }

    // 深拷贝实现
    @Override
    public DeepResume clone() {
        try {
            DeepResume clone = (DeepResume) super.clone();
            clone.work = this.work.clone();  // 克隆引用对象
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }

    // WorkExperience也需要实现Cloneable
    static class WorkExperience implements Cloneable {
        @Override
        protected WorkExperience clone() throws CloneNotSupportedException {
            return (WorkExperience) super.clone();
        }
    }
}

✅ 优点

1. 避免重复初始化复杂对象
2. 动态获取对象运行状态
3. 可配合对象池提升性能
4. 比继承更灵活（不依赖具体类）
5. 符合开闭原则（通过克隆扩展对象）

⚠️ 缺点

1. 需要正确处理深/浅拷贝问题
2. 复杂对象的克隆可能比较麻烦
3. 需要为每个类实现克隆方法
4. 对final字段的克隆支持有限

🔄 相关模式对比

💡 实践建议

1. 深拷贝实现方式：

   • 递归调用clone方法
   • 序列化/反序列化
   • 使用JSON转换工具
   • 第三方库（如Apache Commons）

2. 克隆控制：

   • 使用原型管理器维护原型集合
   • 实现克隆注册机制
   • 支持原型版本控制

3. 性能优化：

   • 缓存常用原型对象
   • 并行化克隆过程
   • 延迟初始化克隆对象

🚀 典型应用场景

1. 游戏开发：快速生成大量相似NPC
2. 文档编辑：模板文档的克隆
3. 缓存系统：保存热点数据快照
4. 机器学习：模型参数的复制
5. 事务管理：保存对象状态用于回滚

📌 实现注意事项

1. Cloneable接口问题：

   • Java的Cloneable是标记接口（无方法）
   • 需要重写Object的clone()方法
   • clone()默认是浅拷贝

2. 深拷贝实现方案对比：

   方式	优点	缺点
   递归clone	原生支持	需要修改所有相关类
   序列化	自动深拷贝	性能较低，需要实现Serializable
   构造器复制	完全控制	需要维护构造逻辑

3. 克隆控制技巧：

   // 禁止克隆的示例
   public final class Uncloneable {
       @Override
       protected final Object clone() throws CloneNotSupportedException {
           throw new CloneNotSupportedException();
       }
   }
   

掌握原型模式的关键在于理解对象克隆机制与深浅拷贝的区别，合理使用可以显著提升系统性能，特别是在需要大量相似对象生成的场景下优势明显。