在`Python`中实现`依赖注入`（`DI`）：使用`Inject`或`Dependency-Injector`库。

Python 依赖注入：使用 Inject 和 Dependency-Injector

大家好，今天我们来深入探讨 Python 中的依赖注入（DI），并着重介绍两个流行的 DI 库：Inject 和 Dependency-Injector。依赖注入是一种设计模式，旨在降低软件组件之间的耦合度，提高代码的可测试性、可维护性和可重用性。

什么是依赖注入？

在传统编程中，一个对象通常负责创建和管理它所依赖的其他对象。这会导致紧耦合，使得修改或替换依赖项变得困难。依赖注入通过以下方式解决这个问题：

• 解耦： 对象不再负责创建其依赖项。
• 外部提供： 依赖项从外部提供给对象，通常是通过构造函数、setter 方法或接口。
• 控制反转（IoC）： 对象将控制权交给外部容器或框架，由其负责依赖项的创建和注入。

简而言之，依赖注入是一种将依赖关系从对象内部转移到外部的过程。

依赖注入的优势

• 可测试性： 容易使用 Mock 对象或 Stub 对象替换真实的依赖项，进行单元测试。
• 可维护性： 修改或替换依赖项不会影响使用该依赖项的对象。
• 可重用性： 对象可以更容易地在不同的上下文中重用，因为它的依赖项是可配置的。
• 松耦合： 降低组件之间的依赖性，使代码更易于理解和修改。
• 代码组织： 更加清晰地定义了组件之间的关系，提高代码的可读性。

依赖注入的类型

主要有三种依赖注入方式：

• 构造器注入： 依赖项通过构造函数传递给对象。
• Setter 注入： 依赖项通过 Setter 方法设置到对象中。
• 接口注入： 对象实现一个接口，该接口定义了设置依赖项的方法。

使用 Inject 库进行依赖注入

Inject 是一个轻量级的 Python 依赖注入库，它使用装饰器和绑定来配置依赖关系。

1. 安装 Inject:

pip install inject

2. 基本用法:

import inject

class DatabaseConnection:
    def connect(self):
        return "Connected to database"

class UserService:
    def __init__(self, db_connection: DatabaseConnection):
        self.db_connection = db_connection

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

# 配置依赖关系
def config(binder):
    binder.bind(DatabaseConnection, DatabaseConnection())  # 将 DatabaseConnection 绑定到 DatabaseConnection 实例

# 使用 Inject
inject.configure(config)

# 获取 UserService 实例
user_service = inject.instance(UserService)

# 调用 UserService 的方法
user = user_service.get_user(123)
print(user)  # 输出: User with ID 123 from database. Connected to database

在这个例子中：

• DatabaseConnection 是一个依赖项。
• UserService 依赖于 DatabaseConnection。
• config 函数使用 binder.bind 定义了 DatabaseConnection 的绑定关系。
• inject.configure(config) 配置了依赖注入容器。
• inject.instance(UserService) 创建了 UserService 的实例，并自动注入了 DatabaseConnection 依赖项。

3. 构造器注入:

Inject 默认使用构造器注入。在 UserService 的 __init__ 方法中，我们使用类型提示 db_connection: DatabaseConnection 来声明依赖关系。Inject 会自动查找 DatabaseConnection 的绑定，并将其注入到 UserService 实例中。

4. Provider Functions:

可以使用 Provider 函数来创建更复杂的依赖项。Provider 函数是一个返回依赖项实例的函数。

import inject

class DatabaseConnection:
    def connect(self):
        return "Connected to database"

class UserService:
    def __init__(self, db_connection): # No type hint here. Inject will use the provider
        self.db_connection = db_connection

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

def provide_database_connection():
    # 可以执行复杂的逻辑来创建 DatabaseConnection 实例
    return DatabaseConnection()

def config(binder):
    binder.bind(DatabaseConnection, provide_database_connection)

inject.configure(config)

user_service = inject.instance(UserService)
user = user_service.get_user(123)
print(user)

在这个例子中，provide_database_connection 函数是一个 Provider 函数，它负责创建 DatabaseConnection 实例。binder.bind(DatabaseConnection, provide_database_connection) 将 DatabaseConnection 绑定到这个 Provider 函数。

5. Named Bindings:

可以使用命名绑定来区分相同类型的不同依赖项。

import inject

class ProductionDatabaseConnection:
    def connect(self):
        return "Connected to production database"

class TestDatabaseConnection:
    def connect(self):
        return "Connected to test database"

class UserService:
    def __init__(self, production_db: ProductionDatabaseConnection):
        self.db_connection = production_db

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

def config(binder):
    binder.bind(ProductionDatabaseConnection, ProductionDatabaseConnection())

inject.configure(config)

user_service = inject.instance(UserService)
user = user_service.get_user(123)
print(user)  # 输出: User with ID 123 from database. Connected to production database

6. 使用 @inject.params 装饰器:

@inject.params 装饰器可以用于更灵活地注入依赖项。

import inject

class DatabaseConnection:
    def connect(self):
        return "Connected to database"

class UserService:
    @inject.params(db_connection=DatabaseConnection)
    def __init__(self, db_connection):
        self.db_connection = db_connection

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

def config(binder):
    binder.bind(DatabaseConnection, DatabaseConnection())

inject.configure(config)

user_service = UserService() # No need to use inject.instance here.
inject.inject_into(user_service) # Manual injection

user = user_service.get_user(123)
print(user)

在这个例子中，@inject.params(db_connection=DatabaseConnection) 装饰器告诉 Inject 将 DatabaseConnection 注入到 UserService 的 __init__ 方法中。注意这里需要手动实例化 UserService，然后使用 inject.inject_into(user_service) 将依赖注入。

使用 Dependency-Injector 库进行依赖注入

Dependency-Injector 是一个功能更强大的 Python 依赖注入库，它提供了容器、Provider 和配置等高级特性。

1. 安装 Dependency-Injector:

pip install dependency-injector

2. 基本用法:

from dependency_injector import containers, providers

class DatabaseConnection:
    def connect(self):
        return "Connected to database"

class UserService:
    def __init__(self, db_connection):
        self.db_connection = db_connection

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

# 定义容器
class Container(containers.DeclarativeContainer):
    db_connection = providers.Singleton(DatabaseConnection)  # 使用 Singleton Provider
    user_service = providers.Factory(UserService, db_connection=db_connection) # 使用 Factory Provider

# 使用容器
container = Container()
user_service = container.user_service()  # 获取 UserService 实例
user = user_service.get_user(123)
print(user)

在这个例子中：

• DatabaseConnection 是一个依赖项。
• UserService 依赖于 DatabaseConnection。
• Container 是一个依赖注入容器，它定义了依赖关系。
• providers.Singleton(DatabaseConnection) 创建了一个 DatabaseConnection 的单例 Provider。这意味着每次请求 db_connection 时，都会返回同一个实例。
• providers.Factory(UserService, db_connection=db_connection) 创建了一个 UserService 的工厂 Provider。这意味着每次请求 user_service 时，都会创建一个新的 UserService 实例，并注入 db_connection 依赖项。

3. Provider Types:

Dependency-Injector 提供了多种 Provider 类型，包括：

Provider 类型	描述
Singleton	创建一个单例实例，每次请求都返回同一个实例。
Factory	创建一个新的实例，每次请求都返回一个新的实例。
Callable	调用一个函数或方法，每次请求都返回调用的结果。
Provider	一个抽象基类，用于创建自定义 Provider。
Configuration	用于存储配置值。
Resource	用于管理资源，例如数据库连接或文件句柄。
Dependency	用于声明依赖关系，可以用于覆盖容器中的绑定。
Object	直接提供一个对象实例。
StaticMethod	提供一个静态方法。
Class	提供一个类对象，可以用于实例化。

4. 使用 Configuration Provider:

Configuration Provider 用于存储配置值，可以从环境变量、配置文件或命令行参数中加载配置。

from dependency_injector import containers, providers

class DatabaseConfig:
    def __init__(self, host, port):
        self.host = host
        self.port = port

class DatabaseConnection:
    def __init__(self, config):
        self.config = config

    def connect(self):
        return f"Connected to database at {self.config.host}:{self.config.port}"

class UserService:
    def __init__(self, db_connection):
        self.db_connection = db_connection

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

class Container(containers.DeclarativeContainer):
    config = providers.Configuration()
    db_config = providers.Factory(DatabaseConfig, host=config.db.host, port=config.db.port)
    db_connection = providers.Factory(DatabaseConnection, config=db_config)
    user_service = providers.Factory(UserService, db_connection=db_connection)

container = Container()
container.config.db.host.from_value("localhost")
container.config.db.port.from_value(5432)

user_service = container.user_service()
user = user_service.get_user(123)
print(user)

在这个例子中：

• config 是一个 Configuration Provider。
• config.db.host 和 config.db.port 用于存储数据库的主机和端口。
• container.config.db.host.from_value("localhost") 和 container.config.db.port.from_value(5432) 设置了配置值。

5. 使用 Resource Provider:

Resource Provider 用于管理资源，例如数据库连接或文件句柄。它可以确保资源在使用后被正确释放。

from dependency_injector import containers, providers
import sqlite3

class Database:
    def __init__(self, db_path):
        self.db_path = db_path
        self.connection = None

    def connect(self):
        self.connection = sqlite3.connect(self.db_path)
        return self.connection

    def disconnect(self):
        if self.connection:
            self.connection.close()

class UserService:
    def __init__(self, db):
        self.db = db

    def get_user(self, user_id):
        connection = self.db.connect()
        cursor = connection.cursor()
        cursor.execute("SELECT * FROM users WHERE id = ?", (user_id,))
        user = cursor.fetchone()
        self.db.disconnect()
        return user

class Container(containers.DeclarativeContainer):
    db_path = providers.Configuration()
    db = providers.Resource(Database, db_path=db_path)
    user_service = providers.Factory(UserService, db=db)

container = Container()
container.db_path.from_value("users.db")

user_service = container.user_service()
user = user_service.get_user(1)
print(user)

在这个例子中，db 是一个 Resource Provider，它负责创建和管理数据库连接。当容器被销毁时，Resource Provider 会自动释放数据库连接。

6. 使用 Dependency Provider:

Dependency Provider 可以用于覆盖容器中的绑定。这在测试或配置不同的环境时非常有用。

from dependency_injector import containers, providers

class DatabaseConnection:
    def connect(self):
        return "Connected to default database"

class TestDatabaseConnection:
    def connect(self):
        return "Connected to test database"

class UserService:
    def __init__(self, db_connection):
        self.db_connection = db_connection

    def get_user(self, user_id):
        connection_status = self.db_connection.connect()
        return f"User with ID {user_id} from database. {connection_status}"

class Container(containers.DeclarativeContainer):
    db_connection = providers.Singleton(DatabaseConnection)
    user_service = providers.Factory(UserService, db_connection=db_connection)

class TestingContainer(Container):
    db_connection = providers.Singleton(TestDatabaseConnection) # Override the default db_connection

container = Container()
user_service = container.user_service()
print(user_service.db_connection.connect()) # Prints "Connected to default database"

testing_container = TestingContainer()
test_user_service = testing_container.user_service()
print(test_user_service.db_connection.connect()) # Prints "Connected to test database"

在这个例子中，TestingContainer 继承自 Container，并使用 Dependency Provider 覆盖了 db_connection 的绑定。这使得在测试环境中使用 TestDatabaseConnection 成为可能。

Inject vs. Dependency-Injector：选择哪个？

Inject 和 Dependency-Injector 都是优秀的 Python 依赖注入库，但它们在功能和复杂性方面有所不同。

特性	Inject	Dependency-Injector
复杂性	简单，轻量级	功能强大，更复杂
学习曲线	较短	较长
Provider 类型	有限	丰富，支持自定义 Provider
配置	基于函数和装饰器	基于容器和 Provider
适用场景	小型项目，简单的依赖关系	中大型项目，复杂的依赖关系，需要高级特性
对AOP的支持	较弱	可以结合AOP模块使用
社区活跃度	相对Dependency-Injector较弱	较高

选择建议：

• 如果你的项目很小，只需要简单的依赖注入，并且希望快速上手，可以选择 Inject。
• 如果你的项目较大，需要更强大的功能，例如配置管理、资源管理、依赖覆盖等，并且愿意投入更多时间学习，可以选择 Dependency-Injector。
• 如果你需要用到AOP，可以选择Dependency-Injector并结合AOP模块使用。

实践中的一些技巧

• 尽早引入 DI： 在项目初期就开始考虑使用 DI，可以避免后期重构的麻烦。
• 避免过度使用 DI： DI 并不是万能的，过度使用可能会导致代码变得过于复杂。只在必要的地方使用 DI。
• 保持容器的简洁： 尽量将容器的配置保持简洁，避免在容器中编写复杂的逻辑。
• 使用单元测试验证 DI： 编写单元测试来验证 DI 的配置是否正确，确保依赖项被正确注入。
• 遵循单一职责原则： 让每个类只负责一个职责，这样可以更容易地管理依赖关系。
• 拥抱接口和抽象类： 使用接口和抽象类可以更容易地替换依赖项，提高代码的可测试性。

依赖注入的意义

依赖注入不仅仅是一种技术手段，更是一种编程思想。它鼓励我们编写松耦合、可测试、可维护的代码，从而提高软件的质量和可维护性。掌握依赖注入可以帮助我们更好地组织代码、提高开发效率，并构建更健壮的应用程序。

最后，一点思考

今天我们学习了如何在 Python 中使用 Inject 和 Dependency-Injector 实现依赖注入。希望大家能够理解依赖注入的原理和优势，并将其应用到实际项目中，编写更高质量的代码。选择哪个库取决于你的项目规模和需求，但理解核心概念是至关重要的。