Java 原型模式 详解

原型模式详解

一、原型模式概述

原型模式(Prototype Pattern)是一种创建型设计模式，它通过复制现有对象来创建新对象，而不是通过new关键字实例化。

核心特点

• 克隆代替新建：通过复制现有对象创建新实例
• 性能优势：避免昂贵的初始化过程
• 灵活性：运行时动态改变对象类型
• 简化创建：隐藏对象创建细节

二、原型模式的实现方式

1. 基本实现（浅拷贝）

// 实现Cloneable接口
public class Sheep implements Cloneable {
    private String name;
    private int age;
    
    public Sheep(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    // 重写clone方法
    @Override
    public Sheep clone() {
        try {
            return (Sheep) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
    
    // getter和setter
    public String getName() {
        return name;
    }
}

// 使用示例
Sheep original = new Sheep("Dolly", 2);
Sheep cloned = original.clone();

2. 深拷贝实现

public class DeepCloneExample implements Cloneable {
    private String data;
    private List<String> items;
    
    public DeepCloneExample(String data, List<String> items) {
        this.data = data;
        this.items = new ArrayList<>(items);
    }
    
    @Override
    public DeepCloneExample clone() {
        try {
            DeepCloneExample cloned = (DeepCloneExample) super.clone();
            // 对引用类型进行深拷贝
            cloned.items = new ArrayList<>(this.items);
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

3. 使用序列化实现深拷贝

import java.io.*;

public class DeepCopySerializable implements Serializable {
    private String name;
    private Date birthDate;
    
    public DeepCopySerializable deepCopy() {
        try {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(this);
            
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (DeepCopySerializable) ois.readObject();
        } catch (Exception e) {
            throw new RuntimeException("深拷贝失败", e);
        }
    }
}

三、原型模式的应用场景

1. 对象初始化成本高

public class ExpensiveObject implements Cloneable {
    private String data;
    private List<String> cachedResults;
    
    public ExpensiveObject() {
        // 模拟耗时初始化
        this.data = loadDataFromDatabase();
        this.cachedResults = computeExpensiveResults();
    }
    
    @Override
    public ExpensiveObject clone() {
        try {
            return (ExpensiveObject) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

// 使用示例
ExpensiveObject prototype = new ExpensiveObject();
ExpensiveObject copy = prototype.clone();

2. 游戏开发中的角色克隆

public abstract class GameCharacter implements Cloneable {
    protected String name;
    protected int health;
    protected List<Item> inventory;
    
    @Override
    public GameCharacter clone() {
        try {
            GameCharacter clone = (GameCharacter) super.clone();
            // 深拷贝inventory
            clone.inventory = new ArrayList<>(this.inventory);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
    
    public abstract void render();
}

3. 配置对象复制

public class SystemConfig implements Cloneable {
    private String theme;
    private int timeout;
    private Map<String, String> preferences;
    
    @Override
    public SystemConfig clone() {
        try {
            SystemConfig clone = (SystemConfig) super.clone();
            // 深拷贝Map
            clone.preferences = new HashMap<>(this.preferences);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

四、原型模式的变体

1. 原型管理器

import java.util.HashMap;
import java.util.Map;

public class PrototypeManager {
    private static Map<String, Cloneable> prototypes = new HashMap<>();
    
    static {
        prototypes.put("default", new DefaultPrototype());
        prototypes.put("custom", new CustomPrototype());
    }
    
    public static Cloneable getPrototype(String type) {
        return prototypes.get(type).clone();
    }
}

2. 结合工厂方法

public abstract class Shape implements Cloneable {
    public abstract void draw();
    
    @Override
    public Shape clone() {
        try {
            return (Shape) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new AssertionError();
        }
    }
}

public class ShapeFactory {
    private static Map<String, Shape> shapeMap = new HashMap<>();
    
    static {
        shapeMap.put("circle", new Circle());
        shapeMap.put("square", new Square());
    }
    
    public static Shape getShape(String type) {
        return shapeMap.get(type).clone();
    }
}

五、原型模式的注意事项

1. 深拷贝与浅拷贝

   • 浅拷贝：基本类型复制值，引用类型复制引用
   • 深拷贝：引用类型也创建新对象

2. Cloneable接口问题

   • clone()方法是Object类的protected方法
   • 需要重写为public方法
   • 考虑使用复制构造函数或工厂方法替代

3. final字段问题

   • 克隆后无法修改final字段的值
   • 需要特别注意final引用类型的字段

六、原型模式的优缺点

优点

1. 性能提升：避免昂贵的初始化过程
2. 简化创建：隐藏对象创建细节
3. 动态性：运行时决定实例类型
4. 减少子类：不需要为每种对象创建子类

缺点

1. 深拷贝复杂性：需要处理引用对象的复制
2. clone方法限制：需要实现Cloneable接口
3. 构造逻辑分散：初始化逻辑可能分布在构造函数和clone方法中

七、最佳实践

1. 考虑深拷贝需求：明确是否需要深拷贝
2. 文档化clone行为：明确说明clone方法的实现方式
3. 替代方案：考虑使用复制构造函数或静态工厂方法
4. 不可变对象：原型模式特别适合不可变对象
5. 结合其他模式：可与工厂方法、享元模式结合使用

八、总结

原型模式是创建型模式中独特的一种，它通过复制而非新建的方式创建对象，适用于：

• 对象创建成本高的场景
• 需要动态配置对象的场景
• 需要隔离对象创建细节的场景

在实际开发中，原型模式常见于：

• 游戏开发（角色、道具复制）
• 配置管理（配置模板复制）
• 缓存实现（原型缓存）
• 撤销/重做功能（状态保存与恢复）

正确使用原型模式可以显著提高系统性能，但需要注意深拷贝/浅拷贝的选择以及clone方法的正确实现。