领域事件

领域事件 (Domain Events)

概述

领域事件表示领域中已经发生的、值得关注的业务事实，是过去时态的描述。Martin Fowler 将其概括为"捕捉对领域有意义的事情发生的记忆"（"captures the memory of something interesting which affects the domain"）。

核心特征：

• 已发生的事实（不可变 / immutable）
• 命名用过去时态（OrderPlaced、PaymentCompleted）
• 由聚合根产生与发布
• 包含事件发生时的关键数据（事件 ID、聚合 ID、发生时间、必要快照）
• 用于聚合间 / 上下文间的松耦合通信，是实现最终一致性的基础

事件的最小元素（推荐统一约定）：

代码示例

// 领域事件定义
public class OrderPlacedEvent {
    private final String orderId;
    private final String customerId;
    private final BigDecimal totalAmount;
    private final LocalDateTime occurredAt;

    public OrderPlacedEvent(String orderId, String customerId, BigDecimal totalAmount) {
        this.orderId = orderId;
        this.customerId = customerId;
        this.totalAmount = totalAmount;
        this.occurredAt = LocalDateTime.now();
    }
    // getters...
}

// 聚合根发布事件
public class Order {
    private List<DomainEvent> domainEvents = new ArrayList<>();

    public void place() {
        if (this.items.isEmpty()) throw new DomainException("订单不能为空");
        this.status = OrderStatus.PLACED;
        // 记录事件
        domainEvents.add(new OrderPlacedEvent(id, customerId, totalAmount));
    }

    public List<DomainEvent> getDomainEvents() {
        return Collections.unmodifiableList(domainEvents);
    }

    public void clearDomainEvents() {
        domainEvents.clear();
    }
}

// 应用层发布事件
@Service
public class OrderApplicationService {
    public void placeOrder(PlaceOrderCommand cmd) {
        Order order = orderRepo.findById(cmd.getOrderId());
        order.place();
        orderRepo.save(order);

        // 发布所有领域事件
        order.getDomainEvents().forEach(eventPublisher::publish);
        order.clearDomainEvents();
    }
}

// 事件处理器 — 其他上下文处理
@EventHandler
public class InventoryEventHandler {
    public void on(OrderPlacedEvent event) {
        inventoryService.reserveStock(event.getOrderId(), event.getItems());
    }
}

@EventHandler
public class NotificationEventHandler {
    public void on(OrderPlacedEvent event) {
        emailService.sendOrderConfirmation(event.getCustomerId(), event.getOrderId());
    }
}

# Python 领域事件
from dataclasses import dataclass, field
from datetime import datetime

@dataclass(frozen=True)  # 不可变
class OrderPlacedEvent:
    order_id: str
    customer_id: str
    total_amount: float
    occurred_at: datetime = field(default_factory=datetime.now)

@dataclass(frozen=True)
class PaymentCompletedEvent:
    order_id: str
    payment_id: str
    amount: float
    occurred_at: datetime = field(default_factory=datetime.now)

# 聚合根收集事件
class Order:
    def __init__(self):
        self._events = []

    def place(self):
        self.status = "PLACED"
        self._events.append(OrderPlacedEvent(
            order_id=self.id,
            customer_id=self.customer_id,
            total_amount=self.total
        ))

    def collect_events(self) -> list:
        events = list(self._events)
        self._events.clear()
        return events

领域事件 vs 集成事件

Vaughn Vernon 在 IDDD 中强调二者的区分（也常被映射到 EventStorming 的"内部事件 / 外部事件"）：

工程实践上，常以领域事件为源，在边界处转换为集成事件对外发布（例如通过 Outbox 表）。

事件命名规范

✅ 正确：过去时态，描述已发生的事实
- OrderPlaced（订单已下单）
- PaymentCompleted（支付已完成）
- ItemShipped（商品已发货）
- AccountActivated（账户已激活）

❌ 错误：命令式或现在时
- PlaceOrder → 这是命令，不是事件
- ProcessingPayment → 这是进行中，不是完成

事件的用途

常见误区

❌ 命令式命名——PlaceOrderEvent、ProcessPaymentEvent → 事件是过去时事实：OrderPlaced、PaymentCompleted；命令是请求，事件是发生

❌ 事件携带可变对象引用——把整个 Order 聚合对象塞进事件 payload → 事件应携带不可变的数据快照（关键字段 + 聚合 ID）；订阅方需要更多信息时按 ID 回查

❌ 业务事务内同步发布事件——订阅者失败导致主事务回滚，跨上下文耦合死灰复燃 → 事务内只 raise 到聚合，事务提交后由应用服务 / Outbox 发布；订阅方失败不应影响主流程

与其他DDD概念的关系

总结

核心：领域事件 = 已发生的业务事实，用于聚合间解耦通信。

实践：过去时态命名、不可变、聚合根发布、应用层分发、其他上下文订阅处理。