依赖注入：从构造函数到服务容器的演进

依赖注入（Dependency Injection, DI）是一种实现控制反转的设计模式，通过外部实体提供依赖对象，降低组件间的耦合度。其演进过程体现了软件架构从简单到复杂的优化路径。

1. 构造函数注入：基础实现

最早期的依赖注入形式，通过类的构造函数显式传入依赖对象：

class UserService:
    def __init__(self, user_repository):
        self.user_repository = user_repository  # 依赖注入
        
# 使用
repo = DatabaseUserRepository()
service = UserService(repo)  # 通过构造函数注入

特点：

• 强类型依赖声明
• 对象创建时即完成依赖绑定
• 实现简单但依赖链复杂时构造函数会臃肿

2. 属性注入：动态扩展

通过公开属性实现依赖的延迟绑定：

class OrderService:
    @property
    def payment_gateway(self):
        return self._gateway
    
    @payment_gateway.setter
    def payment_gateway(self, gateway):
        self._gateway = gateway  # 属性注入

# 使用
service = OrderService()
service.payment_gateway = PayPalGateway()  # 运行时注入

优势：

• 解耦对象创建与依赖绑定
• 支持运行时替换依赖
• 但缺乏强制依赖保证

3. 接口注入：契约化设计

定义依赖接口规范，实现类必须满足接口约束：

class ILogger:
    def log(self, message): pass

class FileLogger(ILogger):
    def log(self, message): ...  # 实现接口

class App:
    def __init__(self, logger: ILogger):  # 接口约束
        self.logger = logger

价值：

• 明确依赖契约
• 支持多态实现
• 增强测试可行性（Mock接口）

4. 服务容器：集中化管理

通过容器统一管理依赖生命周期和解析：

class Container:
    def __init__(self):
        self.services = {}
    
    def register(self, name, creator):
        self.services[name] = creator  # 注册服务
        
    def resolve(self, name):
        return self.services[name]()  # 解析依赖

# 配置容器
container = Container()
container.register("logger", lambda: FileLogger())
container.register("app", lambda: App(container.resolve("logger")))

# 使用
app = container.resolve("app")  # 自动解析依赖链

核心演进：

1. 依赖图谱：容器维护对象依赖关系图
2. 生命周期控制：支持单例/瞬态等模式
3. 自动装配：递归解析嵌套依赖
4. 配置与实现分离：通过配置文件定义依赖关系

5. 现代DI框架特性

• 注解驱动：通过装饰器声明依赖

  @inject(logger=ILogger)
  class App: ...
  

• 作用域管理：请求级/线程级作用域
• 延迟加载：按需初始化依赖
• 依赖循环检测：自动识别循环引用

演进本质

$$ \text{紧耦合} \xrightarrow{\text{显式依赖}} \text{构造函数/属性注入} \xrightarrow{\text{抽象解耦}} \text{接口注入} \xrightarrow{\text{集中控制}} \text{服务容器} $$ 该过程实现了：

1. 组件关系从硬编码到可配置的转变
2. 对象创建权从组件内部转移到外部协调器
3. 系统可测试性的指数级提升
4. 架构扩展成本的显著降低