DDD 实战：聚合根设计的五条血泪教训

// 错误示范：上帝聚合根
public class Order {
    private OrderId id;
    private List<OrderItem> items;          // 订单项
    private ShippingAddress address;        // 收货地址
    private PaymentInfo payment;            // 支付信息
    private List<LogisticsRecord> logistics;// 物流跟踪
    private InvoiceInfo invoice;            // 发票信息
    private CouponUsage couponUsage;        // 优惠券使用记录
    private List<OrderRemark> remarks;      // 订单备注
    
    // 一个方法改了 7 个实体的状态...
    public void confirmOrder() {
        // 验证库存、验证地址、创建支付单、生成物流单...
    }
}

// 正确示范：按一致性边界拆分聚合
public class Order {
    private OrderId id;
    private OrderStatus status;
    private List<OrderItem> items;   // 订单项跟随订单生命周期
    private Money totalAmount;       // 总金额由订单项决定，强一致
    
    // 只暴露 ID 引用，不持有其他聚合的实体
    private AddressId addressId;     // 引用，不是包含
    private PaymentId paymentId;
}

// 独立的聚合根
public class ShippingAddress {
    private AddressId id;
    private OrderId orderId;  // 通过 ID 关联，不是对象引用
    // ...
}

public class PaymentRecord {
    private PaymentId id;
    private OrderId orderId;
    // ...
}

// 错误示范：跨聚合对象引用
public class OrderItem {
    private Product product;  // 直接引用了另一个聚合根！
    private int quantity;
    private Money subtotal;
}

// 正确示范：用 ID 引用
public class OrderItem {
    private ProductId productId;  // 只持有 ID
    private String productName;   // 冗余必要信息（值对象快照）
    private Money unitPrice;      // 下单时的价格快照
    private int quantity;
}

// 1. 订单聚合根发布领域事件
public class Order {
    private List<DomainEvent> events = new ArrayList<>();
    
    public void confirmOrder() {
        this.status = OrderStatus.CONFIRMED;
        events.add(new OrderConfirmedEvent(this.id, this.items));
    }
}

// 2. 应用服务订阅事件，协调其他聚合
@Service
public class OrderApplicationService {
    @Transactional
    public void confirmOrder(OrderId orderId) {
        Order order = orderRepository.findById(orderId);
        order.confirmOrder();
        orderRepository.save(order);
        
        // 发布事件（事务提交后）
        domainEventPublisher.publish(order.getPendingEvents());
    }
}

// 3. 库存聚合订阅事件，异步处理
@Component
public class InventoryEventHandler {
    @EventListener
    @Transactional
    public void onOrderConfirmed(OrderConfirmedEvent event) {
        for (OrderItemSnapshot item : event.getItems()) {
            Inventory inventory = inventoryRepository.findByProductId(item.getProductId());
            inventory.decrease(item.getQuantity());
            inventoryRepository.save(inventory);
        }
    }
}

// 贫血模型：聚合根只有 getter/setter，业务逻辑在 Service 中
public class Order {
    private OrderStatus status;
    public OrderStatus getStatus() { return status; }
    public void setStatus(OrderStatus status) { this.status = status; }
}

// Service 中写满了业务逻辑
public class OrderService {
    public void cancelOrder(Order order) {
        if (order.getStatus() == OrderStatus.SHIPPED) {
            throw new BusinessException("已发货不能取消");
        }
        if (order.getStatus() == OrderStatus.COMPLETED) {
            throw new BusinessException("已完成不能取消");
        }
        order.setStatus(OrderStatus.CANCELLED);
        // ...
    }
}

// 充血模型：业务规则在聚合根中
public class Order {
    private OrderStatus status;
    
    public void cancel(String reason) {
        if (this.status == OrderStatus.SHIPPED) {
            throw new BusinessException("已发货的订单无法取消，请申请退货");
        }
        if (this.status == OrderStatus.COMPLETED) {
            throw new BusinessException("已完成的订单无法取消");
        }
        
        OrderStatus previousStatus = this.status;
        this.status = OrderStatus.CANCELLED;
        this.cancelReason = reason;
        this.cancelledAt = Instant.now();
        
        // 发布领域事件
        this.registerEvent(new OrderCancelledEvent(this.id, reason, previousStatus));
    }
}