如何在 Python 中实现依赖注入（DI）模式？

举报
汪子熙 发表于 2025/02/09 10:21:38 2025/02/09
【摘要】 依赖注入（Dependency Injection, DI）是一种非常有用的设计模式，尤其在复杂的软件系统中，它能有效提高代码的可维护性和可测试性。Python 作为一门动态语言，因其灵活性，可以较为优雅地实现依赖注入。 什么是依赖注入？依赖注入的核心思想是将一个对象的依赖从外部传入，而不是让对象自己创建或获取它所需要的依赖。这样做的好处是：我们可以轻松更换依赖（例如替换为 mock 进行测...

依赖注入（Dependency Injection, DI）是一种非常有用的设计模式，尤其在复杂的软件系统中，它能有效提高代码的可维护性和可测试性。Python 作为一门动态语言，因其灵活性，可以较为优雅地实现依赖注入。

什么是依赖注入？

依赖注入的核心思想是将一个对象的依赖从外部传入，而不是让对象自己创建或获取它所需要的依赖。这样做的好处是：我们可以轻松更换依赖（例如替换为 mock 进行测试），使代码更具扩展性和可维护性。此外，它能更好地遵循“开闭原则”（Open-Closed Principle）和“单一职责原则”（Single Responsibility Principle），从而提高系统的灵活性。

想象一个现实的例子——假设你在搭建一个房屋的照明系统，其中有灯泡、开关和电源。如果灯泡自己去决定用哪种电源，那么就限制了它的用途。而如果我们将电源从外部注入灯泡，则使得灯泡可以灵活地与不同的电源配合，这就是依赖注入的核心概念。

Python 中实现依赖注入

在 Python 中，可以通过多种方式来实现依赖注入。常见的方法有构造函数注入、属性注入和方法注入。在这一部分中，我将通过实际代码来展示这些方式，并逐步拆解每种方式的实现。

构造函数注入

构造函数注入是最常见的一种依赖注入方式。在这种方法中，我们通过对象的构造函数来注入它所依赖的实例。这样一来，在创建对象时就可以将所有需要的依赖传入，从而使对象在整个生命周期中依赖关系固定。

我们以一个“订单管理系统”来举例说明。在这个系统中，我们有一个类 OrderProcessor，它依赖一个支付服务 PaymentService 和一个物流服务 ShippingService。为了方便测试和扩展，我们通过构造函数来注入这些依赖。

示例代码

class PaymentService:
    def process_payment(self, amount):
        print(f'Processing payment of ${amount} through PaymentService.')

class ShippingService:
    def ship_order(self, order_id):
        print(f'Shipping order {order_id} through ShippingService.')

class OrderProcessor:
    def __init__(self, payment_service, shipping_service):
        # 使用构造函数注入依赖项
        self.payment_service = payment_service
        self.shipping_service = shipping_service

    def process_order(self, order_id, amount):
        self.payment_service.process_payment(amount)
        self.shipping_service.ship_order(order_id)

# 实例化依赖项
payment_service = PaymentService()
shipping_service = ShippingService()

# 通过构造函数注入依赖项
order_processor = OrderProcessor(payment_service, shipping_service)

# 调用方法来处理订单
order_processor.process_order(order_id=1234, amount=100.0)

在上面的代码中，OrderProcessor 依赖于 PaymentService 和 ShippingService。通过将这些依赖注入 OrderProcessor 的构造函数，我们可以轻松替换依赖，尤其在单元测试时可以注入 mock 对象。

属性注入

属性注入是一种在对象创建后，将依赖关系直接赋值给对象属性的方式。这种方法更加灵活，可以动态地改变对象的依赖，适用于某些需要在运行时调整依赖的场景。

假设我们在处理订单时有动态选择支付服务的需求，例如客户可能会在下单后更改支付方式。在这种情况下，属性注入就显得非常合适。

示例代码

class OrderProcessor:
    def __init__(self):
        # 初始化时不提供支付服务和物流服务
        self.payment_service = None
        self.shipping_service = None

    def process_order(self, order_id, amount):
        if self.payment_service is None or self.shipping_service is None:
            raise Exception('Dependencies not injected.')
        
        self.payment_service.process_payment(amount)
        self.shipping_service.ship_order(order_id)

# 实例化订单处理器
order_processor = OrderProcessor()

# 实例化依赖项
payment_service = PaymentService()
shipping_service = ShippingService()

# 通过属性注入依赖项
order_processor.payment_service = payment_service
order_processor.shipping_service = shipping_service

# 调用方法来处理订单
order_processor.process_order(order_id=5678, amount=200.0)

在这个例子中，OrderProcessor 没有在初始化时接收任何依赖，而是通过属性注入的方式，将 PaymentService 和 ShippingService 分别赋值给 order_processor。这样做使得依赖的注入过程更加灵活，特别适用于需要在运行过程中调整依赖的场景。

方法注入

方法注入是一种将依赖作为方法参数传入的方式。这样做的好处是，我们可以在不同方法调用中使用不同的依赖，从而使得代码更为灵活。

我们来扩展之前的例子，让 OrderProcessor 的 process_order 方法直接接收支付服务和物流服务作为参数。这种方法适合于某些情况下，每次调用方法时都需要不同的依赖。

示例代码

class OrderProcessor:
    def process_order(self, order_id, amount, payment_service, shipping_service):
        payment_service.process_payment(amount)
        shipping_service.ship_order(order_id)

# 实例化依赖项
payment_service_1 = PaymentService()
shipping_service_1 = ShippingService()

# 实例化订单处理器
order_processor = OrderProcessor()

# 调用方法并传入依赖项
order_processor.process_order(order_id=9012, amount=300.0, 
                              payment_service=payment_service_1, 
                              shipping_service=shipping_service_1)

在这种方法注入的方式中，OrderProcessor 不需要在对象创建时保存支付服务或物流服务的引用，而是每次调用 process_order 方法时传入需要的依赖。这使得方法级别的灵活性更高，可以根据不同的订单来选择不同的支付服务和物流服务。

Python 中的依赖注入框架

在实际的生产环境中，为了更好地管理复杂系统中的依赖，我们通常会使用 DI 框架。Python 社区中有多个 DI 框架，比如 injector、dependency-injector 等。

下面我们将使用 injector 库来演示如何实现依赖注入。这个库提供了一种轻量级的方式来管理依赖注入，从而使得我们可以集中化地管理整个系统的依赖关系。

安装依赖注入框架

首先，使用 pip 安装 injector：

pip install injector

使用 injector 库实现依赖注入

injector 库的核心概念是模块（Module）和注入器（Injector），它们负责定义依赖关系并将依赖注入到目标类中。我们可以通过装饰器来实现依赖注入。

以下是一个使用 injector 库的完整示例：

from injector import Module, Injector, singleton, inject

# 定义支付服务
class PaymentService:
    def process_payment(self, amount):
        print(f'Processing payment of ${amount} through PaymentService.')

# 定义物流服务
class ShippingService:
    def ship_order(self, order_id):
        print(f'Shipping order {order_id} through ShippingService.')

# 定义依赖注入模块
class AppModule(Module):
    def configure(self, binder):
        # 将 PaymentService 和 ShippingService 注册为单例
        binder.bind(PaymentService, to=PaymentService, scope=singleton)
        binder.bind(ShippingService, to=ShippingService, scope=singleton)

# 使用 @inject 装饰器来注入依赖项
class OrderProcessor:
    @inject
    def __init__(self, payment_service: PaymentService, shipping_service: ShippingService):
        self.payment_service = payment_service
        self.shipping_service = shipping_service

    def process_order(self, order_id, amount):
        self.payment_service.process_payment(amount)
        self.shipping_service.ship_order(order_id)

# 创建注入器并实例化订单处理器
injector = Injector([AppModule])
order_processor = injector.get(OrderProcessor)

# 调用方法来处理订单
order_processor.process_order(order_id=3456, amount=150.0)

在这个例子中，我们使用 injector 库来管理依赖。首先，我们定义了一个 AppModule，它将 PaymentService 和 ShippingService 注册为单例。然后，在 OrderProcessor 类中，我们使用 @inject 装饰器注入依赖，从而使得 OrderProcessor 可以自动获取所需的服务。

使用 dependency-injector 库实现依赖注入

dependency-injector 是另一个流行的 Python DI 框架，它提供了更加全面的特性，包括工厂、配置管理等。下面我们使用这个库来实现类似的依赖注入功能。

安装 dependency-injector 库

pip install dependency-injector

示例代码

from dependency_injector import containers, providers

# 定义支付服务
class PaymentService:
    def process_payment(self, amount):
        print(f'Processing payment of ${amount} through PaymentService.')

# 定义物流服务
class ShippingService:
    def ship_order(self, order_id):
        print(f'Shipping order {order_id} through ShippingService.')

# 定义依赖容器
class Container(containers.DeclarativeContainer):
    payment_service = providers.Singleton(PaymentService)
    shipping_service = providers.Singleton(ShippingService)
    order_processor = providers.Factory(
        lambda payment_service, shipping_service: OrderProcessor(payment_service, shipping_service),
        payment_service=payment_service,
        shipping_service=shipping_service,
    )

# 定义订单处理器
class OrderProcessor:
    def __init__(self, payment_service, shipping_service):
        self.payment_service = payment_service
        self.shipping_service = shipping_service

    def process_order(self, order_id, amount):
        self.payment_service.process_payment(amount)
        self.shipping_service.ship_order(order_id)

# 创建依赖容器
container = Container()

# 获取订单处理器实例
order_processor = container.order_processor()

# 调用方法来处理订单
order_processor.process_order(order_id=7890, amount=250.0)

在这个例子中，我们使用了 dependency-injector 的容器类来定义依赖关系。通过声明式的方式，我们可以很清晰地看到每个类的依赖项是什么，以及如何管理这些依赖项。

依赖注入的优势和劣势

依赖注入有很多优势，但也有一些潜在的劣势。在应用 DI 时，需要平衡这两方面的因素，以便做出最佳的设计决策。

优势

  1. 提高代码的可测试性：由于依赖是从外部注入的，因此我们可以在测试中轻松使用 mock 对象来替代真实的依赖，进行单元测试。例如，在上面的例子中，我们可以用 MockPaymentService 替换掉 PaymentService，这样就可以隔离依赖项进行测试。

  2. 增强代码的复用性：将对象与它的依赖解耦意味着可以更方便地重用这些对象，因为它们不再依赖于具体的类实现，而是通过接口或抽象类来交互。

  3. 遵循 SOLID 原则：依赖注入特别符合“开闭原则”和“单一职责原则”。每个类只需要关注自己的行为，而不用考虑如何获取它所依赖的其他对象。

劣势

  1. 增加了代码的复杂度：在简单的小项目中，使用 DI 可能会导致代码变得不必要的复杂，特别是在没有 DI 框架的情况下，手动管理依赖可能会显得笨拙。

  2. 调试困难：由于依赖是动态注入的，在追踪代码调用链时，可能会让人迷失，尤其是在依赖关系复杂的时候。

  3. 学习成本：对于不熟悉 DI 概念的开发者，理解和应用这种模式需要一定的学习成本，特别是当使用诸如 injector 或 dependency-injector 这样的框架时。

如何选择依赖注入方式

在选择合适的依赖注入方式时，可以考虑以下几个因素：

  1. 依赖的生命周期：如果依赖项是单例，那么可以使用构造函数注入或使用 DI 框架中的单例作用域。如果依赖的生命周期与调用方法的生命周期一致，则可以选择方法注入。

  2. 依赖的复杂度：对于复杂的依赖树或需要集中管理依赖的场景，可以选择 DI 框架来简化依赖管理的逻辑。

  3. 代码的灵活性：如果代码需要频繁地替换依赖，或者依赖的变化是动态的，则属性注入可能更适合。

太长不看版

在 Python 中，实现依赖注入的方式主要有三种：构造函数注入、属性注入和方法注入。构造函数注入适用于固定依赖的对象；属性注入更灵活，可以在运行时动态改变依赖；方法注入则使得依赖的传递更加灵活，每次调用方法时都可以选择不同的依赖。

我们还介绍了如何使用 Python 的 DI 框架来实现更加优雅和集中化的依赖管理。无论是使用 injector 还是 dependency-injector，这些框架都能让我们更好地管理依赖，简化开发过程，并提高代码的可维护性和可扩展性。

通过 DI 模式，我们可以将依赖关系从业务逻辑中剥离出来，使代码更加简洁、模块化、易于测试和维护。然而，在使用 DI 时，仍然需要平衡复杂度和灵活性，确保选择最适合项目的方式，以实现最优的设计模式。

【声明】本内容来自华为云开发者社区博主，不代表华为云及华为云开发者社区的观点和立场。转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息，否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
Python
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入