架构与系统设计 / 系统课时

依赖倒置到底倒转了什么

依赖倒置到底倒转了什么

依赖倒置解决的不是“调用顺序反过来”,而是让业务规则不再在编译期依赖数据库、ORM 或远程接口等技术细节。本篇用 Repository 接口拆开高层策略与低层实现,并区分源码依赖方向和运行时调用方向。

学习目标

  • 说清依赖倒置中真正被“倒转”的是源码依赖方向
  • 能用 Repository 接口让应用或领域代码隔离持久化实现
  • 能区分接口归属、对象装配与运行时调用三个问题

从直接依赖看问题

假设支付订单的用例直接创建 JdbcOrderRepository。应用服务为了完成“找到订单并标记已支付”这一业务动作,被迫知道 JDBC 实现类、连接方式甚至技术异常。数据库实现一变,高层业务代码也可能跟着修改。

依赖倒置要求高层策略与低层细节都面向抽象。对聚合持久化而言,这个抽象通常表现为 Repository 接口:接口描述业务真正需要的能力,基础设施层再提供 JDBC、JPA、MyBatis 或内存实现。

依赖倒置前后的源码依赖方向

用 Repository 接口建立依赖边界

下面的单文件 Java 示例不依赖框架。PayOrderService 只认识 OrderRepository,而 InMemoryOrderRepository 负责实现这个抽象。真实项目可以把这些类型拆到不同模块中,核心原则是抽象由业务需要决定,技术实现反过来依赖该抽象。

java
import java.util.HashMap;
import java.util.Map;
import java.util.Optional;

public class DipDemo {
    interface OrderRepository {
        Optional<Order> findById(String id);
        void save(Order order);
    }

    static final class Order {
        private final String id;
        private boolean paid;

        Order(String id) {
            this.id = id;
        }

        String id() {
            return id;
        }

        void markPaid() {
            paid = true;
        }

        String status() {
            return paid ? "PAID" : "UNPAID";
        }
    }

    static final class PayOrderService {
        private final OrderRepository repository;

        PayOrderService(OrderRepository repository) {
            this.repository = repository;
        }

        void pay(String orderId) {
            Order order = repository.findById(orderId)
                    .orElseThrow(() -> new IllegalArgumentException("order not found"));
            order.markPaid();
            repository.save(order);
        }
    }

    static final class InMemoryOrderRepository implements OrderRepository {
        private final Map<String, Order> store = new HashMap<>();

        public Optional<Order> findById(String id) {
            return Optional.ofNullable(store.get(id));
        }

        public void save(Order order) {
            store.put(order.id(), order);
        }
    }

    public static void main(String[] args) {
        InMemoryOrderRepository repository = new InMemoryOrderRepository();
        repository.save(new Order("O-1001"));

        PayOrderService service = new PayOrderService(repository);
        service.pay("O-1001");

        System.out.println(repository.findById("O-1001").orElseThrow().status());
    }
}

预期输出

text
PAID

运行时仍然是应用服务调用 Repository 实例,Repository 实例再访问存储。变化发生在源码层面:PayOrderService 不导入具体持久化实现;反而是具体实现声明 implements OrderRepository,低层模块因此指向业务所需的抽象。

接口放在哪里才算倒置

“高层模块定义抽象”不等于接口必须和应用服务写在同一个文件。如果 OrderRepository 表达“按标识取得聚合、保存聚合”这类领域持久化能力,常由领域层拥有;如果某个接口只服务特定应用查询,也可以由应用层拥有。关键是接口属于需要这项能力的一侧,而不是由数据库实现反向规定业务形状。

真正需要避免的是让业务接口暴露低层细节,例如返回 ResultSet、要求传入 ORM Session,或把数据库表结构直接变成业务方法参数。这样即使多了一层接口,业务代码仍被技术细节污染。

对象最终仍要被组装

接口不能自己创建实现。程序入口、Spring 配置或其他组合根必须在最外层决定本次运行使用哪个实现,再把实现对象传给应用服务。组合根可以同时知道抽象和具体类,因为它负责装配对象,而不是承载业务规则。

因此可以用一个实际问题检查依赖方向:业务代码能否在不知道数据库、消息中间件或 HTTP 客户端具体实现的情况下完成编译和单元测试。若可以,高层策略通常已经不再受低层技术细节牵制。

按自己的节奏,确认真正理解。

目录与阅读设置

阅读设置

17

记录一个想法

依赖倒置到底倒转了什么

0 / 10000 · 笔记保存到账号。未提交的修改会在关闭、离开或刷新后丢失。

登录哪都通