罗罗编程学习记录
本页内容 展开查看

01.3.2.2 工厂模式家族

所属:全栈开发面试题库 / 01 计算机基础与通用工程 / 01.3 设计模式与架构基础 / 01.3.2 常用设计模式多语言详解

覆盖范围

  • 简单工厂、工厂方法、抽象工厂三者的结构差异与演进路径
  • 注册表工厂(Map / 字典分发)消除 if/else
  • 函数式工厂:Go 返回接口的函数、TS 高阶工厂、Python 闭包工厂
  • 依赖注入容器作为工厂的终极形态:创建 + 组装 + 生命周期
  • Spring BeanFactory 与 ApplicationContext 的工厂语义
  • ASP.NET Core IServiceCollection 三种注册方式与作用域
  • Laravel 容器 bind / singleton / scoped 的区别
  • Gin 无容器时的手工组装与 handler 依赖注入
  • Rust 用 enum 分派与 trait object 实现工厂的取舍
  • TypeScript 工厂函数与可辨识联合类型
  • PHP 静态工厂方法与命名构造
  • 工厂与策略的边界、过度设计判断

面试题索引

编号 题目 难度 状态 备注
01.3.2.2-001 简单工厂、工厂方法、抽象工厂三者怎么区分? 基础 已完成 核心对比
01.3.2.2-002 简单工厂的结构与角色是什么?适用边界? 基础 已完成 一个类分支
01.3.2.2-003 工厂方法解决简单工厂的什么问题? 进阶 已完成 开闭原则
01.3.2.2-004 抽象工厂的产品族怎么理解?和工厂方法怎么取舍? 进阶 已完成 产品族配套
01.3.2.2-005 注册表工厂(Map / 字典分发)怎么消除 if/else? 进阶 已完成 key 分发
01.3.2.2-006 函数式工厂在 Go / TS / Python 里怎么写? 进阶 已完成 无类工厂
01.3.2.2-007 依赖注入容器为什么是工厂的终极形态? 进阶 已完成 创建+组装+生命周期
01.3.2.2-008 Spring BeanFactory 与 ApplicationContext 的工厂语义有什么区别? 高级 已完成 容器层级
01.3.2.2-009 ASP.NET Core IServiceCollection 三种注册方式怎么选? 进阶 已完成 作用域
01.3.2.2-010 Laravel 容器 bind 与 singleton 有什么区别? 进阶 已完成 绑定语义
01.3.2.2-011 Gin 没有 DI 容器怎么组装依赖? 进阶 已完成 手工注入
01.3.2.2-012 Rust 怎么用 enum 分派与 trait object 实现工厂? 高级 已完成 所有权约束
01.3.2.2-013 TypeScript 工厂函数与可辨识联合类型怎么配合? 进阶 已完成 类型安全分发
01.3.2.2-014 工厂与策略怎么区分?什么时候算过度设计? 进阶 已完成 选型判断

01.3.2.2-001 简单工厂、工厂方法、抽象工厂三者怎么区分?

一句话结论

简单工厂是「一个类内分支创建多种产品」;工厂方法是「每种产品一个工厂子类,新增产品加工厂不改旧代码」;抽象工厂是「创建一组配套的产品族,换族整体替换」。三者是同一思想的演进:分支集中 → 分支分散 → 产品族配套。

概念解释

  • 简单工厂:一个工厂类,一个创建方法,按参数返回不同产品。
  • 工厂方法:定义工厂接口,每种产品一个具体工厂,产品与工厂一一对应。
  • 抽象工厂:定义一族产品的创建接口,每个具体工厂生产一族配套产品,产品维度多于一个。
  • 演进动因:简单工厂违反开闭(加产品改工厂);工厂方法解决开闭但类数量膨胀;抽象工厂解决多产品维度的配套一致性。

原理流程

  1. 判断产品维度:只有一类产品 → 简单工厂或工厂方法。
  2. 判断扩展频率:产品种类稳定 → 简单工厂;产品频繁新增 → 工厂方法。
  3. 判断是否有产品族:多个相关产品需要配套使用 → 抽象工厂。
  4. 维度进一步增加时,考虑注册表工厂或 DI 容器替代硬编码分支。

代码或图示

简单工厂:
  Factory.create(type) → switch(type) { A, B, C }

工厂方法:
  interface Factory { Product create() }
  AFactory → AProduct
  BFactory → BProduct

抽象工厂:
  interface UIFactory { Button createButton(); Input createInput(); }
  WinFactory → WinButton + WinInput
  MacFactory → MacButton + MacInput
// 简单工厂:一个类分支
public class SenderFactory {
    public static Sender create(String type) {
        return switch (type) {
            case "sms" -> new SmsSender();
            case "mail" -> new MailSender();
            default -> throw new IllegalArgumentException(type);
        };
    }
}

// 工厂方法:每种产品一个工厂
public interface SenderFactory { Sender create(); }
public class SmsSenderFactory implements SenderFactory {
    public Sender create() { return new SmsSender(); }
}

常见误区

  • 把三者当成互斥的「必须三选一」:实际项目中常混合使用,核心是判断变化点在哪一层。
  • 认为工厂方法一定比简单工厂好:产品种类少且稳定时,简单工厂的一个类比十个工厂子类更易读。
  • 抽象工厂就是「多几个工厂方法」:它强调产品族配套,换族时所有产品一起换,不是独立方法的简单堆叠。

追问

  • 面试里怎么快速判断用哪种?答:看 if/else 的分支是否会随新需求持续增长——增长则用工厂方法或注册表;是否存在「成套替换」需求——存在则用抽象工厂。
  • 抽象工厂加新产品类型为什么困难?答:要改抽象工厂接口及所有具体工厂,违反开闭;它对「扩展产品族」开放,对「扩展产品类型」封闭。

01.3.2.2-002 简单工厂的结构与角色是什么?适用边界?

一句话结论

简单工厂由一个工厂类、一个抽象产品、多个具体产品组成;工厂按参数决定创建哪个具体产品,调用方面向抽象产品编程。它适用于产品种类少、创建逻辑集中、不频繁扩展的场景。

概念解释

  • 角色:工厂(创建者)、抽象产品(返回类型)、具体产品(被 new 的类)。
  • 优点:创建逻辑集中,调用方不关心具体类。
  • 缺点:新增产品要改工厂分支,违反开闭原则。
  • 边界:产品种类在可预见的未来不会频繁增加,或创建逻辑有公共初始化需要集中管理。

原理流程

  1. 定义抽象产品接口。
  2. 各具体产品实现该接口。
  3. 工厂类提供静态或实例方法,按参数分支创建并返回抽象产品。
  4. 调用方只依赖抽象产品类型与工厂入口。

代码或图示

public interface Sender { void send(String msg); }

public class SmsSender implements Sender {
    public void send(String msg) { /* ... */ }
}
public class MailSender implements Sender {
    public void send(String msg) { /* ... */ }
}

public class SenderFactory {
    public static Sender create(String type) {
        return switch (type) {
            case "sms" -> new SmsSender();
            case "mail" -> new MailSender();
            default -> throw new IllegalArgumentException("unknown: " + type);
        };
    }
}
// PHP:静态工厂方法是常见写法
class SenderFactory
{
    public static function create(string $type): Sender
    {
        return match ($type) {
            'sms' => new SmsSender(),
            'mail' => new MailSender(),
            default => throw new \InvalidArgumentException("unknown: {$type}"),
        };
    }
}

常见误区

  • 工厂里写业务逻辑:工厂只负责创建,业务应在产品类或调用层。
  • 返回具体类型而非抽象类型:返回 SmsSender 就失去了工厂解耦的意义。
  • 把简单工厂当工厂方法:简单工厂是一个类内分支,工厂方法是每个产品一个工厂类。

追问

  • 简单工厂和静态工厂方法有什么区别?答:静态工厂方法是某个类上的静态创建方法(如 Integer.valueOf),简单工厂是独立的工厂类;思想相近,但后者把创建逻辑从产品类中独立出来。
  • 简单工厂的 if/else 扩散到几十个分支怎么办?答:改用注册表工厂(Map 映射)或依赖注入容器,按 key 自动注册与分发。

01.3.2.2-003 工厂方法解决简单工厂的什么问题?

一句话结论

工厂方法把创建逻辑从一个集中的分支方法下沉到每个产品对应的工厂子类,新增产品只需加一个新工厂类,不需要修改既有工厂代码,从而满足开闭原则;代价是类数量随产品种类线性增长。

概念解释

  • 核心变化:把 switch(type) 拆成多态,每个产品有自己的工厂。
  • 抽象工厂接口声明 create() 方法,具体工厂决定返回哪个产品。
  • 调用方选择哪个工厂,等价于在简单工厂里选择哪个分支。
  • 适用:产品频繁扩展、插件化架构、框架预留扩展点。

原理流程

  1. 定义工厂接口,返回抽象产品类型。
  2. 每种具体产品实现一个对应工厂类,实现创建方法。
  3. 调用方通过依赖注入或配置选择具体工厂。
  4. 新增产品:加产品类 + 加工厂类,不改既有代码。

代码或图示

public interface SenderFactory {
    Sender create();
}

public class SmsSenderFactory implements SenderFactory {
    public Sender create() { return new SmsSender(); }
}

public class MailSenderFactory implements SenderFactory {
    public Sender create() { return new MailSender(); }
}

// 调用方
public class NotificationService {
    private final SenderFactory factory;
    public NotificationService(SenderFactory factory) { this.factory = factory; }
    public void notify(String msg) { factory.create().send(msg); }
}
// Go:没有继承,工厂就是接口的具体实现
type Sender interface{ Send(msg string) }

type SenderFactory interface{ Create() Sender }

type SmsSenderFactory struct{}
func (SmsSenderFactory) Create() Sender { return &SmsSender{} }

type MailSenderFactory struct{}
func (MailSenderFactory) Create() Sender { return &MailSender{} }

常见误区

  • 工厂方法必须配抽象产品:是的,工厂返回抽象类型才有多态意义,返回具体类型等于没解耦。
  • 工厂方法消灭了 if/else:分支从工厂内部移到了「选择哪个工厂」的环节,选择逻辑仍在,只是位置变了。
  • 每个产品都要写一个工厂类:产品少的时候确实类爆炸,可以用注册表工厂合并。

追问

  • 工厂方法适合框架扩展点吗?答:非常适合,框架定义工厂接口与产品接口,插件提供具体实现并注册,主程序不需要知道插件类名。
  • 类爆炸怎么控制?答:产品种类少时用简单工厂;产品成族扩展时考虑抽象工厂;用 DI 容器自动注册工厂实现可以进一步减少手写工厂类。

01.3.2.2-004 抽象工厂的产品族怎么理解?和工厂方法怎么取舍?

一句话结论

抽象工厂创建一组相互配套的产品族(如跨数据库的连接+方言+分页器、跨操作系统的按钮+输入框),保证同一族内产品风格一致;工厂方法只生产单一产品。当存在多个产品维度且必须成套替换时用抽象工厂。

概念解释

  • 产品族:一组相互配套、不能混用的对象。
  • 一致性约束:Windows 按钮不能配 Mac 输入框,MySQL 方言不能配 PostgreSQL 连接。
  • 扩展性:扩展新产品族容易(加一个具体工厂),扩展新产品类型困难(改抽象接口及所有实现)。
  • 典型场景:跨数据库方言、跨 UI 风格、跨消息队列实现、多租户 SDK 版本。

原理流程

  1. 识别产品族维度:有哪些「成套替换」的场景。
  2. 抽象工厂接口声明一族产品的创建方法。
  3. 每个具体工厂实现一族配套产品。
  4. 调用方按配置选择工厂,后续所有产品都从该工厂获取。

代码或图示

UIFactory
 ├─ WinFactory  → WinButton + WinInput + WinCheckbox
 └─ MacFactory  → MacButton + MacInput + MacCheckbox

换族:从 WinFactory 切到 MacFactory,所有 UI 控件整体替换
public interface UIFactory {
    Button createButton();
    Input createInput();
}

public class WinFactory implements UIFactory {
    public Button createButton() { return new WinButton(); }
    public Input createInput() { return new WinInput(); }
}

public class MacFactory implements UIFactory {
    public Button createButton() { return new MacButton(); }
    public Input createInput() { return new MacInput(); }
}
// Rust:trait 作为抽象工厂,具体结构体实现
trait UIFactory {
    fn create_button(&self) -> Box<dyn Button>;
    fn create_input(&self) -> Box<dyn Input>;
}

struct WinFactory;
impl UIFactory for WinFactory {
    fn create_button(&self) -> Box<dyn Button> { Box::new(WinButton) }
    fn create_input(&self) -> Box<dyn Input> { Box::new(WinInput) }
}

常见误区

  • 抽象工厂就是「多几个工厂方法」:它的核心是产品族配套与一致性,不是方法数量。
  • 抽象工厂容易加新产品类型:加产品类型要改抽象工厂接口及所有实现,成本高;它对扩展产品族开放,对扩展产品类型封闭。
  • 把所有相关对象都塞进一个抽象工厂:只有「必须成套」的才放,独立变化的产品应该单独管理。

追问

  • 数据库方言场景怎么用抽象工厂?答:抽象工厂产出连接、方言、分页器、SQL 构建器等配套对象,换数据库换一族实现,调用方只依赖抽象工厂。
  • 抽象工厂和 DI 容器怎么配合?答:容器按配置注入具体工厂实现,调用方只依赖抽象工厂;容器把「选哪个工厂」从硬编码变成配置。

01.3.2.2-005 注册表工厂(Map / 字典分发)怎么消除 if/else?

一句话结论

注册表工厂用「类型标识 → 创建函数」的 Map 替代 switch/if 分支,新增产品时只需往 Map 注册一个条目,不需要修改分发逻辑;它是简单工厂的进化版,也是 DI 容器的底层原理。

概念解释

  • 结构:一个注册中心(Map / 字典),key 是产品类型标识,value 是创建函数或工厂对象。
  • 分发:调用方传入 key,从 Map 取创建函数并执行。
  • 注册时机:启动时静态注册、注解扫描自动注册、依赖注入容器自动收集。
  • 优点:开闭原则、分发逻辑统一、便于按配置动态加载。

原理流程

  1. 定义产品接口与 key 类型(字符串、枚举等)。
  2. 初始化阶段把各产品的创建函数注册到 Map。
  3. 调用方传入 key,Map.get(key) 取出创建函数并执行。
  4. 找不到 key 时走默认策略或抛业务异常。

代码或图示

public class SenderRegistry {
    private final Map<String, Supplier<Sender>> map = new HashMap<>();

    public void register(String type, Supplier<Sender> factory) {
        map.put(type, factory);
    }

    public Sender create(String type) {
        Supplier<Sender> f = map.get(type);
        if (f == null) throw new IllegalArgumentException("unknown: " + type);
        return f.get();
    }
}

// 启动时注册
registry.register("sms", SmsSender::new);
registry.register("mail", MailSender::new);
// Go:用 map[string]func() Sender 做注册表
type SenderRegistry map[string]func() Sender

func NewRegistry() SenderRegistry {
    return SenderRegistry{
        "sms": func() Sender { return &SmsSender{} },
        "mail": func() Sender { return &MailSender{} },
    }
}

func (r SenderRegistry) Create(typ string) (Sender, error) {
    f, ok := r[typ]
    if !ok {
        return nil, fmt.Errorf("unknown: %s", typ)
    }
    return f(), nil
}
# Python:字典分发是最常见的注册表写法
class SenderRegistry:
    def __init__(self):
        self._map: dict[str, callable[[], Sender]] = {}

    def register(self, typ: str, factory: callable[[], Sender]):
        self._map[typ] = factory

    def create(self, typ: str) -> Sender:
        if typ not in self._map:
            raise ValueError(f"unknown: {typ}")
        return self._map[typ]()

常见误区

  • 注册表里存的是实例而非创建函数:存实例会导致每次返回同一对象,有状态产品会串数据;应存创建函数(工厂),每次调用按需创建。
  • 注册时机太晚:在第一次分发时才注册,会遇到竞态或漏注册;应在启动阶段完成注册。
  • 认为注册表完全消灭了分支:分支从 switch 变成了 Map 查找,但新增产品不再需要改分发代码,这才是核心收益。

追问

  • Spring 里怎么自动注册?答:实现 List<Sender> 注入时 Spring 自动收集所有 Sender 实现,再按 type() 方法建 Map,不需要手写注册。
  • 注册表和策略模式是什么关系?答:注册表解决「怎么选到策略」,策略解决「选到之后怎么执行」;两者组合是业务代码最常见的形态。

01.3.2.2-006 函数式工厂在 Go / TS / Python 里怎么写?

一句话结论

在函数式风格的语言里,工厂不需要类,一个返回接口类型的函数就是工厂;Go 的 func() Sender、TypeScript 的高阶函数、Python 的闭包工厂都属于这一类,比类工厂更轻量。

概念解释

  • 函数式工厂:返回抽象类型的函数,调用方只依赖函数签名。
  • Go:函数是一等公民,type SenderFactory func() Sender 就是工厂类型。
  • TypeScript:高阶函数返回接口或对象,配合泛型做类型安全。
  • Python:闭包捕获配置参数,返回构造好的对象。

原理流程

  1. 定义产品接口或类型。
  2. 写一个函数,内部组装依赖并返回产品实例。
  3. 调用方把函数当依赖注入,不需要知道具体实现。
  4. 需要不同配置时,用闭包或柯里化包装出多个工厂函数。

代码或图示

// Go:返回接口的函数就是工厂
type Sender interface {
    Send(msg string) error
}

func NewSmsSender(apiKey string) Sender {
    return &smsSender{apiKey: apiKey}
}

func NewMailSender(smtpHost string) Sender {
    return &mailSender{smtpHost: smtpHost}
}

// 调用方注入工厂函数
type Notifier struct {
    senderFactory func() Sender
}
// TypeScript:高阶工厂函数
interface Sender {
  send(msg: string): void;
}

type SenderFactory = () => Sender;

function createSmsSender(apiKey: string): SenderFactory {
  return () => new SmsSender(apiKey);
}

function createMailSender(host: string): SenderFactory {
  return () => new MailSender(host);
}
# Python:闭包工厂
def create_sms_sender(api_key: str) -> Sender:
    def send(msg: str) -> None:
        print(f"sms via {api_key}: {msg}")
    return send  # 函数本身就是 Sender 实现

常见误区

  • 函数式工厂只能返回简单对象:Go 里可以在函数里组装多个依赖,返回完整服务对象。
  • 闭包工厂无法持有状态:闭包可以捕获外部变量,等于工厂自带配置,比类工厂更灵活。
  • 认为 Go 没有类就不能写设计模式:Go 用接口 + 结构体组合 + 函数类型实现了大部分模式的语义,只是形式不同。

追问

  • Go 的构造函数为什么习惯命名 NewXxx?答:Go 没有构造器语法,约定 NewXxx() 作为导出的构造函数,返回接口类型时对外隐藏具体类型。
  • TypeScript 里函数式工厂和类工厂怎么选?答:无状态、逻辑简单用函数式;需要多方法、继承层次或 DI 容器注入用类。

01.3.2.2-007 依赖注入容器为什么是工厂的终极形态?

一句话结论

DI 容器把「创建对象 + 解析依赖 + 注入 + 生命周期管理 + 作用域控制」全部自动化,是通用化的工厂/注册表:手写工厂只负责创建单个产品,容器负责创建整个对象图并管理其生命周期。

概念解释

  • 手写工厂:硬编码创建逻辑,依赖手动组装。
  • DI 容器:注册抽象到实现的映射,启动时自动解析依赖图,按作用域创建与注入。
  • 生命周期:容器管理单例、请求级、瞬态等作用域,自动回收。
  • 可替换性:切换实现只改注册点,不改调用方。

原理流程

  1. 启动阶段:注册抽象到实现的映射与作用域。
  2. 请求阶段:容器从根对象开始,递归解析构造器参数,依次创建依赖。
  3. 运行阶段:按作用域复用实例,请求结束时释放请求级资源。
  4. 测试阶段:注册替身实现,替换真实依赖。

代码或图示

手写工厂:
  OrderService → new OrderService(new OrderRepo(new Db()))

DI 容器:
  builder.Services.AddSingleton<OrderRepo>();
  builder.Services.AddTransient<OrderService>();
  // 容器自动解析:OrderService 需要 OrderRepo,自动创建并注入
// ASP.NET Core:容器自动组装对象图
builder.Services.AddSingleton<IConfig, Config>();
builder.Services.AddScoped<IOrderRepository, OrderRepository>();
builder.Services.AddTransient<OrderService>();

// OrderService 构造器需要 IOrderRepository,容器自动注入
public class OrderService(IOrderRepository repo) { }

常见误区

  • 用了容器就不用理解工厂:容器内部仍是创建与装配逻辑,装配失败时需要理解容器怎么解析依赖。
  • 容器 Bean 天然线程安全:单例 Bean 必须自己保证无共享可变状态,容器只保证实例唯一。
  • 容器解决了所有设计问题:容器是工具,不是架构;错误的依赖方向和分层不会因为用了容器而变对。

追问

  • 容器怎么解决循环依赖?答:Spring 通过三级缓存提前暴露早期引用解决构造器循环;ASP.NET Core 默认不支持构造器循环依赖,需改用方法注入或属性注入。
  • 手写 DI 和用框架容器怎么取舍?答:小型项目手写构造函数注入足够;大型项目用容器获得自动装配、生命周期管理和测试替换能力。

01.3.2.2-008 Spring BeanFactory 与 ApplicationContext 的工厂语义有什么区别?

一句话结论

BeanFactory 是 Spring 最底层的工厂接口,只提供最基础的 getBean 与懒加载能力;ApplicationContext 是 BeanFactory 的超集,额外提供国际化、事件发布、AOP 自动代理、启动时预初始化单例等企业级能力,实际开发中几乎总是用 ApplicationContext。

概念解释

  • BeanFactory:顶层工厂接口,定义 getBean(),默认懒加载(首次请求才创建)。
  • ApplicationContext:继承 BeanFactory,增加 MessageSource、ApplicationEventPublisher、ResourceLoader、环境抽象等能力。
  • 预初始化:ApplicationContext 默认启动时创建所有单例 Bean,提前暴露装配错误。
  • AOP 集成:ApplicationContext 自动为匹配的 Bean 创建代理,不需要手动调用工厂。

原理流程

  1. 定义阶段:BeanFactory 只负责 Bean 定义与实例化。
  2. 启动阶段:ApplicationContext 刷新容器,完成 BeanFactory 的初始化、后处理器注册、单例预实例化。
  3. 运行阶段:getBean 时按作用域返回实例。
  4. 销毁阶段:ApplicationContext 触发 Bean 的销毁回调。

代码或图示

BeanFactory(底层)
  ├─ getBean(name)
  ├─ 懒加载(默认)
  └─ 基础实例化与依赖注入

ApplicationContext(企业级超集)
  ├─ 继承 BeanFactory 全部能力
  ├─ 国际化 MessageSource
  ├─ 事件发布 ApplicationEventPublisher
  ├─ AOP 自动代理
  ├─ 单例预初始化(启动时创建)
  └─ 环境配置与 Profile

常见误区

  • 认为 ApplicationContext 和 BeanFactory 是两套容器:ApplicationContext 内部组合了一个 BeanFactory,是增强而非替代。
  • 认为 BeanFactory 是生产推荐:它主要用于资源受限场景,日常开发一律用 ApplicationContext。
  • 认为单例预初始化是浪费:它的价值是启动时就暴露装配错误,而不是第一次请求时才崩。

追问

  • Spring 为什么要分这两层?答:解耦基础容器能力与企业级特性,让资源受限场景(如移动设备、嵌入式)可以只用 BeanFactory。
  • BeanFactory 懒加载和 ApplicationContext 预初始化怎么选?答:生产环境预初始化(启动时发现错误);极大型应用启动慢时可以对特定 Bean 加 @Lazy 延迟加载。

01.3.2.2-009 ASP.NET Core IServiceCollection 三种注册方式怎么选?

一句话结论

AddSingleton 全应用一个实例,适合无状态服务;AddScoped 每个请求一个实例,适合请求级数据(如 DbContext);AddTransient 每次解析都新建,适合轻量无状态对象。选错作用域最典型的事故是把 Scoped 服务注入 Singleton 导致跨请求串数据。

概念解释

  • Singleton:进程内唯一,第一次请求时创建,后续复用。
  • Scoped:每个请求(scope)一个,请求结束释放。
  • Transient:每次 GetService 或注入时都新建。
  • 依赖方向约束:Singleton 不能依赖 Scoped(除非手动创建 scope),否则 Scoped 服务被单例持有,变成事实上的单例。

原理流程

  1. 无状态、初始化昂贵、线程安全:用 Singleton。
  2. 持有请求级状态(如当前用户、DbContext):用 Scoped。
  3. 轻量、频繁创建、不持有状态:用 Transient。
  4. 启动时容器校验作用域:ASP.NET Core 默认检测常见的作用域校验错误(待确认:开发环境默认开启,生产环境行为以官方文档为准)。

代码或图示

// 无状态服务:单例
builder.Services.AddSingleton<IEmailSender, EmailSender>();

// 请求级数据库上下文:每请求一个
builder.Services.AddDbContext<AppDbContext>(opt => opt.UseNpgsql(cs));

// 轻量工具:瞬态
builder.Services.AddTransient<IPasswordHasher, PasswordHasher>();
Singleton → 可以依赖 Singleton
Scoped    → 可以依赖 Singleton / Scoped / Transient
Transient → 可以依赖 Singleton / Scoped / Transient
禁止:Singleton 依赖 Scoped(会导致 Scoped 服务泄漏为单例)

常见误区

  • 把 DbContext 注册成 Singleton:DbContext 不是线程安全的,多请求并发会崩。
  • 在 Singleton 服务里注入 Scoped 服务:跨请求共享状态,典型串数据事故。
  • 认为 Transient 一定轻量:如果 Transient 服务内部又依赖 Scoped 服务,每次解析都会创建一条新的对象图,注意性能。

追问

  • 怎么在 Singleton 里手动使用 Scoped 服务?答:注入 IServiceScopeFactory,用 CreateScope() 创建临时 scope,从 scope 里取 Scoped 服务,用完释放。
  • 作用域校验怎么开启?答:开发环境默认 ValidateScopes = true,生产环境可通过 WebHost.CreateDefaultBuilder 配置;具体行为版本相关,以官方文档为准。

01.3.2.2-010 Laravel 容器 bind 与 singleton 有什么区别?

一句话结论

bind 每次从容器解析时都返回新实例(等价于瞬态);singleton 第一次解析时创建并缓存,后续解析返回同一实例(等价于单例);scoped 在 Laravel 中按请求周期共享(等价于请求级单例)。

概念解释

  • bind(abstract, concrete):每次解析都重新实例化。
  • singleton(abstract, concrete):首次解析时创建并缓存,后续复用。
  • scoped(abstract, concrete):同一请求周期内复用,请求结束后释放。
  • instance(abstract, instance):直接绑定已有实例到容器。

原理流程

  1. 服务提供者 register() 阶段调用 bind/singleton 注册映射。
  2. 请求阶段:容器从路由或控制器开始解析依赖,自动调用注册时定义的工厂。
  3. 缓存策略:singleton 在首次解析时缓存到容器;scoped 在请求生命周期内缓存。
  4. 请求结束:释放 scoped 实例,触发terminating回调。

代码或图示

// Laravel 容器绑定
class AppServiceProvider extends ServiceProvider
{
    public function register(): void
    {
        // 每次解析新建
        $this->app->bind(PaymentGateway::class, StripeGateway::class);

        // 全应用单例
        $this->app->singleton(Config::class, function ($app) {
            return new Config($app['files']->get('.env'));
        });

        // 请求级单例
        $this->app->scoped(AuditContext::class, function ($app) {
            return new AuditContext(request()->user());
        });
    }
}
bind      → 每次 new,适合轻量无状态
singleton → 第一次创建后缓存,适合配置、连接池
scoped    → 同一请求内复用,适合当前用户、审计上下文
instance  → 直接绑定已有对象

常见误区

  • 把 Eloquent Model 绑定成 singleton:Model 是有状态的,单例会导致跨请求数据污染。
  • 在 singleton 里持有 request 相关数据:请求是请求级的,单例持有会跨请求串号。
  • 认为 bind 和 singleton 只是性能差异:它们语义不同,bind 每次新实例,singleton 共享状态,选错会导致正确性问题。

追问

  • Laravel 容器怎么自动解析依赖?答:通过反射读取类的构造器参数类型,递归解析并注入;接口绑定需要手动注册到容器,具体类可以自动解析。
  • 容器解析失败怎么排查?答:看报错信息中的目标类与缺失依赖,检查是否有未绑定的接口、是否有无法实例化的参数(如基本类型)、是否有循环依赖。

01.3.2.2-011 Gin 没有 DI 容器怎么组装依赖?

一句话结论

Gin 本身不提供 DI 容器,常见做法是「构造函数注入 + 结构体持有依赖 + 路由注册时手工传入」:在 main 函数里手动创建所有依赖,从最底层开始逐层组装,最后把 handler 结构体传给路由注册函数。

概念解释

  • 无容器:Gin 只负责 HTTP 路由,不管理依赖生命周期。
  • 手工组装:在 main 中创建 repository、service、handler,层层传递。
  • 接口隔离:handler 依赖 service 接口,service 依赖 repository 接口,便于测试替换。
  • 测试:单测时直接构造假实现传入 handler。

原理流程

  1. 定义各层接口与实现。
  2. main 中创建数据库连接、配置等基础依赖。
  3. 从下往上组装:repo → service → handler。
  4. 把 handler 注册到 Gin 路由,handler 结构体内部持有依赖。

代码或图示

package main

import "github.com/gin-gonic/gin"

type OrderRepository interface {
    Find(id string) (*Order, error)
}

type OrderService struct {
    repo OrderRepository
}

func NewOrderService(repo OrderRepository) *OrderService {
    return &OrderService{repo: repo}
}

type OrderHandler struct {
    svc *OrderService
}

func NewOrderHandler(svc *OrderService) *OrderHandler {
    return &OrderHandler{svc: svc}
}

func (h *OrderHandler) Get(c *gin.Context) { /* ... */ }

func main() {
    r := gin.Default()

    // 手工组装:从下往上
    repo := NewPostgresOrderRepo()
    svc := NewOrderService(repo)
    h := NewOrderHandler(svc)

    r.GET("/orders/:id", h.Get)
    r.Run(":8080")
}

常见误区

  • 在 handler 里直接 new 依赖:等于硬编码,无法测试替换。
  • 把数据库连接当全局变量到处传:应在 main 中创建后注入,不要包级变量全局散用。
  • 认为 Go 项目必须引入 DI 框架:小型项目手工组装足够,大型项目可以考虑 google/wire 这类代码生成式 DI,但不是必须。

追问

  • Go 里有没有常用的 DI 方案?答:google/wire 是编译期代码生成 DI,fx/dig 是运行时反射 DI;但很多团队选择手工组装,因为显式、可调试。
  • 怎么在 Gin 里做中间件依赖注入?答:把中间件也写成结构体方法,在 main 中组装后注册,或者用闭包捕获依赖。

01.3.2.2-012 Rust 怎么用 enum 分派与 trait object 实现工厂?

一句话结论

Rust 没有类与继承,工厂实现有两条路:用 enum 做静态分派(编译期确定类型,零开销),或用 Box<dyn Trait> 做动态分派(运行时选择,灵活但有开销)。选择取决于是否需要运行时多态。

概念解释

  • 静态分派:enum Sender { Sms(SmsSender), Mail(MailSender) },match 分派,编译器内联优化,无堆分配。
  • 动态分派:Box<dyn Sender>,运行时通过 vtable 调用,需要堆分配与 trait object。
  • 工厂函数:fn create_sender(typ: &str) -> Box<dyn Sender> 等价于经典工厂。
  • 所有权约束:工厂返回 Box<dyn Sender> 时,所有权转移给调用方。

原理流程

  1. 定义 trait 作为产品抽象。
  2. 各产品实现 trait。
  3. 工厂函数:按输入返回 Box<dyn Product> 或返回 enum 变体。
  4. 调用方通过 trait 方法使用产品,不关心具体类型。

代码或图示

// 动态分派工厂
trait Sender {
    fn send(&self, msg: &str);
}

struct SmsSender;
impl Sender for SmsSender {
    fn send(&self, msg: &str) { println!("sms: {msg}"); }
}

struct MailSender;
impl Sender for MailSender {
    fn send(&self, msg: &str) { println!("mail: {msg}"); }
}

fn create_sender(typ: &str) -> Result<Box<dyn Sender>, String> {
    match typ {
        "sms" => Ok(Box::new(SmsSender)),
        "mail" => Ok(Box::new(MailSender)),
        t => Err(format!("unknown: {t}")),
    }
}
// 静态分派:enum + match
enum SenderKind {
    Sms(SmsSender),
    Mail(MailSender),
}

impl SenderKind {
    fn send(&self, msg: &str) {
        match self {
            SenderKind::Sms(s) => s.send(msg),
            SenderKind::Mail(s) => s.send(msg),
        }
    }
}

常见误区

  • 所有场景都用 Box<dyn Trait>:静态分派(enum)零开销且更易推理,只有在真正需要运行时多态时才用 trait object。
  • 忽略生命周期:返回 &dyn Trait 时生命周期受约束,通常返回 Box<dyn Trait> 转移所有权。
  • 认为 Rust 不能写工厂模式:Rust 用 trait + 函数 + enum/Box 实现了工厂语义,只是形式不同。

追问

  • Box<dyn Trait> 有什么开销?答:每次方法调用多一次 vtable 间接跳转,且需要堆分配;高频路径要考虑静态分派。
  • Rust 里怎么实现注册表工厂?答:用 HashMap<String, fn() -> Box<dyn Sender>>,注册函数指针,运行时按 key 查找调用。

01.3.2.2-013 TypeScript 工厂函数与可辨识联合类型怎么配合?

一句话结论

TypeScript 用「可辨识联合类型 + 工厂函数」实现类型安全的分发:每个产品有一个 kind 字段做判别,工厂函数根据 kind 字面量类型返回对应类型,编译器能在 switch 中自动收窄类型。

概念解释

  • 可辨识联合:多个类型共享一个字面量字段(如 kind: 'sms' | 'mail')。
  • 类型收窄:switch (s.kind) 中每个分支编译器自动推断具体类型。
  • 工厂函数:输入判别字段,返回对应产品实例,类型签名保证类型安全。
  • 替代 if/else:分发逻辑集中在工厂,调用方享受类型自动推断。

原理流程

  1. 定义各产品接口,共享 kind 判别字段。
  2. 工厂函数:输入 kind 字面量联合类型,返回对应产品类型。
  3. 调用方使用产品时,switch (kind) 自动收窄类型。
  4. 新增产品类型:联合类型加一项,工厂函数加一个分支,TS 编译器会提示未处理的 case。

代码或图示

interface SmsSender {
  kind: "sms";
  apiKey: string;
  send(msg: string): void;
}

interface MailSender {
  kind: "mail";
  smtpHost: string;
  send(msg: string): void;
}

type Sender = SmsSender | MailSender;

function createSender(kind: "sms", apiKey: string): SmsSender;
function createSender(kind: "mail", smtpHost: string): MailSender;
function createSender(kind: Sender["kind"], config: string): Sender {
  switch (kind) {
    case "sms":
      return { kind, apiKey: config, send: (m) => console.log(`sms: ${m}`) };
    case "mail":
      return { kind, smtpHost: config, send: (m) => console.log(`mail: ${m}`) };
  }
}

// 使用时类型自动收窄
function notify(sender: Sender, msg: string) {
  if (sender.kind === "sms") {
    console.log(sender.apiKey); // 这里 sender 被推断为 SmsSender
  }
  sender.send(msg);
}

常见误区

  • 工厂返回宽泛类型 Sender 而不是联合类型:丢失了类型收窄能力,等于放弃了 TS 的优势。
  • 不用可辨识字段而用 instanceof:instanceof 在编译期不如字面量类型精确,且跨 realm 不可靠。
  • 认为 TypeScript 没有运行时类型安全:工厂函数在运行时仍有分支逻辑,类型安全是编译期的,运行时校验仍需自己做。

追问

  • 可辨识联合和 Java 的 sealed 类型有什么相似?答:都是有限集合的多态,编译器能穷尽检查所有分支;TS 用 kind 字段,Java 用 sealed class permits。
  • 工厂里怎么处理默认分支?答:用 never 类型做穷尽检查:default: const _exhaustive: never = kind;,确保新增类型时编译器报错。

01.3.2.2-014 工厂与策略怎么区分?什么时候算过度设计?

一句话结论

工厂解决「创建哪个对象」(选择实现),策略解决「执行哪种算法」(选择行为);工厂产出的对象通常是无状态的服务,策略是可替换的算法。只有一个实现、创建逻辑简单、没有替换需求时,直接 new 比工厂更清晰。

概念解释

  • 工厂:关注对象的创建与组装,调用方不关心构造细节。
  • 策略:关注算法的可替换性,同一个上下文在运行时切换算法。
  • 组合关系:工厂可以按类型创建对应策略实例,策略注册表是两者的结合。
  • 过度设计信号:只有一个实现、没有测试替身需求、没有配置化切换需求、创建只发生一次。

原理流程

  1. 判断变化点是「创建哪个实现」还是「执行哪种行为」。
  2. 变化点在创建 → 工厂;变化点在行为 → 策略。
  3. 两者常组合:工厂/注册表按类型选策略,策略负责执行。
  4. 评估成本:间接层带来的类数量与理解成本,是否大于未来扩展的收益。

代码或图示

工厂:
  SenderFactory.create(type) → 返回 Sender 实现
  关注:怎么造出来、依赖怎么组装

策略:
  DiscountStrategy.apply(amount) → 返回折后金额
  关注:同一场景下可替换的算法

组合:
  DiscountRegistry.get(type) → 返回 DiscountStrategy
  → 工厂选策略,策略执行算法
// 工厂 vs 策略对比
// 工厂:创建对象
Sender sender = senderFactory.create("sms");

// 策略:选择算法
DiscountStrategy strategy = registry.get(couponType);
BigDecimal final = strategy.apply(amount);

常见误区

  • 把所有 new 都包一层工厂:只有一个实现时,直接构造更易读,工厂增加了跳转。
  • 策略里塞多个不相关方法:违反接口隔离,策略应只承担一类算法。
  • 认为用了工厂就一定是好设计:工厂是手段,不是目的;没有真实变化点时它就是过度设计。

追问

  • 什么时候应该从直接构造重构为工厂?答:出现第二套实现、构造逻辑重复扩散、需要测试替身、需要按配置切换实现时。
  • 怎么判断工厂是不是过度设计?答:问自己「明天要加一个新实现,我需要改几个地方?」——如果改一个地方(加注册项),工厂值;如果还要改分发逻辑,工厂没起到作用。

跨语言差异对照

语言 惯用实现 差异要点
Java 简单工厂 / 工厂方法 / 抽象工厂 + DI 容器 反射能力强,动态代理与容器自动装配成熟;类工厂是主流
Go 返回接口的构造函数 + map 注册表 + 手工组装 没有类继承,工厂就是函数;NewXxx() 命名约定;wire 编译期 DI
Python 函数工厂 + 字典分发 + 闭包 动态类型,工厂就是函数;模块级实例天然单例;注册装饰器自动注册
PHP 静态工厂方法 + Laravel 容器 bind/singleton FPM 请求级生命周期,bind 每次新实例;容器反射自动解析依赖
C#/.NET DI 容器 IServiceCollection 注册 + 工厂委托 三种作用域(Singleton/Scoped/Transient)是核心概念;ActivatorUtilities 动态实例化
TypeScript 可辨识联合 + 工厂函数重载 + 模块导出 编译期类型收窄是核心优势;模块系统天然提供单例工厂
Rust trait + 工厂函数 + Box&lt;dyn Trait&gt; 或 enum 分派 静态分派(enum)零开销,动态分派(Box)有 vtable 开销;所有权约束工厂返回值

跨语言差异

  • Go 没有类与继承,工厂退化为「返回接口的函数」,比 Java 轻量得多;DI 也没有 Spring 那样的运行时容器,更多靠手工组装或编译期生成。
  • Rust 的工厂必须面对「静态分派 vs 动态分派」的选择:enum + match 零开销但类型固定,Box<dyn Trait> 灵活但有堆分配与 vtable 开销。
  • TypeScript 的工厂优势在编译期类型安全:可辨识联合让 switch 自动收窄类型,这是其他语言没有的。
  • C# 和 ASP.NET Core 把「作用域」作为一等概念,三种注册方式不只是性能差异,而是正确性边界;Singleton 依赖 Scoped 是典型事故。
  • PHP 的工厂受 FPM 生命周期约束:bind 每次新实例,单例在请求结束即销毁,跨请求共享要靠容器外机制。
  • Python 的字典分发是最自然的注册表写法,不需要类工厂,一个 dict[str, callable] 就够了。
  • Java 是唯一完整保留 GoF 三种工厂形态的语言,也是面试中工厂模式题的主要语言基线。

待整理清单

  • [ ] 补充 Kotlin object/companion 工厂与 sealed class 穷尽分派
  • [ ] 补充 Spring @ConditionalOnProperty 条件工厂与自动装配原理
  • [ ] 补充 Rust once_cell + 注册表的运行时动态注册方案
  • [ ] 补充 Gin + wire 编译期 DI 的完整示例