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

用领域事件连接后续动作

用领域事件连接后续动作

当订单完成支付后,通知用户、增加积分、触发履约都可能随之发生。如果把这些动作直接写进订单聚合,核心事务会迅速耦合外部系统。本节把“订单已支付”建模为领域事件,让聚合只记录已经发生的业务事实,再由事件处理器决定后续动作。

学习目标

  • 能把领域事件命名为已经发生的业务事实,并明确事件产生位置
  • 能让通知、积分、履约等后续动作从聚合核心行为中解耦
  • 能识别“保存聚合后立即发消息”的可靠性缺口,并知道何时使用 Outbox

事件表达已经完成的事实

领域事件应使用过去式语义,例如 OrderPaid、InventoryReserved,因为它描述的是领域中已经成立的事实,而不是“请做某事”的命令。事件通常由聚合在完成状态变更时产生,因此它可以携带后续动作真正需要的最小信息,例如订单 ID、用户 ID 和支付金额。

聚合不应该知道“有三个订阅者”,更不应该直接调用短信、积分或履约客户端。它只负责保证自身规则成立,并把事实记录下来。应用服务在保存聚合之后取得这些事件,再交给发布器分发。

订单支付领域事件与后续动作解耦流程

在聚合中记录事件

下面的完整示例让订单聚合在支付成功时记录 OrderPaid。应用服务负责保存聚合并发布事件;三个处理器彼此独立,新增第四个后续动作时不需要修改 Order.pay()。

java
import java.util.ArrayList;
import java.util.List;
import java.util.function.Consumer;

public class DomainEventDemo {
    interface DomainEvent {}

    record OrderPaid(String orderId, String userId, long amountCents)
            implements DomainEvent {}

    static final class Order {
        private final String id;
        private final String userId;
        private final long amountCents;
        private String status = "CREATED";
        private final List<DomainEvent> pendingEvents = new ArrayList<>();

        Order(String id, String userId, long amountCents) {
            this.id = id;
            this.userId = userId;
            this.amountCents = amountCents;
        }

        void pay() {
            if (!"CREATED".equals(status)) {
                throw new IllegalStateException("order cannot be paid");
            }
            status = "PAID";
            // 先完成聚合内状态变化,再记录已经成立的业务事实。
            pendingEvents.add(new OrderPaid(id, userId, amountCents));
        }

        List<DomainEvent> pullEvents() {
            List<DomainEvent> copy = List.copyOf(pendingEvents);
            pendingEvents.clear();
            return copy;
        }
    }

    static final class OrderRepository {
        private final List<Order> store = new ArrayList<>();

        void save(Order order) {
            // 用内存集合模拟已提交的持久化结果,重点保留“先保存、后发布”的顺序。
            store.add(order);
        }
    }

    static final class EventPublisher {
        private final List<Consumer<OrderPaid>> handlers = new ArrayList<>();

        void onOrderPaid(Consumer<OrderPaid> handler) {
            handlers.add(handler);
        }

        void publish(DomainEvent event) {
            if (event instanceof OrderPaid paid) {
                handlers.forEach(handler -> handler.accept(paid));
            }
        }
    }

    public static void main(String[] args) {
        OrderRepository repository = new OrderRepository();
        EventPublisher publisher = new EventPublisher();

        publisher.onOrderPaid(e ->
                System.out.println("notification: " + e.orderId()));
        publisher.onOrderPaid(e ->
                System.out.println("points: " + e.orderId() + " +100"));
        publisher.onOrderPaid(e ->
                System.out.println("fulfillment: " + e.orderId()));

        Order order = new Order("O-1001", "U-9", 29900);
        order.pay();
        repository.save(order);

        order.pullEvents().forEach(publisher::publish);
    }
}

预期输出

text
notification: O-1001
points: O-1001 +100
fulfillment: O-1001

这个例子刻意把事件发布放在应用服务一侧:聚合决定“何时产生事实”,发布器决定“如何通知订阅者”,处理器决定“事实发生后各自做什么”。三类职责被分开后,核心支付规则不会因为新增通知渠道而改变。

处理事务提交与可靠发布

最小示例中的“保存成功后立即发布”存在一个生产级缺口:数据库已经提交,但进程可能在消息发送前崩溃,导致事件丢失;反过来,如果先发送消息再回滚数据库,又会出现外部动作已经发生而订单未支付的矛盾。

需要可靠跨进程传播时,常用 Transactional Outbox:在同一个本地事务中同时保存聚合状态和 Outbox 事件记录,事务提交后再由独立 Relay 重试发布。这样核心事务只保证本地数据与事件记录原子一致,通知、积分和履约则接受最终一致性,并通过事件 ID 做幂等处理。

判断什么该成为事件

适合建模为领域事件的,是“业务上值得被其他规则关注的已完成事实”,例如订单已支付、会员已升级、退款已批准。单纯的字段变化未必值得发布,例如把内部缓存标记从 false 改成 true 通常不是领域事实。

如果某个后续动作必须与聚合状态在同一强一致事务中完成,它也不应仅靠异步事件“最终补上”。先确定一致性要求,再决定使用聚合内规则、同事务应用服务协作,还是领域事件加 Outbox。事件的价值不在于多一层代码,而在于让“事实发生”和“谁关心这个事实”保持独立。

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

目录与阅读设置

阅读设置

17

记录一个想法

用领域事件连接后续动作

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

登录哪都通