设计模式——原型设计模式（创建型）
摘要
本文详细介绍了原型设计模式，这是一种创建型设计模式，通过复制现有对象（原型）来创建新对象，避免使用new关键字，可提高性能并简化对象创建逻辑。文章阐述了其优点，如提高性能、动态扩展和简化构造逻辑，以及缺点，如深拷贝实现复杂、复杂资源复制困难和易破坏封装性。还介绍了使用条件、结构、实现方式、适合场景和实战示例，并探讨了Spring中原型思想的应用。
1. 原型设计模式定义
原型设计模式是一种创建型设计模式，其核心思想是：通过复制现有的对象（原型）来创建新对象，而不是通过 new 关键字来实例化，从而提高性能并简化对象创建逻辑。使用原型实例指定创建对象的种类，并且通过拷贝这些原型来创建新的对象。
| 特性 | 说明 |
| 创建方式 | 使用已有对象（原型）复制创建，而不是 new |
| 拷贝类型 | 通常支持 浅拷贝 和 深拷贝 |
| 接口 | 通常实现 Cloneable接口，重写 clone()方法（Java） |
| 性能 | 适合对象创建代价高、结构复杂的场景 |
1.1. ✅ 原型模式的优点
- 提高性能：避免重复创建复杂对象。
- 动态扩展：在运行时动态创建对象。
- 简化构造逻辑：不用关心构造细节，只需拷贝。
1.2. ❌ 缺点
- 深拷贝实现复杂（需注意引用对象）
- 对象包含复杂资源（如数据库连接）时不易复制
- 克隆过程容易破坏封装性
1.3. 📌 原型设计模式使用条件
适合以下场景：
场景
说明
对象构造开销大
如数据库连接、网络通信等初始化代价高
对象构造逻辑复杂
包含多个参数、状态配置等
多个相似对象
只需要改变少部分属性
2. 原型设计模式结构
2.1. 原型设计模式类图
- 客户(Client)角色：客户类提出创建对象的请求。
- 抽象原型(Prototype)角色：这是一个抽象角色，通常由一个Java接口或Java抽象类实现。此角色给出所有的具体原型类所需的接口。
- 具体原型（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 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. 📌 实现步骤总结
步骤
描述
1. 实现 Cloneable接口
否则调用 clone()会抛异常
2. 重写 clone()方法
调用 super.clone()并处理引用类型字段
3. 深拷贝时递归调用子对象的 clone()
保证对象间完全独立
3.6. 💡 Tips（在项目中使用时注意）：
- 不要忘了处理 引用类型字段（深拷贝）
- 可以用工具类如 Apache Commons Lang 的 SerializationUtils.clone() 简化处理
- Java record 类型天然不可变，结合原型模式更安全
- Spring 中 @Scope("prototype") 是原型思想的一种应用
4. 原型设计模式适合场景
原型设计模式（Prototype Pattern）适用于通过复制（克隆）现有对象来快速创建新对象的场景。以下是它适用和不适用的场景对比：
4.1. ✅ 适合使用原型模式的场景
场景
说明
对象创建成本高
构造函数复杂、耗时（如 I/O、数据库、复杂计算)时，通过克隆避免重复创建
对象初始化复杂
需要设置很多配置/参数，克隆一个已初始化好的对象更方便
需要大量相似对象
如游戏中怪物/兵种生成、工作流中节点复制、表单复制等
运行时动态创建对象
不依赖类名和构造函数，只要能访问 prototype 对象即可
避免工厂或 new 创建的耦合
提高系统灵活性，符合开闭原则
4.2. ❌ 不适合使用原型模式的场景
场景
原因
对象结构简单、创建成本低
使用 new即可，没必要增加 clone 成本
对象包含复杂的循环引用关系
clone 实现困难，容易出错
频繁深拷贝，性能反而变差
clone 比 new 还慢，得不偿失
对象包含外部不可复制资源
如线程、Socket、数据库连接等资源不能复制
需要严格控制对象创建流程
比如工厂方法模式更适合定制构造逻辑
4.3. 🧠 实际项目应用建议
建议
说明
复杂对象或批量对象创建场景优先考虑
如任务调度系统中复制任务模板
引用类型多的对象必须小心实现深拷贝
避免共享引用带来的副作用
尽量配合原型注册表（原型缓存池）
管理所有 prototype 模板，集中创建
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 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 中如何实现这个思想？
Prototype 模式要素
Spring 的对应机制
原型对象
Bean 的定义（类 + 配置）
拷贝新对象
每次调用 getBean()，Spring 通过反射“创建新对象”
统一管理原型
由 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 的区别
特性
singleton（默认）
prototype
实例个数
全局一个
每次请求新建
生命周期管理
Spring 管
Spring 只负责创建，不管理销毁
适用场景
共享服务、无状态组件
有状态对象、频繁创建的临时对象
博文参考
- 创建型 - 原型模式(Prototype) | Java 全栈知识体系
- 原型设计模式
