Python 依赖注入

### 什么是依赖注入？
依赖注入是一种设计模式，它的核心思想是：
> 类不应该自己创建依赖的对象，而是应该从外部接收依赖。

### 示例
没有使用依赖注入的例子：
```
class Service:
    def __init__(self):
        # 类自己创建依赖，这不是依赖注入
        self.db = Database(url="postgresql://localhost:5432")
        self.cache = Cache(address="redis://localhost:6379")
```
使用依赖注入的例子：
1. 基础的依赖注入：

```
from dataclasses import dataclass

@dataclass
class Database:
    url: str

@dataclass
class Cache:
    address: str

class Service:
    def __init__(self, db: Database, cache: Cache):
        # 依赖从外部注入
        self.db = db
        self.cache = cache

# 使用
db = Database(url="postgresql://localhost:5432")
cache = Cache(address="redis://localhost:6379")
service = Service(db=db, cache=cache)
```
2. 使用依赖注入容器：

```
from dependency_injector import containers, providers

class Container(containers.DeclarativeContainer):
    # 配置数据库连接
    database = providers.Singleton(
        Database,
        url="postgresql://localhost:5432"
    )
    
    # 配置缓存连接
    cache = providers.Singleton(
        Cache,
        address="redis://localhost:6379"
    )
    
    # 配置服务
    service = providers.Singleton(
        Service,
        db=database,
        cache=cache
    )

# 使用
container = Container()
service = container.service()
```

### 依赖注入的优势
1. 解耦

```
# 不好的做法：强耦合
class Service:
    def __init__(self):
        self.db = Database("postgresql://localhost:5432")

# 好的做法：松耦合
class Service:
    def __init__(self, db: Database):
        self.db = db
```

2. 单一职责

```
class Service:
	# 专注于业务逻辑，而不是如何创建和管理依赖

def __init__(self, db: Database, cache: Cache):
        self.db = db
        self.cache = cache

def get_user(self, user_id: int):
        cached_user = self.cache.get(f"user:{user_id}")
        if cached_user:
            return cached_user
        return self.db.get_user(user_id)
```

### 常见的依赖注入框架
- `dependency-injector`
- `injector`
- `fastapi (内置依赖注入系统)`

### 使用 FastAPI 的依赖注入示例
```
from fastapi import Depends, FastAPI

app = FastAPI()

def get_db():
    db = Database("postgresql://localhost:5432")
    try:
        yield db
    finally:
        db.close()

@app.get("/users/{user_id}")
def read_user(user_id: int, db: Database = Depends(get_db)):
    return db.get_user(user_id)
```

### 总结
依赖注入是一种强大的设计模式，它可以帮助我们编写更清晰、更易测试和更易维护的代码。