11. 原型模式-优快云博客

本文链接：https://blog.youkuaiyun.com/sinat_33739100/article/details/146472258

原型模式（Prototype Pattern）是一种创建型设计模式，其核心思想是通过复制现有对象来创建新对象，而非通过类实例化。它适用于创建成本较高或需要动态配置的场景，通过克隆避免重复初始化，提升性能并简化对象创建逻辑。

核心概念

目的：通过复制原型对象快速生成新对象，减少资源消耗。
适用场景：
- 对象创建过程复杂（如数据库连接、复杂配置初始化）。
- 需要动态生成对象的不同状态副本（如游戏中的敌人克隆、文档模板复制）。
- 避免构造函数的重复调用（尤其是涉及IO或计算密集型操作时）。

结构组成

原型接口（Prototype）：
- 声明克隆方法（如 clone()），定义对象复制的标准。
具体原型类（Concrete Prototype）：
- 实现克隆方法，完成自身对象的复制（深拷贝或浅拷贝）。
客户端（Client）：
- 通过原型对象创建新实例，无需依赖具体类。

实现步骤

定义原型接口：声明克隆方法。
实现具体原型类：
- 实现 clone() 方法，复制对象属性。
- 注意处理引用类型的深拷贝问题。
客户端调用：
- 通过原型实例调用 clone() 生成新对象。

代码示例（Java）

以游戏中的角色克隆为例：

1. 原型接口（Cloneable）

Java 已内置 Cloneable 接口（标记接口），实际开发中需重写 Object.clone() 方法：

public interface CharacterPrototype extends Cloneable {
    CharacterPrototype clone() throws CloneNotSupportedException;
}

2. 具体原型类（GameCharacter）

public class GameCharacter implements CharacterPrototype {
    private String name;
    private Weapon weapon;  // 武器对象（引用类型，需深拷贝）
    
    public GameCharacter(String name, Weapon weapon) {
        this.name = name;
        this.weapon = weapon;
    }

    @Override
    public GameCharacter clone() throws CloneNotSupportedException {
        // 浅拷贝（基础类型和String直接复制）
        GameCharacter cloned = (GameCharacter) super.clone();
        // 手动深拷贝引用类型（如Weapon）
        cloned.weapon = this.weapon.clone(); 
        return cloned;
    }

    // Getter/Setter 省略
}

// 武器类也需实现Cloneable
class Weapon implements Cloneable {
    private String type;
    
    public Weapon(String type) {
        this.type = type;
    }

    @Override
    public Weapon clone() throws CloneNotSupportedException {
        return (Weapon) super.clone();
    }
}

3. 客户端调用

public class Client {
    public static void main(String[] args) throws Exception {
        // 创建原型对象
        Weapon sword = new Weapon("Sword");
        GameCharacter hero = new GameCharacter("Hero", sword);

        // 克隆新角色
        GameCharacter heroClone = hero.clone();
        heroClone.setName("Shadow Hero");
        heroClone.getWeapon().setType("Dark Sword");

        // 验证深拷贝
        System.out.println("Original Weapon: " + hero.getWeapon().getType()); // Sword
        System.out.println("Clone Weapon: " + heroClone.getWeapon().getType()); // Dark Sword
    }
}

深拷贝 vs 浅拷贝

类型	定义	实现方式
浅拷贝	仅复制对象本身及值类型字段，引用类型字段指向原对象地址。	直接调用 `super.clone()`，不处理引用类型。
深拷贝	复制对象及所有引用类型字段的实际数据，完全独立于原对象。	递归调用引用类型字段的 `clone()`，或通过序列化/反序列化实现（如JSON、字节流）。

模式优势

性能优化：避免重复执行构造函数或复杂初始化逻辑。
动态配置：通过修改原型对象批量生成不同配置的新对象。
简化创建逻辑：客户端无需了解对象创建细节。
与不可变对象兼容：适合生成不可变对象的变体（如配置模板）。

模式缺点

深拷贝实现复杂：需递归处理所有引用类型字段。
违反封装性：某些语言（如Java）的 clone() 方法需访问私有字段。
循环引用问题：对象间相互引用可能导致克隆逻辑死循环。

与其他模式对比

模式	区别
工厂模式	工厂模式通过类创建新对象；原型模式通过复制现有对象。
单例模式	单例模式限制实例数量；原型模式用于生成多个相似对象。
建造者模式	建造者模式分步构造复杂对象；原型模式直接复制已构造好的对象。

实际应用场景

游戏开发：
- 快速生成大量相同或微调的游戏角色、道具。
- 场景中重复元素（如树木、建筑）的实例化。
配置管理：
- 复制预配置的数据库连接对象、线程池参数模板。
文档处理：
- 克隆复杂格式的文档模板（如合同、报告）。
缓存优化：
- 缓存热点数据对象，通过克隆快速响应请求。

实现深拷贝的其他方式

1. 序列化/反序列化

import java.io.*;

public class DeepCopyUtil {
    // 通过序列化实现深拷贝
    public static <T> T deepCopy(T obj) throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(obj);
        
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (T) ois.readObject();
    }
}

// 要求所有引用类型必须实现 Serializable 接口
class Weapon implements Serializable { /* ... */ }
class GameCharacter implements Serializable { /* ... */ }

2. JSON 序列化（如使用 Jackson）

ObjectMapper mapper = new ObjectMapper();
GameCharacter clone = mapper.readValue(mapper.writeValueAsString(original), GameCharacter.class);

最佳实践

明确拷贝需求：优先使用浅拷贝，仅在必要时实现深拷贝。
使用工具类：借助序列化或第三方库（如Apache Commons）简化深拷贝。
标记不可克隆字段：通过 transient 关键字或自定义逻辑跳过某些字段。
防御性编程：处理 CloneNotSupportedException 并验证克隆结果。

总结

原型模式通过克隆机制高效创建对象，是解决复杂对象复制问题的经典方案。它特别适用于对象初始化成本高或需要动态生成变体的场景，但需谨慎处理深拷贝与引用关系。合理使用原型模式能显著提升系统性能，但需权衡实现复杂度与维护成本。