一、起源

1.1 三类复杂度信号

技术层面的复杂度(并发、性能、可用性)有成熟解法,业务层面的复杂度没有通用解法,只能靠结构与语言约束。业务复杂度失控时会出现三类可观察的信号:

信号 表现 后果
术语漂移 同一个概念在不同模块中名称不同,或同一名称指代不同含义 沟通成本上升,改动时无法判断影响范围
规则散落 同一条业务规则在多个服务方法中重复实现 规则修改时漏改,各处行为逐渐分歧
边界模糊 模块之间随意互相调用,事务跨越多个业务概念 改一处影响多处,回归范围无法界定

三类信号的共同原因是:代码结构按技术分层组织(控制器、服务、数据访问),而业务概念在结构中没有位置。

1.2 事务脚本与贫血模型的适用边界

先说清什么情况下不需要领域驱动:

场景 适用形态 判断依据
以数据录入与查询为主,规则少 事务脚本,服务方法按用例组织 业务规则可以在一屏代码内看全
规则集中但变化少 贫血模型加规则集中校验 规则不跨越多个对象
规则相互关联、状态流转复杂 领域模型 存在需要整体维护的不变式

判断标准是"是否需要在多个对象之间维持一致性约束"。如果一条规则只涉及单条记录的字段校验,事务脚本足够;如果一条规则要求"账户余额与流水之和始终相等"这类跨对象约束,就需要一个显式的一致性边界。

1.3 引入成本

领域驱动的成本不在工具,而在沟通与演进:

  • 需要业务方参与建模,把术语、规则、状态流转显式化,这部分投入在短期看不到产出。
  • 模型需要随业务演进持续调整,一次建模不能一劳永逸。
  • 若团队对业务的理解尚未统一,先做建模会把分歧暴露出来并阻塞进度,这是它容易在中途放弃的主要原因。

因此引入的前提是:业务复杂度已经构成主要矛盾,且团队有能力持续维护模型。

二、原理

2.1 限界上下文:战略设计的核心

限界上下文的定义是"术语含义唯一的边界"。同一个词在不同上下文中含义不同是常态,例如"商品"在交易上下文中包含价格与库存,在物流上下文中包含重量与体积,在推荐上下文中只包含标签。要求全局使用同一个商品模型,会得到一个包含所有上下文需求的巨大对象。

划分依据按可靠性从高到低排列:

  1. 业务能力的自然边界:同一批业务规则由同一个团队负责,且这些规则的变更节奏一致。
  2. 术语的语义边界:出现"同一个词在两处含义不同"的位置,通常是上下文边界。
  3. 组织边界:团队边界与协作方式决定沟通成本,进而决定模型边界;与组织冲突的划分难以长期维持。
  4. 数据一致性要求:需要强一致的数据应落在同一上下文内,否则需要为跨边界的一致性设计补偿路径。

上下文之间必然存在协作,协作关系需要显式声明,因为它决定了两侧的耦合强度与变更影响:

关系 含义 耦合强度与适用
共享内核 两个上下文共享一部分模型 高,仅适用于同一团队且变更同步
客户方与供应方 上游按下游需求提供接口 中,适用于上下游有协商能力的场景
遵奉者 下游直接采用上游模型 中高,适用于上游不配合但模型稳定
防腐层 下游用转换层隔离上游模型 低,适用于上游模型不稳定或语义差异大
开放主机服务 上游提供稳定的对外服务协议 低,适用于一方对接多方
发布语言 上下游用统一的交换格式通信 低,通常与开放主机服务配合
各行其道 不集成 无耦合,适用于集成收益低于成本

2.2 聚合:一致性边界

聚合是"作为一个整体被修改与读取的对象簇",聚合根是唯一的外部访问入口。

概念 判据 例子
实体 有标识,标识不变而属性可变 订单、账户
值对象 无标识,由属性值定义相等性,不可变 金额、地址、时间段
聚合根 聚合的唯一入口,负责维护聚合内的不变式 订单是订单项的聚合根

四条设计原则按重要性排列:

  1. 不变式决定边界:聚合内必须始终成立的约束,就是事务边界。要求"订单总额等于各订单项金额之和"这类约束必须在同一事务内维护,因此订单与订单项属于同一聚合。
  2. 聚合尽量小:聚合越大,并发冲突越多、加载成本越高。若某条约束只在极少数操作中需要,可降级为最终一致,而不是扩大聚合。
  3. 以标识引用其他聚合:聚合内不持有其他聚合对象的引用,只保存标识。这样加载一个聚合不会级联加载整个对象图,也避免了跨聚合的事务边界。
  4. 跨聚合一致用最终一致:同一事务只修改一个聚合,跨聚合的约束通过领域事件与补偿达成。

一致性边界与事务边界的对应关系决定了并发行为:同一聚合的并发写入会互相冲突,需要通过乐观锁或版本号处理;不同聚合的写入互不阻塞。

2.3 领域事件

领域事件是"业务上值得记录的状态变更",它同时承担两个职责:表达业务语义,以及在聚合之间传递变更。

设计要点 要求 原因
命名 用过去时描述已发生的事实 事件是事实而非意图,命名决定它是否被误用为命令
内容 携带接收方决策所需的数据,而不只是标识 减少接收方回查,也避免接收方因数据已变化而做出错误决策
粒度 按业务含义划分,不按数据表划分 一个业务动作可能修改多张表,但对外是一个业务事实
不可变 事件对象创建后不修改 事件是历史记录

发布时机的选择是关键工程问题:在事务内直接发布事件,会出现"事件已发出但事务回滚"的不一致。正确路径是事务内记录、事务后发布,三种实现方式:

方式 机制 特点
事务同步回调 注册事务提交后的回调,在回调中发布 实现简单,但进程崩溃会导致事件丢失
本地消息表 事件与业务数据在同一事务写入本地表,再由独立任务投递 可保证不丢,需处理投递重复与清理
事务消息 由消息中间件参与两阶段提交 依赖中间件支持,链路较长

投递语义至少是"至少一次",因此接收方必须幂等,判断手段见 消息可靠性与幂等。

2.4 分层与依赖方向

领域驱动采用四层结构,关键约束是依赖方向单向向内:

层 职责 不承担的职责
用户接口层 协议转换、参数校验、响应组装 业务规则、事务编排
应用层 用例编排、事务边界、权限校验、事件发布 业务规则判断
领域层 业务规则、不变式、领域事件定义 持久化、外部调用、框架依赖
基础设施层 持久化、消息、外部系统适配 业务规则

三条具体结论:

  • 仓储接口定义在领域层,实现放在基础设施层,这是依赖倒置在领域驱动中的主要应用。领域层只依赖接口,因此不依赖任何持久化框架。
  • 应用服务负责编排,领域服务负责跨越多个聚合或无法自然归属某个实体的规则。把业务规则写进应用服务会让规则重新散落。
  • 领域层不依赖框架:不出现持久化注解、事务注解、HTTP 对象。这一约束是模型可测试与可演进的前提,也是落地时最先被破坏的一条。

2.5 贫血与充血的取舍

模型 表现 适用
贫血 对象只有属性,规则集中在服务类 规则简单、以数据为中心、团队以数据表思维协作
充血 对象包含属性与操作自身状态的方法 存在跨属性约束、状态流转复杂

取舍依据是"规则是否围绕对象状态展开"。若规则主要围绕状态与不变式,把规则放在对象内部可以减少重复;若规则主要是跨对象的外部流程,放在对象内会引入不必要的依赖。混用是常态,需要避免的是"名义上充血、实际规则仍在服务中"的状态。

2.6 防腐层

防腐层是下游为隔离上游模型而加的转换层,适用条件是上游模型不稳定、语义与本地不同、或上游由外部提供。它的作用是阻止上游的模型与术语渗透到本地领域模型,代价是增加一层转换与维护成本,以及同一概念在两处出现不同定义。

不适用的情况:上下游由同一团队维护且模型一致时,防腐层只会增加无意义的映射代码。

2.7 事件风暴与领域语言

事件风暴是一种协作建模手段,产出物是领域事件序列、命令、聚合与边界。它的价值在于让业务方与开发方用同一套语言描述流程,并把分歧在建模阶段暴露。产出物应落到三处:术语表(统一语言)、上下文划分(边界)、事件序列(状态流转与一致性要求)。

领域语言落地的判断标准是:代码中的类名、方法名与业务方口述的流程能够对应。做不到这一点,说明模型与业务仍然脱节。

三、实现

3.1 包结构

com.example.order
├── interfaces            # 用户接口层:控制器、请求与响应对象、转换器
│   ├── rest
│   └── assembler
├── application           # 应用层:用例编排、事务边界
│   ├── OrderApplicationService.java
│   ├── command           # 入参命令
│   └── event             # 对外集成事件的发布入口
├── domain                # 领域层:不依赖框架
│   ├── model
│   │   ├── Order.java            # 聚合根
│   │   ├── OrderItem.java        # 聚合内实体
│   │   ├── Money.java            # 值对象
│   │   └── OrderStatus.java
│   ├── event
│   │   └── OrderPaidEvent.java
│   ├── repository
│   │   └── OrderRepository.java  # 接口,定义在领域层
│   └── service
│       └── PricingService.java   # 领域服务
└── infrastructure        # 基础设施层:实现领域层定义的接口
    ├── persistence
    │   ├── OrderRepositoryImpl.java
    │   └── OrderPO.java          # 持久化对象,与聚合对象分离
    └── messaging
        └── DomainEventPublisher.java

分层与包结构的完整规则与依赖方向的守护方式见 架构风格与依赖方向。

3.2 聚合的实现要点

public class Order {                       // 聚合根

    private OrderId id;
    private OrderStatus status;
    private final List<OrderItem> items = new ArrayList<>();
    private Money totalAmount;
    private long version;                  // 乐观锁版本

    // 变更只能通过业务方法,不提供 setter
    public void addItem(ProductId productId, Money unitPrice, int quantity) {
        if (status != OrderStatus.CREATED) {
            throw new DomainException("订单已支付,不能修改明细");
        }
        items.add(new OrderItem(productId, unitPrice, quantity));
        recalculateTotal();                // 维护聚合内不变式
    }

    public void pay(PaymentId paymentId) {
        if (items.isEmpty()) {
            throw new DomainException("订单无明细,不能支付");
        }
        if (status != OrderStatus.CREATED) {
            throw new DomainException("订单状态不允许支付");
        }
        this.status = OrderStatus.PAID;
        // 记录而不是立即投递事件
        DomainEvents.record(new OrderPaidEvent(this.id, paymentId, this.totalAmount));
    }

    private void recalculateTotal() {
        this.totalAmount = items.stream()
                .map(OrderItem::subtotal)
                .reduce(Money.zero(), Money::add);
    }

    // 只暴露不可变视图,防止外部绕过聚合根修改内部集合
    public List<OrderItem> items() {
        return List.copyOf(items);
    }
}

要点:

  • 不提供 setter,状态变更只能通过表达业务语义的方法,使不变式有唯一维护位置。
  • 内部集合只暴露不可变视图,否则外部可以直接修改集合,绕过聚合根的校验。
  • 其他聚合以标识引用,例如 ProductId 与 PaymentId,不持有 Product 对象。
  • 事件在业务方法中记录而不投递,投递时机由应用层与基础设施层控制。

3.3 领域事件的投递

// 领域层:只负责记录
public final class DomainEvents {

    private static final ThreadLocal<List<Object>> HOLDER = ThreadLocal.withInitial(ArrayList::new);

    public static void record(Object event) { HOLDER.get().add(event); }

    public static List<Object> drain() {
        List<Object> events = List.copyOf(HOLDER.get());
        HOLDER.remove();                        // 必须清理,避免线程池复用导致事件串场
        return events;
    }
}
// 应用层:编排用例并确定事务边界;事件在事务提交后发布
@Service
public class OrderApplicationService {

    private final OrderRepository orderRepository;
    private final DomainEventPublisher publisher;

    @Transactional
    public void pay(PayCommand command) {
        Order order = orderRepository.findById(new OrderId(command.orderId()))
                .orElseThrow(() -> new DomainException("订单不存在"));
        order.pay(new PaymentId(command.paymentId()));
        orderRepository.save(order);

        // 注册提交后回调:事务回滚时事件不会发出
        TransactionSynchronizationManager.registerSynchronization(new TransactionSynchronization() {
            @Override
            public void afterCommit() {
                DomainEvents.drain().forEach(publisher::publish);
            }
        });
    }
}

需要权衡的地方:提交后发布存在进程崩溃导致事件丢失的窗口,要求不丢时应改为本地消息表,把事件与业务数据在同一事务写入,再由独立任务投递;此时需要为投递任务设计重试与幂等,避免重复投递造成重复业务。

3.4 仓储与 ORM 的边界

把持久化对象直接当作聚合对象会带来两个问题:框架需要的无参构造与代理机制迫使聚合暴露内部状态;数据库结构变化会直接改变领域模型。

处理方式 做法 适用
分离持久化对象 聚合对象与持久化对象分开,仓储实现负责转换 领域模型与表结构差异较大、聚合结构复杂
直接映射 聚合对象加持久化注解,由框架直接映射 模型与表结构接近、团队规模有限

选择分离需要额外的转换代码,但可以避免「聚合为了适配框架而破坏封装」。若选择直接映射,至少要做到:不因为框架需要而添加 setter,不在领域对象中出现延迟加载的集合遍历(会导致意外的级联查询)。

3.5 防腐层实现

// 上游模型(外部系统),不进入本地领域层
// 防腐层负责把它翻译为本地概念
@Component
public class ExternalProductAdapter implements ProductCatalog {

    private final ExternalProductClient client;

    @Override
    public ProductSnapshot load(ProductId productId) {
        ExternalProductDTO dto = client.get(productId.value());
        return new ProductSnapshot(
                new ProductId(dto.getId()),
                new Money(dto.getPriceCent(), Currency.of(dto.getCurrency())),
                ProductStatus.of(dto.getStatus()));   // 状态映射在防腐层完成
    }
}

要点:上游的字段与状态值只在防腐层出现,本地领域层只看到本地概念;上游新增字段时改动范围限制在适配器内。

3.6 落地顺序与三类退化

落地顺序建议由外向内、由小到大:

  1. 先统一语言:产出术语表,在需求、接口与代码中使用同一套词。
  2. 再划边界:按业务能力与术语差异划出上下文,明确上下文间的关系。
  3. 从变化最频繁、规则最复杂的上下文开始建模,不要全量推倒重来。
  4. 在单个上下文内先建立聚合与不变式,再引入领域事件与跨上下文协作。

三类常见退化:

退化 表现 纠正方式
只会画上下文图 有一堆上下文与关系图,代码结构未变 检查聚合与不变式是否落到代码,术语是否统一
聚合过大 一个聚合包含几乎所有对象,并发冲突频发 按不变式重新界定边界,跨聚合约束改为最终一致
领域层被框架渗透 领域对象出现持久化注解与事务注解 分离持久化对象,仓储接口留在领域层

3.7 常见问题对照

现象 常见原因 核对与处置
同一概念多个名称 未统一语言或跨上下文强行共用模型 产出术语表,明确每个名称所属上下文
规则在多处重复且行为分歧 规则写在应用服务或控制器中 把规则下沉到聚合与领域服务,使其有唯一位置
聚合保存后并发冲突频繁 聚合过大,无关数据进入同一事务边界 按不变式缩小聚合,跨聚合改为最终一致
事件发出但业务已回滚 在事务内直接发布事件 改为事务内记录、提交后发布,或使用本地消息表
事件接收方重复处理 投递为至少一次语义,接收方未幂等 引入幂等键或去重表
加载聚合时触发大量查询 聚合内持有其他聚合的对象引用 改为以标识引用,按需单独加载
领域对象为了适配框架而添加 setter 直接映射导致封装被破坏 分离持久化对象,或至少去除非必要的 setter
上游字段变更导致大范围改动 上游模型直接进入本地领域层 引入防腐层隔离
模型建好后无法演进 建模一次成型后不再维护 把模型演进纳入需求流程,随业务调整
团队认为领域驱动只是多写代码 缺少业务方参与,未产出统一语言 先做事件风暴,把分歧在建模阶段暴露

四、总结

  1. 业务复杂度失控表现为术语漂移、规则散落与边界模糊,根因是代码结构按技术分层组织而业务概念没有位置。
  2. 领域驱动的适用前提是存在跨对象的不变式;只有单记录字段校验的场景,事务脚本成本更低。
  3. 限界上下文是术语含义唯一的边界,划分依据按业务能力、术语语义、组织边界、一致性要求的顺序判断。
  4. 上下文之间的关系需要显式声明,它决定耦合强度;上游模型不稳定时用防腐层隔离,模型一致时不必引入。
  5. 聚合的边界由不变式决定,设计原则是边界小、以标识引用其他聚合、跨聚合用最终一致。
  6. 一致性边界即事务边界:同一聚合的并发写入互相冲突需要版本控制,不同聚合的写入互不阻塞。
  7. 领域事件用过去时命名、携带接收方决策所需数据;投递必须遵循事务内记录与提交后发布,且投递语义至少为一次,因此接收方必须幂等。
  8. 四层结构的关键约束是依赖方向单向向内,仓储接口定义在领域层是依赖倒置的主要应用,领域层不应出现框架依赖。
  9. 贫血与充血的取舍依据是规则是否围绕对象状态展开,需要避免的是名义充血而规则仍留在服务中的状态。
  10. 落地顺序是先统一语言、再划边界、从最复杂的上下文开始,三类常见退化分别对应只会画图、聚合过大、领域层被框架渗透。