设计模式之创建型设计模式详细解析(含示例)

创建型模式 (Creational Patterns)关注对象的创建机制旨在将对象的创建与使用分离提高系统的灵活性和可复用性。目录单例模式 (Singleton)工厂方法模式 (Factory Method)抽象工厂模式 (Abstract Factory)建造者模式 (Builder)原型模式 (Prototype)1. 单例模式 (Singleton)定义确保一个类只有一个实例并提供一个全局访问点来访问这个唯一实例。核心思想唯一性控制实例数量确保全局只有一个实例全局访问提供统一的访问入口延迟加载首次使用时才创建实例可选类比理解公司CEO一个公司只能有一位CEO所有公民都通过CEO这个称谓访问同一个人CEO职位是唯一的但具体人选可以更替结构┌─────────────────┐ │ Singleton │ ├─────────────────┤ │ - _instance │ ← 静态私有实例 │ - __init__() │ ← 私有构造函数 ├─────────────────┤ │ get_instance()│ ← 静态获取方法 │ business_logic│ └─────────────────┘Python 实现import threading from typing import Optional class Singleton: _instance: Optional[Singleton] None _lock: threading.Lock threading.Lock() def __new__(cls, *args, **kwargs): if cls._instance is None: with cls._lock: if cls._instance is None: cls._instance super().__new__(cls) cls._instance._initialized False return cls._instance def __init__(self): if self._initialized: return self._initialized True self.data 单例数据 print(单例实例被创建) def do_something(self): return f执行操作当前数据: {self.data} # 使用示例 print( 单例模式测试 ) s1 Singleton() s2 Singleton() print(fs1 和 s2 是同一对象: {s1 is s2}) # True print(fs1 数据: {s1.do_something()}) # 修改一个实例影响所有引用 s1.data 修改后的数据 print(fs2 看到的数据: {s2.data}) # 也是修改后的数据适用场景数据库连接池管理日志记录器配置信息管理线程池、缓存管理注意事项单例模式可能隐藏类之间的依赖关系在多线程环境中需要特别注意线程安全单元测试时可能带来困难全局状态2. 工厂方法模式 (Factory Method)定义定义一个用于创建对象的接口让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到其子类。核心思想解耦将对象创建与使用分离扩展性新增产品只需新增工厂无需修改现有代码开闭原则多态性通过统一的接口创建不同类型的对象类比理解餐厅点餐系统顾客客户端说我要一份主食抽象请求不同的分店具体工厂根据当地特色制作川菜店 → 宫保鸡丁粤菜店 → 白切鸡鲁菜店 → 糖醋鲤鱼顾客无需知道具体菜品如何制作只需通过点餐接口结构┌───────────────┐ ┌───────────────┐ │ Creator │────────→│ Product │ ├───────────────┤ ├───────────────┤ │ factory_method│ │ use() │ │ operation() │ └───────────────┘ └───────┬───────┘ △ │ │ ┌────┴────┐ ┌────┴────┐ ▼ ▼ ▼ ▼ ┌───────┐ ┌───────┐ ┌───────┐ ┌───────┐ │Concrete│ │Concrete│ │Concrete│ │Concrete│ │CreatorA│ │CreatorB│ │ProductA│ │ProductB│ └───────┘ └───────┘ └───────┘ └───────┘Python 实现from abc import ABC, abstractmethod # 抽象产品 class Transport(ABC): abstractmethod def deliver(self) - str: pass abstractmethod def capacity(self) - str: pass # 具体产品 class Truck(Transport): def deliver(self) - str: return 卡车在公路上运输货物 def capacity(self) - str: return 载重: 20吨 class Ship(Transport): def deliver(self) - str: return 轮船在海上运输货物 def capacity(self) - str: return 载重: 5000吨 class Airplane(Transport): def deliver(self) - str: return 飞机在空中运输货物 def capacity(self) - str: return 载重: 100吨 # 抽象工厂 class LogisticsFactory(ABC): abstractmethod def create_transport(self) - Transport: pass def plan_delivery(self, goods: str) - str: transport self.create_transport() return f计划配送 {goods}{transport.deliver()}{transport.capacity()} # 具体工厂 class RoadLogistics(LogisticsFactory): def create_transport(self) - Transport: print(公路工厂生产卡车...) return Truck() class SeaLogistics(LogisticsFactory): def create_transport(self) - Transport: print(海运工厂生产轮船...) return Ship() class AirLogistics(LogisticsFactory): def create_transport(self) - Transport: print(航空工厂生产飞机...) return Airplane() # 使用示例 print( 工厂方法模式物流系统 ) def client_code(factory: LogisticsFactory, goods: str): print(factory.plan_delivery(goods)) print() factories [ (RoadLogistics(), 电子产品), (SeaLogistics(), 原油), (AirLogistics(), 紧急药品) ] for factory, goods in factories: client_code(factory, goods)适用场景无法预知需要创建哪种具体对象希望由子类决定创建的对象类型需要扩展产品类型而不影响现有代码与简单工厂的区别特性简单工厂工厂方法创建逻辑集中在一个类中分散在各个子类扩展性修改工厂类违反开闭原则新增子类符合开闭原则复杂度简单较复杂3. 抽象工厂模式 (Abstract Factory)定义提供一个创建一系列相关或相互依赖对象的接口而无需指定它们具体的类。核心思想产品族创建一组相关的产品对象如UI组件按钮文本框下拉框一致性确保同一产品族的对象风格一致隔离性不同产品族之间互不影响类比理解家具品牌套装现代风格工厂生产玻璃桌 金属椅 简约灯古典风格工厂生产实木桌 皮椅 水晶灯客户选择现代风格后获得的所有家具都是现代风格不会出现混搭结构┌─────────────────┐ │ AbstractFactory │ ├─────────────────┤ │ createProductA()│ │ createProductB()│ └────────┬────────┘ │ ┌────┴────┐ ▼ ▼ ┌───────┐ ┌───────┐ │Concrete│ │Concrete│ │Factory1│ │Factory2│ └───┬───┘ └───┬───┘ │ │ ▼ ▼ ┌───────┐ ┌───────┐ │Product│ │Product│ │ A1B1 │ │ A2B2 │ ← 产品族 └───────┘ └───────┘Python 实现from abc import ABC, abstractmethod # 抽象产品族UI组件 class Button(ABC): abstractmethod def render(self) - str: pass abstractmethod def on_click(self) - str: pass class TextField(ABC): abstractmethod def render(self) - str: pass abstractmethod def input_text(self, text: str) - str: pass class Checkbox(ABC): abstractmethod def render(self) - str: pass abstractmethod def toggle(self) - str: pass # 具体产品Windows风格 class WinButton(Button): def render(self) - str: return [Windows风格按钮 - 直角边框] def on_click(self) - str: return Windows按钮被点击蓝色高亮 class WinTextField(TextField): def render(self) - str: return [Windows风格文本框 - 带边框] def input_text(self, text: str) - str: return fWindows文本框输入: {text} class WinCheckbox(Checkbox): def render(self) - str: return [Windows风格复选框 - 方形] def toggle(self) - str: return Windows复选框切换显示√ # 具体产品Mac风格 class MacButton(Button): def render(self) - str: return [Mac风格按钮 - 圆角渐变] def on_click(self) - str: return Mac按钮被点击弹性动画 class MacTextField(TextField): def render(self) - str: return [Mac风格文本框 - 无边框] def input_text(self, text: str) - str: return fMac文本框输入: {text}平滑动画 class MacCheckbox(Checkbox): def render(self) - str: return [Mac风格复选框 - 圆形] def toggle(self) - str: return Mac复选框切换显示● # 抽象工厂 class GUIFactory(ABC): abstractmethod def create_button(self) - Button: pass abstractmethod def create_text_field(self) - TextField: pass abstractmethod def create_checkbox(self) - Checkbox: pass # 具体工厂 class WindowsFactory(GUIFactory): def create_button(self) - Button: print(Windows工厂生产按钮...) return WinButton() def create_text_field(self) - TextField: print(Windows工厂生产文本框...) return WinTextField() def create_checkbox(self) - Checkbox: print(Windows工厂生产复选框...) return WinCheckbox() class MacFactory(GUIFactory): def create_button(self) - Button: print(Mac工厂生产按钮...) return MacButton() def create_text_field(self) - TextField: print(Mac工厂生产文本框...) return MacTextField() def create_checkbox(self) - Checkbox: print(Mac工厂生产复选框...) return MacCheckbox() # 客户端代码 class Application: def __init__(self, factory: GUIFactory): self.factory factory self.button factory.create_button() self.text_field factory.create_text_field() self.checkbox factory.create_checkbox() def render_ui(self): print(渲染UI界面:) print(self.button.render()) print(self.text_field.render()) print(self.checkbox.render()) def interact(self): print(用户交互:) print(self.button.on_click()) print(self.text_field.input_text(Hello World)) print(self.checkbox.toggle()) # 使用示例 print( 抽象工厂模式跨平台UI ) print(【配置1Windows风格】) app1 Application(WindowsFactory()) app1.render_ui() app1.interact() print() print(*50) print() print(【配置2Mac风格】) app2 Application(MacFactory()) app2.render_ui() app2.interact()适用场景系统需要独立于产品的创建、组合和表示系统需要配置多个产品族中的一个需要强调一系列相关产品对象的设计以便联合使用工厂方法与抽象工厂对比维度工厂方法抽象工厂产品数量单一产品产品族多个相关产品抽象层次一个抽象产品多个抽象产品复杂度较低较高扩展产品族容易新增工厂困难需修改所有工厂4. 建造者模式 (Builder)定义将一个复杂对象的构建与它的表示分离使得同样的构建过程可以创建不同的表示。核心思想分步构建复杂对象的创建分解为多个步骤灵活配置可以按需选择构建步骤隔离复杂性客户端无需知道内部构建细节类比理解定制电脑装机装机单Director定义装机流程选CPU→选主板→选内存→组装测试装机师傅Builder执行具体装机操作游戏配置i9 RTX4090 64GB内存办公配置i5 核显 16GB内存客户只需说明用途无需知道如何插内存条结构┌─────────┐ ┌─────────────┐ ┌───────────┐ │ Director│────→│ Builder │←────│ Client │ ├─────────┤ ├─────────────┤ └───────────┘ │ construct│ │ buildPartA()│ └─────────┘ │ buildPartB()│ │ getResult() │ └──────┬──────┘ │ ┌────────┴────────┐ ▼ ▼ ┌───────────┐ ┌───────────┐ │ Concrete │ │ Concrete │ │ Builder1 │ │ Builder2 │ └───────────┘ └───────────┘Python 实现from abc import ABC, abstractmethod from typing import Optional, List from dataclasses import dataclass, field # 产品电脑 dataclass class Computer: cpu: str gpu: str ram: int 0 storage: str motherboard: str power_supply: str case: str rgb_lighting: bool False water_cooling: bool False wifi_module: bool False def __str__(self) - str: specs [ f电脑配置清单:, f CPU: {self.cpu}, f GPU: {self.gpu}, f 内存: {self.ram}GB, f 存储: {self.storage}, f 主板: {self.motherboard}, f 电源: {self.power_supply}, f 机箱: {self.case}, f RGB灯效: {开启 if self.rgb_lighting else 关闭}, f 水冷散热: {开启 if self.water_cooling else 关闭}, f WiFi模块: {开启 if self.wifi_module else 关闭}, ] return \n.join(specs) # 抽象建造者 class ComputerBuilder(ABC): abstractmethod def reset(self): pass abstractmethod def set_cpu(self, model: str): pass abstractmethod def set_gpu(self, model: str): pass abstractmethod def set_ram(self, size: int): pass abstractmethod def set_storage(self, spec: str): pass abstractmethod def set_motherboard(self, model: str): pass abstractmethod def set_power_supply(self, wattage: str): pass abstractmethod def set_case(self, type: str): pass abstractmethod def add_rgb_lighting(self): pass abstractmethod def add_water_cooling(self): pass abstractmethod def add_wifi_module(self): pass abstractmethod def get_computer(self) - Computer: pass # 具体建造者 class GamingComputerBuilder(ComputerBuilder): def __init__(self): self.reset() def reset(self): self._computer Computer() def set_cpu(self, model: str): self._computer.cpu model if model else Intel i9-13900K return self def set_gpu(self, model: str): self._computer.gpu model if model else NVIDIA RTX 4090 return self def set_ram(self, size: int): self._computer.ram size if size else 64 return self def set_storage(self, spec: str): self._computer.storage spec if spec else 2TB NVMe SSD 4TB HDD return self def set_motherboard(self, model: str): self._computer.motherboard model if model else ROG Z790-E Gaming return self def set_power_supply(self, wattage: str): self._computer.power_supply wattage if wattage else 1000W 80Plus Gold return self def set_case(self, type: str): self._computer.case type if type else 全塔侧透钢化玻璃 return self def add_rgb_lighting(self): self._computer.rgb_lighting True print(添加RGB灯效系统) return self def add_water_cooling(self): self._computer.water_cooling True print(安装360mm水冷散热) return self def add_wifi_module(self): self._computer.wifi_module True print(集成WiFi 6E模块) return self def get_computer(self) - Computer: computer self._computer self.reset() return computer class OfficeComputerBuilder(ComputerBuilder): def __init__(self): self.reset() def reset(self): self._computer Computer() def set_cpu(self, model: str): self._computer.cpu model if model else Intel i5-13400 return self def set_gpu(self, model: str): self._computer.gpu model if model else Intel UHD 核显 return self def set_ram(self, size: int): self._computer.ram size if size else 16 return self def set_storage(self, spec: str): self._computer.storage spec if spec else 512GB SATA SSD return self def set_motherboard(self, model: str): self._computer.motherboard model if model else B660M 商务版 return self def set_power_supply(self, wattage: str): self._computer.power_supply wattage if wattage else 400W 静音电源 return self def set_case(self, type: str): self._computer.case type if type else 紧凑型商务机箱 return self def add_rgb_lighting(self): print(办公电脑不建议添加RGB灯效) return self def add_water_cooling(self): print(办公电脑使用风冷即可) return self def add_wifi_module(self): self._computer.wifi_module True print(添加WiFi模块办公便利) return self def get_computer(self) - Computer: computer self._computer self.reset() return computer # 指挥者Director class ComputerDirector: def __init__(self, builder: ComputerBuilder): self._builder builder def build_minimal(self) - Computer: return (self._builder .set_cpu() .set_ram(0) .get_computer()) def build_full_featured(self) - Computer: return (self._builder .set_cpu() .set_gpu() .set_ram(0) .set_storage() .set_motherboard() .set_power_supply() .set_case() .add_rgb_lighting() .add_water_cooling() .add_wifi_module() .get_computer()) # 使用示例 print( 建造者模式电脑装机 ) print(【配置1通过Director构建顶配游戏电脑】) gaming_builder GamingComputerBuilder() director ComputerDirector(gaming_builder) gaming_pc director.build_full_featured() print(gaming_pc) print() print(*50) print() print(【配置2客户端自定义办公电脑】) office_builder OfficeComputerBuilder() office_pc (office_builder .set_cpu(Intel i7-13700) .set_ram(32) .set_storage(1TB NVMe SSD) .add_wifi_module() .get_computer()) print(office_pc) print() print(*50) print() print(【配置3自定义高端工作站】) workstation_builder GamingComputerBuilder() workstation (workstation_builder .set_cpu(AMD Ryzen 9 7950X) .set_gpu(NVIDIA RTX 4080) .set_ram(128) .set_storage(4TB NVMe SSD RAID) .add_water_cooling() .add_wifi_module() .get_computer()) print(workstation)适用场景创建复杂对象且需要分步骤配置对象有多种配置组合需要避免构造函数爆炸需要创建不同表示的相似对象与工厂模式的区别工厂模式关注创建单个产品是什么建造者模式关注创建产品的过程怎么做支持分步骤、可配置5. 原型模式 (Prototype)定义用原型实例指定创建对象的种类并通过复制这些原型创建新的对象。核心思想克隆通过复制现有对象创建新对象避免子类化无需通过子类创建对象保留状态新对象继承原对象的状态类比理解文件复印原版文件原型一份已填写好的表格复印机克隆机制制作完全相同的副本修改副本可以在复印件上修改不影响原件效率比重新填写一份新表格快得多结构┌─────────────────┐ │ Prototype │ ├─────────────────┤ │ clone() │ ← 克隆方法 └────────┬────────┘ │ ┌────┴────┐ ▼ ▼ ┌───────┐ ┌───────┐ │Concrete│ │Concrete│ │PrototypeA│ │PrototypeB│ └───────┘ └───────┘Python 实现import copy from abc import ABC, abstractmethod from typing import List, Optional, Dict, Any from dataclasses import dataclass, field # 抽象原型 class Prototype(ABC): abstractmethod def clone(self) - Prototype: pass abstractmethod def deep_clone(self) - Prototype: pass # 具体原型文档模板 dataclass class DocumentTemplate(Prototype): name: str content: str format_settings: Dict[str, Any] field(default_factorydict) metadata: Dict[str, Any] field(default_factorydict) sections: List[str] field(default_factorylist) def __post_init__(self): if not self.format_settings: self.format_settings { font: Arial, font_size: 12, line_spacing: 1.5, margin: 2cm } def clone(self) - DocumentTemplate: print(f浅拷贝文档: {self.name}) new_doc copy.copy(self) new_doc.name f{self.name}_副本 return new_doc def deep_clone(self) - DocumentTemplate: print(f深拷贝文档: {self.name}) new_doc copy.deepcopy(self) new_doc.name f{self.name}_深拷贝 return new_doc def display_info(self): print(f 名称: {self.name}) content_preview self.content[:30] ... if len(self.content) 30 else self.content print(f 内容: {content_preview}) print(f 格式: {self.format_settings}) print(f 章节: {self.sections}) print(f 元数据: {self.metadata}) # 原型管理器注册表 class DocumentRegistry: def __init__(self): self._prototypes: Dict[str, DocumentTemplate] {} def register(self, key: str, prototype: DocumentTemplate): self._prototypes[key] prototype print(f注册模板: {key}) def unregister(self, key: str): del self._prototypes[key] print(f注销模板: {key}) def create_document(self, key: str, deep: bool False) - Optional[DocumentTemplate]: prototype self._prototypes.get(key) if prototype is None: print(f未找到模板: {key}) return None if deep: return prototype.deep_clone() else: return prototype.clone() def list_templates(self): print(可用模板列表:) for key in self._prototypes.keys(): print(f - {key}) # 使用示例 print( 原型模式文档模板系统 ) registry DocumentRegistry() print(【步骤1创建并注册原型模板】) report_template DocumentTemplate( name季度报告模板, content【季度总结】\n1. 业绩概述\n2. 数据分析\n3. 下季度计划, sections[封面, 目录, 正文, 附录], metadata{author: 公司模板, version: v2.0, confidential: True} ) registry.register(quarterly_report, report_template) contract_template DocumentTemplate( name劳动合同模板, content【劳动合同】\n甲方[公司名称]\n乙方[员工姓名]\n..., format_settings{font: 宋体, font_size: 14, line_spacing: 2.0}, sections[合同条款, 签字页], metadata{type: legal, reviewed_by: 法务部} ) registry.register(employment_contract, contract_template) registry.list_templates() print() print(【步骤2基于原型创建新文档】) print(--- 创建Q1报告浅拷贝---) q1_report registry.create_document(quarterly_report, deepFalse) if q1_report: q1_report.content q1_report.content.replace(季度总结, 2024 Q1总结) q1_report.metadata[department] 销售部 q1_report.display_info() print() print(--- 创建Q2报告深拷贝---) q2_report registry.create_document(quarterly_report, deepTrue) if q2_report: q2_report.content q2_report.content.replace(季度总结, 2024 Q2总结) q2_report.metadata[department] 技术部 q2_report.format_settings[font] Times New Roman q2_report.display_info() print() print(【步骤3验证原型未被修改】) print(原始模板状态:) report_template.display_info() print() print(【步骤4深拷贝 vs 浅拷贝对比】) print(修改Q2报告的格式深拷贝观察是否影响Q1:) print(fQ1格式字体: {q1_report.format_settings[font]}) print(fQ2格式字体: {q2_report.format_settings[font]}) print(f原始模板字体: {report_template.format_settings[font]}) print() print(【步骤5创建劳动合同实例】) contract registry.create_document(employment_contract, deepTrue) if contract: contract.content contract.content.replace([公司名称], 科技创新有限公司) contract.content contract.content.replace([员工姓名], 张三) contract.metadata[employee_id] EMP2024001 contract.display_info()适用场景创建新对象成本较高如需要复杂计算或数据库查询需要复制对象状态而不仅是创建空对象类层次结构复杂通过子类化创建对象不现实需要避免与产品类层次结构平行的工厂类层次结构深拷贝 vs 浅拷贝特性浅拷贝 (Shallow Copy)深拷贝 (Deep Copy)基本类型复制值复制值引用类型复制引用共享对象递归复制整个对象性能快慢内存占用少多修改影响可能意外影响其他对象完全独立Python实现copy.copy()copy.deepcopy()创建型模式对比总结模式核心意图最佳使用场景复杂度单例唯一实例控制全局共享资源管理低工厂方法延迟实例化到子类需要灵活扩展产品类型中抽象工厂创建产品族需要保证产品一致性跨平台UI高建造者分步构建复杂对象对象配置多样、步骤复杂中原型通过复制创建对象创建成本高、需保留状态低选择决策树需要控制实例数量 ├─ 是 → 单例模式 └─ 否 → 需要创建复杂对象 ├─ 是 → 需要分步配置 │ ├─ 是 → 建造者模式 │ └─ 否 → 原型模式复制现有 └─ 否 → 需要创建多种相关产品 ├─ 是 → 需要产品族一致性 │ ├─ 是 → 抽象工厂 │ └─ 否 → 工厂方法 └─ 否 → 简单工厂或直接创建