设计模式-依赖倒置原则（Dependency Inversion Principle, DIP）

原创于 2025-06-16 17:40:01 发布 · 343 阅读

9 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言

依赖倒置原则（Dependency Inversion Principle, DIP）

核心思想：

高层模块不应依赖低层模块，二者都应依赖抽象（接口或抽象类）。
抽象不应依赖细节，细节（具体实现）应依赖抽象。

目标：通过解耦模块间的直接依赖，提升代码的灵活性、可维护性和可测试性。

原理详解

依赖方向反转
- 传统依赖：高层模块直接调用低层模块（如业务逻辑依赖具体数据库操作）。
- 倒置后依赖：高层和低层模块均依赖抽象接口，低层模块实现接口。
实现方式
- 依赖注入（Dependency Injection）：通过构造函数、Setter 方法或框架（如 Spring）注入具体实现。
- 接口隔离：定义稳定的抽象接口，隔离变化风险。

应用案例

案例1：数据访问层解耦

传统设计（违反DIP）

// 高层模块直接依赖低层模块
class UserService {
    private MySQLDatabase database; // 直接依赖具体实现
    public UserService() {
        this.database = new MySQLDatabase();
    }
    public void saveUser(User user) {
        database.save(user);
    }
}

class MySQLDatabase {
    public void save(User user) { /* MySQL 存储逻辑 */ }
}

问题：

切换数据库（如改用 MongoDB）需修改 UserService 源码。
难以单元测试（直接依赖具体数据库实现）。

遵循DIP的设计

// 定义抽象接口
interface Database {
    void save(User user);
}

// 高层模块依赖抽象
class UserService {
    private Database database; // 依赖抽象
    public UserService(Database database) { // 依赖注入
        this.database = database;
    }
    public void saveUser(User user) {
        database.save(user);
    }
}

// 低层模块实现接口
class MySQLDatabase implements Database {
    @Override
    public void save(User user) { /* MySQL 存储逻辑 */ }
}

class MongoDBDatabase implements Database {
    @Override
    public void save(User user) { /* MongoDB 存储逻辑 */ }
}

// 使用示例
Database mysqlDb = new MySQLDatabase();
UserService service = new UserService(mysqlDb); // 注入具体实现
service.saveUser(new User());

优势：

切换数据库只需更换注入的实现类（如 new MongoDBDatabase()）。
单元测试时可注入 Mock 对象（如 MockDatabase）。

案例2：消息通知系统

传统设计（违反DIP）

class NotificationService {
    private EmailSender emailSender; // 直接依赖具体实现
    private SMSSender smsSender;

    public void sendEmail(String message) {
        emailSender.send(message);
    }

    public void sendSMS(String message) {
        smsSender.send(message);
    }
}

问题：

新增通知方式（如微信通知）需修改 NotificationService 类。
高层模块与低层模块强耦合。

遵循DIP的设计

// 定义抽象接口
interface MessageSender {
    void send(String message);
}

// 高层模块依赖抽象
class NotificationService {
    private MessageSender sender; // 依赖抽象
    public NotificationService(MessageSender sender) {
        this.sender = sender;
    }
    public void sendNotification(String message) {
        sender.send(message);
    }
}

// 低层模块实现接口
class EmailSender implements MessageSender {
    @Override
    public void send(String message) { /* 发送邮件 */ }
}

class SMSSender implements MessageSender {
    @Override
    public void send(String message) { /* 发送短信 */ }
}

class WeChatSender implements MessageSender {
    @Override
    public void send(String message) { /* 发送微信消息 */ }
}

// 使用示例
MessageSender weChatSender = new WeChatSender();
NotificationService service = new NotificationService(weChatSender);
service.sendNotification("Hello");

优势：

新增通知方式只需实现 MessageSender 接口，无需修改高层代码。
支持灵活扩展和替换通知渠道。

DIP 实践指南

识别变化点：将易变的部分抽象为接口（如数据库操作、外部服务调用）。
依赖注入框架：使用 Spring、Guice 等框架自动管理依赖关系。
面向接口编程：在代码中优先使用接口类型声明变量和方法参数。

违反 DIP 的典型场景

场景	后果	修复方案
高层模块直接实例化低层类	切换实现需修改高层代码	通过依赖注入解耦
具体类之间的直接依赖	系统僵化，难以扩展	引入接口隔离依赖
工具类静态方法调用	难以替换实现和测试	将工具类封装为接口实现