直接上结论：原型模式的核心是通过复制已有对象来创建新对象，避免重复初始化开销。适用于创建成本高的场景，如数据库查询、复杂计算或IO操作。

一、原型模式是什么？

通过克隆（Clone）现有对象生成新对象，而非通过new创建。Java通过Cloneable接口和Object.clone()实现。

// 1. 实现Cloneable接口
class UserProfile implements Cloneable {
    private String name;
    private int age;
    private List<String> permissions; // 引用类型需深拷贝

    public UserProfile(String name, int age, List<String> permissions) {
        // 模拟高成本初始化（如数据库查询）
        System.out.println("执行高成本初始化...");
        this.name = name;
        this.age = age;
        this.permissions = permissions;
    }

    // 2. 重写clone()方法
    @Override
    protected UserProfile clone() throws CloneNotSupportedException {
        // 浅拷贝基础类型
        UserProfile clone = (UserProfile) super.clone();
        // 手动深拷贝引用类型
        clone.permissions = new ArrayList<>(this.permissions);
        return clone;
    }
}

二、适用场景（什么时候用？）

1. 对象创建成本高

• 场景：初始化需查数据库、调用远程API、复杂计算。
• 案例：缓存用户配置模板，快速生成新用户。

public class PrototypeDemo {
    public static void main(String[] args) throws Exception {
        // 原始对象（高成本初始化）
        UserProfile template = new UserProfile("模板用户", 30, Arrays.asList("read", "write"));
        
        // 通过克隆创建新对象（避免初始化开销）
        UserProfile user1 = template.clone();
        user1.setName("用户1");
        
        UserProfile user2 = template.clone();
        user2.setName("用户2");

        System.out.println("user1权限：" + user1.getPermissions()); // [read, write]
        System.out.println("user2权限：" + user2.getPermissions()); // [read, write]
    }
}

2. 避免构造方法约束

• 场景：对象需多步骤构造，或构造方法被私有化。
• 案例：Spring框架中@Scope("prototype")的Bean。

3. 动态状态保存与恢复

• 场景：游戏存档、事务快照。
• 实现：克隆当前对象状态作为备份。

三、优点 vs 缺点

四、深拷贝 vs 浅拷贝（关键细节）

深拷贝实现方案：

1. 手动复制（如上文代码）
2. 序列化（推荐）

public UserProfile 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 (UserProfile) ois.readObject();
}

五、总结：什么时候该用原型模式？

• 用：当对象初始化成本高，且需频繁创建相似对象时（如配置模板、游戏实体）。
• 不用：若对象简单，或深拷贝成本高于初始化成本。

性能对比：

// 传统new创建（耗时高）
long start1 = System.nanoTime();
UserProfile userNew = new UserProfile("新用户", 25, Arrays.asList("read"));
long end1 = System.nanoTime();

// 原型克隆（耗时低）
long start2 = System.nanoTime();
UserProfile userClone = template.clone();
long end2 = System.nanoTime();

System.out.println("new创建耗时：" + (end1 - start1) + " ns"); // 约100000 ns
System.out.println("克隆耗时：" + (end2 - start2) + " ns");   // 约10000 ns

最终决策图：

创建对象成本高？ → Yes → 对象是否需独立状态？ → Yes → 用原型模式（深拷贝）  
                     ↓ No  
                   用单例模式  

六、原型模式在框架中的实战应用

1. Spring框架的Prototype Bean
Spring中@Scope("prototype")的Bean本质是原型模式，每次请求返回新实例：

@Component
@Scope("prototype") // 关键注解
public class PaymentProcessor implements Cloneable {
    private PaymentConfig config;
    
    @Override
    public PaymentProcessor clone() { ... }
}

// 使用
@Autowired
private ApplicationContext context;

public void processPayment() {
    // 每次获取新对象（避免线程安全问题）
    PaymentProcessor processor = context.getBean(PaymentProcessor.class);
    processor.execute();
}

2. JDK中的原型实现
java.util.Arrays#copyOf和ArrayList#clone均采用原型思想：

String[] arr1 = {"A", "B", "C"};
String[] arr2 = Arrays.copyOf(arr1, arr1.length); // 浅拷贝数组

七、避坑指南：深拷贝的3种解决方案

// 方案2：序列化实现深拷贝（通用版）
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 (Exception e) {
        throw new RuntimeException("深拷贝失败", e);
    }
}

八、性能优化：何时该放弃原型模式？

通过数学公式决策：

if (初始化成本C_init > 深拷贝成本C_copy * 创建次数N)  
    使用原型模式  
else  
    使用new创建

实测数据对比（单位：ns）：

结论：当对象初始化成本 > 2000ns或需创建 > 100次时，原型模式优势明显

九、终极实战：游戏角色克隆系统

场景需求：

• 基础角色模板包含技能树、装备等复杂配置
• 玩家创建角色时需快速复制模板
• 允许玩家自定义修改克隆体

// 1. 原型接口
interface GameCharacter extends Cloneable {
    GameCharacter clone();
    void customize(String name);
}

// 2. 具体原型类
class Warrior implements GameCharacter {
    private String name;
    private List<String> skills;
    private Equipment equipment; // 引用类型
    
    public Warrior(String name) {
        // 模拟高成本初始化（加载技能树/装备配置）
        this.skills = loadSkillsFromDB(); 
        this.equipment = loadEquipmentFromFile();
    }
    
    @Override
    public Warrior clone() {
        Warrior clone = new Warrior(this.name);
        // 深拷贝逻辑
        clone.skills = new ArrayList<>(this.skills);
        clone.equipment = this.equipment.deepCopy();
        return clone;
    }
    
    public void customize(String name) {
        this.name = name;
        // 添加自定义技能
        this.skills.add("Custom Skill");
    }
}

// 3. 客户端使用
public class GameSystem {
    private static GameCharacter warriorTemplate = new Warrior("战士模板");
    
    public static GameCharacter createPlayer(String name) {
        GameCharacter player = warriorTemplate.clone();
        player.customize(name); // 深度定制
        return player;
    }
}

十、总结：原型模式决策树

三条黄金法则：

1. 查成本：对象初始化含IO/复杂计算时必用原型
2. 验状态：克隆体需独立修改时强制深拷贝
3. 避冲突：final修饰字段需特殊处理（如通过构造器重置）

代码警示：

class Problem implements Cloneable {
    private final String id; // final字段！
    
    public Problem(String id) {
        this.id = id;
    }
    
    @Override
    public Problem clone() {
        // 错误！final字段无法在clone后修改
        return new Problem(this.id); // 正确方案：通过构造器
    }
}