Python：依赖倒置原则（DIP）

依赖倒置原则（Dependency Inversion Principle，DIP）是 SOLID 原则之一，由 Robert C. Martin 提出。它强调：

1、高层模块（High-level module）不应该依赖低层模块（Low-level module）。两者都应该依赖抽象（Interface/抽象类）。

2、抽象不应该依赖细节。细节应该依赖抽象。

换句话说，DIP 的核心理念是面向抽象编程，而非面向实现编程。这样可以让系统更灵活、可扩展，同时降低模块间耦合度。

一、为什么需要依赖倒置原则？

在传统设计中，高层业务模块直接依赖低层实现，容易出现以下问题：

• 修改低层模块会直接影响高层模块，破坏系统稳定性。

• 系统难以扩展新功能，需要改动多个类。

• 测试困难，无法轻松替换依赖（例如单元测试中替换数据库或网络模块）。

举例：违反 DIP 的设计

ruby 复制代码

class MySQLDatabase:    def connect(self):        print("连接 MySQL 数据库")
class UserService:    def __init__(self):        self.db = MySQLDatabase()  # ❌ 高层模块依赖低层实现
    def add_user(self, name: str):        self.db.connect()        print(f"添加用户 {name}")

问题：

• UserService 直接依赖 MySQLDatabase 具体实现。

• 如果改用 PostgreSQL 数据库，必须修改 UserService 类的代码。

• 单元测试无法用 Mock 对象替代真实的数据库连接。

这种设计违反了依赖倒置原则，导致系统僵化、难以维护。

二、依赖倒置原则的核心思想

DIP 的基本要求：

1、高层模块不依赖低层模块，二者都依赖抽象

2、抽象不依赖具体实现，实现依赖抽象

换句话说：

• 依赖于接口（抽象），而非具体类

• 通过抽象隔离高层与低层

• 将控制权从低层模块转移到高层模块

在 Python 中，这通常通过抽象基类（ABC）或协议（Protocol）实现。

三、Python 中实现 DIP 的方法

（1）使用抽象基类（ABC）

ruby 复制代码

from abc import ABC, abstractmethod
class Database(ABC):    @abstractmethod    def connect(self): ...
class MySQLDatabase(Database):    def connect(self):        print("连接 MySQL 数据库")
class UserService:    def __init__(self, db: Database):  # 依赖抽象，而非具体实现        self.db = db
    def add_user(self, name: str):        self.db.connect()        print(f"添加用户 {name}")
# 使用示例mysql_db = MySQLDatabase()service = UserService(mysql_db)service.add_user("小艾")

优势：

• 高层模块 UserService 不依赖具体数据库实现

• 可以轻松替换数据库实现（例如 PostgreSQL 或 SQLite）

• 单元测试时可替换为 Mock 对象

（2）使用协议（Protocol）实现轻量抽象

python 复制代码

from typing import Protocol
class DBProtocol(Protocol):    def connect(self): ...
class PostgreSQLDatabase:    def connect(self):        print("连接 PostgreSQL 数据库")
def process_user(db: DBProtocol, user: str):    db.connect()    print(f"处理用户 {user}")
# 使用示例postgres = PostgreSQLDatabase()process_user(postgres, "小艾")

优势：

• Pythonic 风格，符合鸭子类型

• 不需要显式继承 ABC，只要"实现所需方法"即可

• 更灵活，支持结构化类型注解

四、违反 DIP 的典型场景

（1）高层直接依赖低层实现

ruby 复制代码

class EmailSender:    def send(self, msg): ...
class Notification:    def __init__(self):        self.sender = EmailSender()  # ❌ 依赖具体实现

（2）修改低层实现破坏高层模块

例如，当 EmailSender 改为使用第三方 SDK 时，Notification 类也需要相应修改。

（3）单元测试困难

高层模块难以替换依赖，导致测试变得复杂、脆弱。

（4）工厂方法返回具体类型

ruby 复制代码

def create_database():    return MySQLDatabase()  # ❌ 返回具体类型，限制了扩展性

五、遵守 DIP 的设计建议

（1）依赖抽象，不依赖具体类

高层模块与低层模块都依赖接口或抽象类，而非具体实现。

（2）通过构造函数或依赖注入传入依赖

避免在高层模块内部直接创建低层对象，使用依赖注入模式。

（3）接口尽量小而精

与接口隔离原则（ISP）配合，每个抽象只暴露必要方法，避免高层模块依赖多余功能。

（4）轻量抽象优先

Python 中可以使用 Protocol、ABC 或鸭子类型，不必追求复杂的接口层次结构。

（5）便于测试和替换

单元测试中可以用 Mock 对象替换依赖，实现无侵入测试。

（6）使用依赖注入容器（可选）

对于大型项目，可以使用依赖注入容器来管理依赖关系。

示例：日志系统

python 复制代码

from abc import ABC, abstractmethod
class Logger(ABC):    @abstractmethod    def log(self, msg: str): ...
class FileLogger(Logger):    def log(self, msg: str):        with open("log.txt", "a", encoding="utf-8") as f:            f.write(msg + "\n")
class ConsoleLogger(Logger):    def log(self, msg: str):        print(msg)
class AppService:    def __init__(self, logger: Logger):  # ✅ 依赖抽象        self.logger = logger
    def process(self):        self.logger.log("开始处理任务")        self.logger.log("任务完成")
# 使用示例file_logger = FileLogger()console_logger = ConsoleLogger()
service1 = AppService(file_logger)service2 = AppService(console_logger)
service1.process()service2.process()

说明：

• AppService 不依赖具体日志实现

• 可自由替换不同的 Logger 实现

• 高层与低层模块完全解耦

• 符合依赖倒置原则

📘 小结

依赖倒置原则是构建灵活、可维护系统的基石。它要求高层模块不依赖低层实现，而是共同依赖抽象，从而降低耦合度、提高扩展性。在 Python 中，通过 ABC、Protocol 或鸭子类型可以自然实现 DIP，让系统在面对需求变化时保持稳定。遵循 DIP 不仅能提升代码的可测试性和可维护性，还能促进更好的模块划分与团队协作。

"点赞有美意，赞赏是鼓励"