05.原型模式：从影分身术到细胞分裂的编程艺术

目录

• • 序幕：当复制对象成为战略需求
  • 一、原型工厂的核心装备库
  • • [1.1 Java原生的浅克隆术](#1.1 Java原生的浅克隆术)
  • 二、深度克隆的炼金法则
  • • [2.1 手工克隆大法（硬核派）](#2.1 手工克隆大法（硬核派）)
    • [2.2 序列化克隆术（魔法派）](#2.2 序列化克隆术（魔法派）)
  • 三、原型模式的工业级装配
  • • [3.1 原型注册管理局](#3.1 原型注册管理局)
    • [3.2 Spring框架中的原型容器](#3.2 Spring框架中的原型容器)
  • 四、原型模式的性能实验室
  • • [4.1 克隆 vs New性能对决](#4.1 克隆 vs New性能对决)
  • 五、原型模式三十六计
  • • [5.1 浅克隆适用场景](#5.1 浅克隆适用场景)
    • [5.2 深克隆必备场景](#5.2 深克隆必备场景)
    • [5.3 模式选择决策树](#5.3 模式选择决策树)
  • 终章：复制之术的哲学思考

序幕：当复制对象成为战略需求

🎮 游戏开发现场 ：

你需要快速生成1000个外形相同但位置不同的敌人，直接new对象导致内存飙升？文档编辑器需要支持"无限撤销"功能，如何保存编辑状态的每一帧？这些场景都需要深谙"复制之道"的原型模式来破局！

---

一、原型工厂的核心装备库

1.1 Java原生的浅克隆术

// 基础忍者原型
public class Ninja implements Cloneable {
    private String name;
    private Weapon weapon; // 引用对象共享
    
    public Ninja(String name, Weapon weapon) {
        this.name = name;
        this.weapon = weapon;
    }
    
    @Override
    public Ninja clone() {
        try {
            return (Ninja) super.clone(); // 浅克隆
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 测试影分身效果
Ninji naruto = new Ninja("鸣人", new Kunai());
Ninja shadowClone = naruto.clone();

System.out.println(naruto == shadowClone); // false
System.out.println(naruto.weapon == shadowClone.weapon); // true ❗

浅克隆缺陷警告：

• 引用类型共享导致意外修改
• 嵌套对象无法实现真正隔离
• 需要人工递归克隆对象树

---

二、深度克隆的炼金法则

2.1 手工克隆大法（硬核派）

// 深克隆示例
public class DeepNinja implements Cloneable {
    private String name;
    private Weapon weapon;
    
    @Override
    public DeepNinja clone() {
        DeepNinja clone = (DeepNinja) super.clone();
        clone.weapon = this.weapon.clone(); // 武器也要克隆
        return clone;
    }
}

// 武器类的克隆支持
public class Weapon implements Cloneable {
    private String type;
    
    @Override
    public Weapon clone() {
        try {
            return (Weapon) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

2.2 序列化克隆术（魔法派）

// 基于序列化的深克隆工具
public class CloneUtils {
    @SuppressWarnings("unchecked")
    public static <T extends Serializable> T deepClone(T obj) {
        try (ByteArrayOutputStream bos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(bos)) {
            
            oos.writeObject(obj);
            
            try (ByteArrayInputStream bis = 
                    new ByteArrayInputStream(bos.toByteArray());
                 ObjectInputStream ois = new ObjectInputStream(bis)) {
                return (T) ois.readObject();
            }
        } catch (IOException | ClassNotFoundException e) {
            throw new RuntimeException("克隆失败", e);
        }
    }
}

// 测试魔法克隆
Ninja sasuke = new Ninja("佐助", new Sword());
Ninja cloneArmy = CloneUtils.deepClone(sasuke); 

---

三、原型模式的工业级装配

3.1 原型注册管理局

// 原型管理器
public class PrototypeRegistry {
    private static Map<String, Ninja> prototypes = new HashMap<>();
    
    static {
        prototypes.put("naruto", new Ninja("鸣人", new Rasengan()));
        prototypes.put("sakura", new Ninja("小樱", new MedicalSeal()));
    }
    
    public static Ninja getClone(String key) {
        return prototypes.get(key).clone();
    }
    
    public static void addPrototype(String key, Ninja ninja) {
        prototypes.put(key, ninja);
    }
}

// 快速生成克隆军团
Ninja army1 = PrototypeRegistry.getClone("naruto");
Ninja army2 = PrototypeRegistry.getClone("sakura");

3.2 Spring框架中的原型容器

// 原型Bean定义
@Component
@Scope(scopeName = ConfigurableBeanFactory.SCOPE_PROTOTYPE)
public class ReportPrototype {
    private byte[] content;
    
    public void loadData(File file) {
        // 加载大文件到内存...
    }
}

// 使用时获取新实例
public class ReportService {
    @Autowired
    private ApplicationContext context;
    
    public void generateReport() {
        ReportPrototype report = context.getBean(ReportPrototype.class);
        report.loadData(new File("data.xlsx"));
        // 使用完自动回收...
    }
}

---

四、原型模式的性能实验室

4.1 克隆 vs New性能对决

// 测试代码框架
long start = System.nanoTime();
for (int i = 0; i < 10000; i++) {
    // 方案A: new Ninja(...)
    // 方案B: prototype.clone()
}
long duration = System.nanoTime() - start;

测试结果对比（复杂对象创建场景）：

操作方式	耗时(纳秒)	内存占用(MB)
new	352,000	145
clone	78,000	62

结论：

• 对象构造越复杂，克隆优势越明显
• 简单对象反而可能new更快

---

五、原型模式三十六计

5.1 浅克隆适用场景

• 需要轻量级对象复制
• 确定所有引用都是不可变对象
• 需要与原型共享某些状态

5.2 深克隆必备场景

• 原型包含可变引用对象
• 需要完全隔离副本与原型
• 原型中存在集合或嵌套结构

5.3 模式选择决策树

Yes No Yes Yes No 需要创建对象副本? 对象是否包含可变引用? 使用浅克隆 使用深克隆 确认是否接受引用共享 完成

---

终章：复制之术的哲学思考

设计启示：

1. 克隆不是银弹，要评估对象复杂度
2. 深克隆可能引发"递归地狱"陷阱
3. 原型注册表可以成为系统单点故障

性能警钟：

// 错误！每次深克隆大文件对象
public class ReportService {
    private Report hugeReport; // 100MB的报表对象
    
    public Report createReport() {
        return CloneUtils.deepClone(hugeReport); // 灾难性性能！
    }
}

专家挑战 ：

当你的原型对象包含网络连接（Socket）这类不可序列化的资源时，如何实现安全的深克隆？把你的解决方案写在评论区！