设计模式：创建型模式——一碗面的五种获得方式

可视化演示

动态对比五种创建型模式（单例、工厂、抽象工厂、建造者、原型）的复杂度、灵活性与控制权，通过创建流程动画展示各模式的对象实例化路径与解耦方式。

模式概览：一碗面的五种获得方式

深夜的小林走进面馆，发现吃面这件事远不止一种打开方式。他可以让后厨师傅代劳、可以点成套的套餐、可以在窗口逐项定制、也可以直接照邻桌的样板复刻，当然，最硬核的是自己冲进后厨从头煮。五种方式对应着五种对“这碗面由谁创造、怎么创造”的不同回答。

软件世界里，这碗面就是“对象”，而对象的诞生方式正是创建型模式的领地。传统代码里一句 new 看似省事，实则把客户端与具体类绑在了一起——未来换实现类，所有 new 过它的地方都要跟着改，这种“牵一发动全身”的毛病就是耦合。创建型模式的核心目标，就是用结构化的方式降低耦合，让“创建”与“使用”各司其职。

创建型模式一共五员大将：单例管唯一实例；工厂方法把创建延迟到子类；抽象工厂按产品族成套生产；建造者把复杂构建拆成步骤；原型靠克隆复制对象。它们都是“开闭原则”的化身——对扩展开放，对修改关闭。用一个简单的指标可以感受解耦的收益：

小林把五种姿势想了一遍：自己下厨最累但掌控感最强，喊师傅代劳最省心但口味不由自己定，套餐最配套但灵活性最低。解耦度就像“你亲自下厨的比例”——当越来越多的面交给专业角色去完成，省下的力气就是未来换口味时的改造成本。创建型模式练的，正是这门“得体地外包做饭”的功夫。

单例模式：全城唯一的老字号

老城区有一家做了六十年的牛肉面馆，只此一家，别无分号。无论你哪天去，门口都是同一块褪色的招牌，锅里滚着同一锅老汤。食客再多，也从没见过第二家分店——有些东西，全城只能有一份。

程序世界里，“老汤”就是那些全局共享的资源。AI 实验里的配置（学习率、批量大小、数据路径）就是典型：如果每个模块各存一份，改一次配置就要全网同步，改漏一处立刻翻车。单例模式（Singleton）的使命就是保证“一个类在整个进程里只有一个实例，并提供全局唯一的访问入口”。

实现单例有三个要点：构造函数私有化，杜绝外界 new；用静态字段保存唯一实例；提供静态方法 getInstance() 作为唯一入口。按创建时机不同，又分饿汉式（类加载时立刻创建，简单但可能浪费资源）和懒汉式（第一次调用才创建，省资源但多线程下有风险）。多线程环境的经典解法是双重检查锁：先判空，再加锁，锁内再判空，既保证线程安全又避免每次调用都加锁的损耗。懒汉式单例的返回逻辑可以写成：

全城唯一的老字号，优点是极致的一致——东城食客和西城食客喝到的是同一锅汤；缺点也同样明显——想换个口味，全城都得跟着改。单例给了你“一锅汤”的确定性，却也悄悄藏起了全局状态，测试时想换一份 mock 汤底就得绕路。工程上，为这碗独一份的汤买单之前，先问一句：它真的全城只需要一份吗？

工厂方法：喊一声“来碗面”

小林懒得自己下厨，走进一家挂着“面馆”招牌的店，对服务员说：来碗面。他不关心后厨师傅是谁、用的是什么面粉，端上来的到底是兰州拉面、重庆小面还是刀削面，取决于他走进的是哪家分店。每家门面都挂同一块“面馆”的招牌，后厨却各显神通。

工厂方法模式（Factory Method）正是如此：定义一个创建对象的工厂接口，把“到底创建哪个具体产品”的决策延迟到子类。客户端只面对抽象产品与抽象工厂，不接触任何具体类——这就把“依赖具体实现”转成了“依赖抽象接口”，是依赖倒置原则的日常实践。

结构上包含四个角色：抽象产品（面条接口）、具体产品（拉面、小面）、抽象工厂（声明 create 方法）、具体工厂（实现 create 返回具体产品）。当新增一种面时，只需新增具体产品和对应工厂，客户端代码零改动。这个“产品类型由工厂类型决定”的关系可以写成：

点餐时你只管“要碗面”，至于后厨流派是子类的事。这省掉的正是“知道太多”的负担——当你想新增一家越南河粉分店时，老顾客菜单上那句“来碗面”一个字都不用改，这正是“对修改关闭、对扩展开放”的回报。

抽象工厂：牛肉面套餐的成套哲学

连锁品牌不会只卖单品。你点一个“牛肉面套餐”，端上来的是一整套：一碗红烧牛肉面、一碟小菜、一杯酸梅汤、一副印着品牌 logo 的木质餐具。所有东西风格统一、搭配和谐。如果单点，你可能会得到一碗与餐具完全不搭的面——这正是抽象工厂要消灭的混乱。

抽象工厂模式（Abstract Factory）解决的是“产品族”的一致性问题：当你要创建一组彼此关联、必须配套使用的对象（比如一套 UI 控件、一组数据访问组件）时，用同一个抽象工厂创建，就能保证这组对象的“风格”始终一致。与工厂方法每次只创建一个产品不同，抽象工厂一次创建一族产品。

代价是接口膨胀：每增加一种产品，所有工厂实现都要跟着改。所以它适合“产品族结构稳定、需要成套替换”的场景，比如换数据库时把 MySQL 系列组件整体换成 PostgreSQL 系列，像换一整套餐具而不是只换一个盘子。产品族的严格隔离可以这样表达：

就像你家的餐厅可以整桌换装：今天是中式八仙桌配青花瓷，明天是西式长桌配银质刀叉，但绝不会出现中式桌子配西式刀叉的混搭。抽象工厂给的就是这种“整桌成套”的确定性，代价是——想往套餐里加一道甜品，每个门店的配置单都得改一轮。

建造者模式：逐项定制一碗面

最挑剔的食客不会点套餐，而是走到窗口，对着师傅一步一步交代：面条要手工的，汤底要番茄的，加一个卤蛋，再加一把青菜，辣度微辣。师傅按着步骤逐一落实，最后端出一碗完全符合心意的面——这就是建造者的“分步构建”。

建造者模式（Builder）适用于“构造过程复杂且步骤可组合”的对象。它与工厂的区别在于：工厂关心“创建什么类型”，建造者关心“一个对象如何被一步步拼装”。当构造函数参数超过四五个时，直接 new 会面临参数顺序混乱、可读性差的困境。建造者的现代实现常用链式调用：每个 setter 返回自身，方法链一气呵成，把“参数多”变成了“步骤清晰”。

建造者模式包含指挥者（编排构建顺序）、抽象建造者（声明各步骤方法）、具体建造者（实现步骤）和产品四部分。步骤的编排可以抽象成函数复合：

定制窗口的妙处在于：师傅的记忆（指挥者）和你的需求（建造者）是分开的——换一个师傅，同样的步骤也可能做出不同风味；同一个师傅，按不同顺序也能玩出花样。这就是建造者的价值：把“怎么一步步做”和“最终做成什么”彻底拆开，各管各的。

原型模式：照这碗再来一份

邻桌那碗面端上来，面条筋道、汤色红亮，小林看得直咽口水。他不想等厨房从零重做，也不想费劲跟师傅描述，只消说一句“照这碗再来一份”。师傅瞄一眼样板，快速复制出一碗一模一样的——耗时之短，比自己下厨还快。

原型模式（Prototype）正是通过克隆已有对象来创建新对象，而不是重新走一遍构造函数。它有两类关键场景：一是创建对象成本高昂（比如要读数据库、跑复杂校验），二是新对象与原型只有少量差异。Python 里的 copy.copy 和 copy.deepcopy 就是现成的克隆工具。

克隆的隐患在于拷贝方式。浅拷贝只复制引用，新对象和原型共享内部对象——改一个会影响另一个；深拷贝递归复制整个对象图，各自独立但开销大。若对象图里含有可变容器，选择哪种拷贝直接影响正确性。拷贝成本可以这样建模：

“照这碗再来一份”看似取巧，实则需要谨慎：如果面条里藏着一碟众人共享的辣酱（可变引用），复制时是共用一个瓶子还是各分一瓶，直接决定两位食客会不会吃串味。搞懂深浅拷贝的边界，原型模式才能真正用得顺手、复制得放心。

选型决策：门口的五张菜单

站在面馆门口，小林该选哪一张菜单？自己下厨、单点、套餐、定制、复刻，没有绝对的好坏，只有合不合适的取舍。创建型模式的选型也一样，本质是在三个维度之间找平衡：控制权（创建逻辑握在谁手里）、扩展性（能不能不修改旧代码就支持新产品）、复杂度（为此多引入多少类与接口）。

用一张决策表辅助判断：对象简单、创建逻辑固定时直接 new 最省事；需要全局唯一时上单例；有一组同类产品且类型可能扩展时用工厂方法；需要成套产品保持一致时用抽象工厂；对象构造步骤多、参数杂时用建造者；创建成本高、差异小时用原型。

五者之间各有短板：工厂方法最均衡；抽象工厂扩展力强但接口重；单例实现简单但隐藏全局状态；原型性能好但拷贝语义有坑；建造者灵活但类会膨胀。用加权评分可以量化权衡：

面馆门口的选择题没有标准答案：一个人吃饭图快就自己下厨，请客要体面就点套餐，想独一无二就逐项定制。关键是别让“用设计模式”本身成为一种炫技——一把钥匙开一把锁，给锁配钥匙，而不是背着满口袋钥匙满街找锁。

实战应用：面馆开进 AI 实验室

面馆的哲学正在 AI 工程里生根发芽。训练一个深度学习模型，要“煮”的东西可不少：实验配置、数据集、模型、训练流水线，每一样都是对象，每一样都可能面对五种获得方式的选择——而选对了，能让整个训练流程清爽得多。

配置管理是单例的天然主场：学习率、批量大小、数据路径、随机种子，全进程只有一份 Config，所有模块统一读取，改一处全同步，实验复现也只需要记录这一份配置。模型工厂则是工厂方法最直观的落地：根据名称字符串创建 CNN、RNN、Transformer，调用方不必关心类名与 import 路径，为框架切换留出余地。

数据处理流水线适合建造者：读取 → 清洗 → 特征工程 → 归一化，按步骤链式组装，不同实验可复用不同步骤组合。超参数模板适合原型：从一份基准模板深拷贝出多份实验变体，只改少数参数就提交新一轮训练，避免从零构建的开销。三者的协作可以写成：

从面馆到实验室，底层逻辑相通：把“做面”的复杂性封装在专业角色里，让调用的代码像点餐一样简洁。AI 工程师每天面对成千上万次对象创建，用创建型模式把它们管得井井有条，才能在千行代码中气定神闲地调控那一碗“模型浓汤”。

AI 应用场景

Python 演示

# -*- coding: utf-8 -*-"""演示创建型模式: 单例-工厂方法-抽象工厂-建造者-原型"""import copyimport threading  class Config:    """单例模式: 全局唯一的配置中心, 双重检查锁保证线程安全"""    _instance = None    _lock = threading.Lock()     def __new__(cls):        # 第一重判断: 已存在则直接返回, 避免每次加锁        if cls._instance is None:            with cls._lock:                # 第二重判断: 锁内再次确认, 防止并发重复创建                if cls._instance is None:                    ins = super().__new__(cls)                    ins.data = {'lr': 0.001, 'batch': 32}                    cls._instance = ins        return cls._instance     def get(self, key):        return self.data.get(key)     def set(self, key, value):        self.data[key] = value  class ModelFactory:    """工厂方法模式: 按名称创建模型, 客户端不接触具体类"""    @staticmethod    def create(kind):        if kind == 'lr':            return 'LogisticRegressor'        if kind == 'cnn':            return 'ConvNet'        return 'RecurrentNet'  def make_combo(platform):    """抽象工厂模式: 按硬件平台成套返回 模型与加载器 产品族"""    if platform == 'gpu':        return ('Fp16Model', 'CudaLoader')    return ('Fp32Model', 'CpuLoader')  class PipelineBuilder:    """建造者模式: 分步构建数据流水线, 支持链式组合"""    def __init__(self):        self.parts = []     def add_read(self, path):        self.parts.append('read_' + path)        return self     def add_clean(self):        self.parts.append('clean')        return self     def add_norm(self):        self.parts.append('norm')        return self     def build(self):        return ' -> '.join(self.parts)  class HpTemplate:    """原型模式: 基准超参与模板, 深拷贝出独立实验变体"""    def __init__(self, lr=0.001, batch=32):        self.lr = lr        self.batch = batch     def clone(self, **kw):        obj = copy.deepcopy(self)        for k, v in kw.items():            setattr(obj, k, v)        return obj  def main():    c1 = Config()    c2 = Config()    c1.set('lr', 0.0001)    print('singleton:', c1 is c2, c2.get('lr'))    print('factory:', ModelFactory.create('cnn'))    print('abstract factory:', make_combo('gpu'))    p = (PipelineBuilder().add_read('train.csv').add_clean().add_norm().build())    print('builder:', p)    base = HpTemplate()    exp = base.clone(batch=64)    print('prototype:', exp.lr, exp.batch)  if __name__ == '__main__':    main()

1. if cls._instance is None:第一重判空，已创建就直接返回，省去每次加锁的开销。
2. with cls._lock:进入加锁临界区，保证并发下只有一个线程能执行创建。
3. ins = super().__new__(cls)真正分配实例内存的动作只发生一次，之后全部复用。
4. return cls._instance无论哪个线程调用，拿到的都是同一个对象。
5. def create(kind):工厂方法的统一入口，客户端只面向字符串和抽象接口。
6. if platform == 'gpu':抽象工厂按平台返回成套的“模型+加载器”产品族。
7. .add_read('train.csv').add_clean().add_norm()链式调用一步一步组装流水线，步骤可插拔。
8. obj = copy.deepcopy(self)深拷贝整个对象图，保证实验变体之间互不干扰。
9. for k, v in kw.items():在克隆体上逐项覆盖差异参数，实现“只改少数就开新实验”。

常见误区

面试题