设计模式——原型设计模式（创建型）

摘要

本文详细介绍了原型设计模式，这是一种创建型设计模式，通过复制现有对象（原型）来创建新对象，避免使用new关键字，可提高性能并简化对象创建逻辑。文章阐述了其优点，如提高性能、动态扩展和简化构造逻辑，以及缺点，如深拷贝实现复杂、复杂资源复制困难和易破坏封装性。还介绍了使用条件、结构、实现方式、适合场景和实战示例，并探讨了Spring中原型思想的应用。

1. 原型设计模式定义

原型设计模式是一种创建型设计模式，其核心思想是：通过复制现有的对象（原型）来创建新对象，而不是通过 new 关键字来实例化，从而提高性能并简化对象创建逻辑。使用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。

1.1. ✅ 原型模式的优点

1. 提高性能：避免重复创建复杂对象。
2. 动态扩展：在运行时动态创建对象。
3. 简化构造逻辑：不用关心构造细节，只需拷贝。

1.2. ❌ 缺点

• 深拷贝实现复杂（需注意引用对象）
• 对象包含复杂资源（如数据库连接）时不易复制
• 克隆过程容易破坏封装性

1.3. 📌 原型设计模式使用条件

适合以下场景：

2. 原型设计模式结构

2.1. 原型设计模式类图

1. 客户(Client)角色：客户类提出创建对象的请求。
2. 抽象原型(Prototype)角色：这是一个抽象角色，通常由一个Java接口或Java抽象类实现。此角色给出所有的具体原型类所需的接口。
3. 具体原型（Concrete Prototype）角色：被复制的对象。此角色需要实现抽象的原型角色所要求的接口

2.2. 原型设计模式时序图

3. 原型设计模式实现方式

原型设计模式的实现方式核心在于 —— 通过克隆现有对象来创建新对象，而不是使用 new。在 Java 中，通常通过实现 Cloneable 接口并重写 clone() 方法来完成。下面是常见的两种实现方式：浅拷贝和深拷贝。

3.1. 🛠️ 原型模式实现方式

3.2. ✅ 浅拷贝示例（实现 Cloneable）

@Data
public class Person implements Cloneable {
    private String name;
    private int age;

    @Override
    public Person clone() {
        try {
            return (Person) super.clone(); // 浅拷贝
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

✅ 浅拷贝适用于字段都是基本类型或不可变类型（如 String）。

3.3. ✅ 深拷贝示例（引用字段也复制）

@Data
public class Person implements Cloneable {
    private String name;
    private int age;
    private Address address; // 引用类型

    @Override
    public Person clone() {
        try {
            Person cloned = (Person) super.clone();
            // 深拷贝 Address 对象
            cloned.address = address.clone();
            return cloned;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

@Data
class Address implements Cloneable {
    private String city;

    @Override
    public Address clone() {
        try {
            return (Address) super.clone();
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

3.4. 🔁 使用序列化实现深拷贝（通用方案）

public static <T extends Serializable> T deepCopy(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);
    }
}

3.5. 📌 实现步骤总结

3.6. 💡 Tips（在项目中使用时注意）：

• 不要忘了处理 引用类型字段（深拷贝）
• 可以用工具类如 Apache Commons Lang 的 SerializationUtils.clone() 简化处理
• Java record 类型天然不可变，结合原型模式更安全
• Spring 中 @Scope("prototype") 是原型思想的一种应用

4. 原型设计模式适合场景

原型设计模式（Prototype Pattern）适用于通过复制（克隆）现有对象来快速创建新对象的场景。以下是它适用和不适用的场景对比：

4.1. ✅ 适合使用原型模式的场景

4.2. ❌ 不适合使用原型模式的场景

4.3. 🧠 实际项目应用建议

5. 原型设计模式实战示例

在 Spring 项目中，原型设计模式（Prototype Pattern）最典型的应用方式是使用 Spring 的 @Scope("prototype") 注解来声明一个 Bean 为原型模式，使得每次注入都会创建一个新实例。

5.1. ✅ 示例：批量生成任务模板对象（适合原型模式场景）

5.1.1. 定义一个任务对象（复杂初始化逻辑）

@Data
public class Task implements Cloneable {
    private String name;
    private String type;
    private List<String> steps = new ArrayList<>();

    public Task(String name, String type) {
        this.name = name;
        this.type = type;
        this.steps.add("初始化");
        this.steps.add("执行中");
        this.steps.add("结束");
    }

    @Override
    public Task clone() {
        try {
            Task clone = (Task) super.clone();
            // 深拷贝
            clone.steps = new ArrayList<>(this.steps);
            return clone;
        } catch (CloneNotSupportedException e) {
            throw new RuntimeException(e);
        }
    }
}

5.1.2. Spring容器中定义该对象为原型 Bean

@Configuration
public class TaskConfig {

    @Bean
    @Scope("prototype") // 每次注入时都会创建新实例
    public Task taskPrototype() {
        return new Task("默认任务", "general");
    }
}

5.1.3. 任务服务中使用 Prototype Bean并进行克隆

@Service
public class TaskService {

    @Autowired
    private ApplicationContext applicationContext;

    public Task createNewTask(String name, String type) {
        // 每次从容器获取都会是一个新实例（原型）
        Task prototype = applicationContext.getBean(Task.class);
        Task newTask = prototype.clone(); // 克隆一份再设置参数
        newTask.setName(name);
        newTask.setType(type);
        return newTask;
    }
}

5.1.4. ✅ 为什么这是原型模式适合的场景？

6. 原型设计模式思考

6.1. Spring 中 @Scope("prototype") 是原型思想的一种应用？

使用 @Scope("prototype") 标注的 Bean，每次从 Spring 容器中获取时，都会创建一个全新的实例，而不是复用同一个对象。这就是“原型”的核心思想。

Prototype 模式的定义：“用原型实例指定创建对象的种类，并通过拷贝这些原型创建新的对象。”（即：通过复制一个“原型对象”来生成新对象）

6.1.1. Spring 中如何实现这个思想？

6.1.2. 示例

@Component
@Scope("prototype")
public class Task {
    public Task() {
        System.out.println("新任务实例被创建");
    }
}

@Autowired
private ApplicationContext applicationContext;

public void createTasks() {
    Task t1 = applicationContext.getBean(Task.class); // 创建一个新实例
    Task t2 = applicationContext.getBean(Task.class); // 再创建一个新实例
    System.out.println(t1 == t2); // false
}

6.1.3. prototype与singleton 的区别

博文参考

• 创建型 - 原型模式(Prototype) | Java 全栈知识体系
• 原型设计模式