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

Repository 怎样保存整个聚合

Repository 怎样保存整个聚合

Repository 的关键不是“帮每张表写一个 DAO”,而是以聚合为持久化单位。本节通过订单示例说明:领域层只声明 OrderRepository,基础设施层把 Order 与持久化模型互相转换,再调用具体数据库组件一次保存或重建完整聚合。

学习目标

  • 理解 Repository 为什么围绕聚合根而不是数据库表设计
  • 看懂基础设施层如何完成聚合与持久化模型之间的转换
  • 明确保存子实体时的事务边界与加载边界

Repository 面向聚合而不是表

订单聚合可能落到 orders 和 order_lines 两张表,但应用层不应该先保存订单表、再循环保存明细表。那会把聚合内部结构和事务细节泄漏到用例代码中,也让“保存了一半”的状态更容易出现。

更合适的接口是 save(Order order) 和 findById(String id)。调用方只处理一个完整 Order;至于需要写几张表、执行几条 SQL、怎样映射字段,由基础设施层负责。

Repository 保存和重建订单聚合的数据流

基础设施层负责转换与数据库调用

下面的完整示例把 OrderRepository 作为领域侧抽象,把 SqlOrderRepository 放在基础设施侧。为了让示例无需外部依赖,InMemoryOrderMapper 用内存模拟具体数据库组件;真实项目中可替换为 MyBatis、JPA 或 JDBC 适配器,Repository 的职责不变。

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

public class Main {
    record OrderLine(String sku, int quantity) {
        OrderLine {
            if (sku == null || sku.isBlank() || quantity <= 0) {
                throw new IllegalArgumentException("invalid order line");
            }
        }
    }

    static final class Order {
        private final String id;
        private final List<OrderLine> lines;

        Order(String id, List<OrderLine> lines) {
            if (id == null || id.isBlank()) {
                throw new IllegalArgumentException("id is required");
            }
            this.id = id;
            this.lines = new ArrayList<>(lines);
        }

        String id() {
            return id;
        }

        List<OrderLine> lines() {
            return List.copyOf(lines);
        }
    }

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

    record OrderRow(String id) {
    }

    record OrderLineRow(String orderId, String sku, int quantity) {
    }

    interface OrderMapper {
        void upsertOrder(OrderRow row);
        void replaceLines(String orderId, List<OrderLineRow> rows);
        Optional<OrderRow> findOrder(String orderId);
        List<OrderLineRow> findLines(String orderId);
    }

    static final class InMemoryOrderMapper implements OrderMapper {
        private final Map<String, OrderRow> orders = new HashMap<>();
        private final Map<String, List<OrderLineRow>> lines = new HashMap<>();

        public void upsertOrder(OrderRow row) {
            orders.put(row.id(), row);
        }

        public void replaceLines(String orderId, List<OrderLineRow> rows) {
            lines.put(orderId, List.copyOf(rows));
        }

        public Optional<OrderRow> findOrder(String orderId) {
            return Optional.ofNullable(orders.get(orderId));
        }

        public List<OrderLineRow> findLines(String orderId) {
            return lines.getOrDefault(orderId, List.of());
        }
    }

    static final class SqlOrderRepository implements OrderRepository {
        private final OrderMapper mapper;

        SqlOrderRepository(OrderMapper mapper) {
            this.mapper = mapper;
        }

        public void save(Order order) {
            mapper.upsertOrder(new OrderRow(order.id()));

            List<OrderLineRow> rows = order.lines().stream()
                    .map(line -> new OrderLineRow(
                            order.id(), line.sku(), line.quantity()))
                    .toList();

            // 根实体与所有子实体由一个 Repository 协调持久化。
            mapper.replaceLines(order.id(), rows);
        }

        public Optional<Order> findById(String id) {
            return mapper.findOrder(id).map(row -> {
                List<OrderLine> lines = mapper.findLines(id).stream()
                        .map(line -> new OrderLine(line.sku(), line.quantity()))
                        .toList();
                return new Order(row.id(), lines);
            });
        }
    }

    public static void main(String[] args) {
        OrderMapper mapper = new InMemoryOrderMapper();
        OrderRepository repository = new SqlOrderRepository(mapper);

        Order order = new Order(
                "O-1001",
                List.of(new OrderLine("BOOK", 2), new OrderLine("PEN", 1))
        );

        repository.save(order);
        System.out.printf("saved aggregate=%s, lineCount=%d%n",
                order.id(), order.lines().size());

        Order loaded = repository.findById("O-1001").orElseThrow();
        System.out.printf("loaded aggregate=%s, lineCount=%d%n",
                loaded.id(), loaded.lines().size());
    }
}

预期输出

text
saved aggregate=O-1001, lineCount=2
loaded aggregate=O-1001, lineCount=2

真实数据库必须保证原子性

示例中的 upsertOrder 与 replaceLines 是两个数据库动作的抽象。在真实关系数据库中,它们应处于同一个事务:根记录成功但明细写入失败时,整个保存必须回滚,否则数据库里会出现一个无法还原为合法聚合的半成品。

事务通常由基础设施实现或应用层事务边界协调,但事务覆盖的持久化范围应与聚合一致。不要把 OrderLineRepository 暴露给应用服务,让它在聚合之外独立修改订单明细;这等于绕过聚合根。

加载时也要一次重建完整聚合

findById 不只是“查一行订单”。它需要读取根记录及本次业务操作所需的子实体,然后重建 Order。如果聚合很大,说明边界可能需要重新评估,而不是简单把 Repository 改成按表返回半个领域对象。

同时要避免让领域对象依赖 OrderRow、ORM Entity 或 Mapper 类型。持久化模型属于基础设施细节;领域模型只表达业务含义,转换逻辑由 Repository 实现承担。

Repository 与 DAO 的边界

DAO、Mapper 或 ORM Repository 通常直接面向表、文档或持久化实体;DDD Repository 面向领域聚合。两者可以同时存在:SqlOrderRepository 负责“保存一个订单聚合”,内部再调用 OrderMapper 负责具体读写。

这样应用层只看见 OrderRepository,领域层保持对数据库技术无感,基础设施层则集中处理字段映射、SQL/ORM 调用和事务。只要这个边界没有泄漏,未来把 MyBatis 换成 JPA,或把关系库存储改成其他实现,都不需要改写订单的领域行为。

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

目录与阅读设置

阅读设置

17

记录一个想法

Repository 怎样保存整个聚合

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

登录哪都通