DDD中如何强制Order聚合根的不变量约束？

问题背景 #

Order聚合根存在两个核心不变量约束：

• 必须至少包含一个OrderItem
• 必须设置有效的PaymentMethod

当前存在直接实例化Order后就调用仓储保存的违规操作，导致约束被破坏。同时不想通过构造函数传入所有OrderItem（订单生成初期可能还在添加商品），也不愿依赖外部订单验证服务（担心开发人员遗忘调用）。

问题1：能否通过工厂模式实现？如何将Order的Add方法设为私有？ #

可以通过工厂模式实现，且能从根源上约束Order的创建和修改流程。核心思路是将Order的构造函数、修改方法（AddOrderItem/SetPaymentMethod）设为私有，仅通过工厂类操作订单的创建、添加项和设置支付方式，最后提供一个"完成订单"的方法，只有满足约束时才返回合法的Order实例。

代码示例 #

// Order聚合根，仅暴露只读属性，修改逻辑私有
public class Order
{
    private readonly List<OrderItem> _orderItems = new();
    private PaymentMethod? _paymentMethod;

    // 私有构造函数，禁止外部直接实例化
    private Order() {}

    // 私有方法：添加订单项
    private void AddOrderItem(OrderItem item)
    {
        _orderItems.Add(item);
        // 可选：触发OrderItemAdded领域事件
    }

    // 私有方法：设置支付方式
    private void SetPaymentMethod(PaymentMethod method)
    {
        _paymentMethod = method;
        // 可选：触发PaymentMethodSet领域事件
    }

    // 内部验证方法，供工厂调用
    internal bool IsValid()
    {
        return _orderItems.Any() && _paymentMethod != null;
    }

    // 暴露只读属性给外部查询
    public IReadOnlyList<OrderItem> OrderItems => _orderItems.AsReadOnly();
    public PaymentMethod? PaymentMethod => _paymentMethod;
}

// 订单工厂，负责订单的草稿创建、修改和最终校验
public class OrderFactory
{
    private Order? _draftOrder;

    // 创建订单草稿
    public OrderFactory CreateDraft()
    {
        _draftOrder = new Order();
        return this;
    }

    // 添加订单项（链式调用）
    public OrderFactory AddItem(OrderItem item)
    {
        _draftOrder?.AddOrderItem(item);
        return this;
    }

    // 设置支付方式（链式调用）
    public OrderFactory SetPayment(PaymentMethod method)
    {
        _draftOrder?.SetPaymentMethod(method);
        return this;
    }

    // 完成订单：验证通过后返回合法Order实例
    public Order Finalize()
    {
        if (_draftOrder == null || !_draftOrder.IsValid())
        {
            throw new InvalidOperationException("订单必须至少包含一个订单项并设置支付方式");
        }

        // 触发OrderCreated领域事件
        _draftOrder.AddDomainEvent(new OrderCreatedDomainEvent(_draftOrder));
        return _draftOrder;
    }
}

// 正确使用方式
var orderFactory = new OrderFactory();
var validOrder = orderFactory.CreateDraft()
                            .AddItem(new OrderItem("商品A", 99))
                            .SetPayment(new PaymentMethod("支付宝"))
                            .Finalize();

_orderRepository.Save(validOrder); // 合法操作

// 违规操作会被阻止：编译期无法直接实例化Order
// var invalidOrder = new Order(); // 编译错误

问题2：通过OrderCreated事件处理器做保存前验证是否更优？ #

这种方案属于事后验证：在OrderCreated事件触发后，由ValidatorOrderCreatedDomainEventHandler在仓储保存前检查约束。但它并非更优方案，原因如下：

1. 无法在编译期阻止违规操作：开发人员依然可以直接实例化Order并触发OrderCreated事件，绕过约束检查。
2. 运行时校验的滞后性：订单已经被创建（甚至可能处于中间状态），才抛出异常，增加了业务逻辑的不确定性。
3. 依赖外部处理器：需要确保事件处理器被正确注册，否则约束依然会被破坏。

最佳方案选择 #

工厂模式是强制Order聚合根不变量的最佳方案，理由：

1. 编译期防护：通过私有构造函数和私有修改方法，从语法层面阻止外部直接创建或修改不符合约束的Order，彻底避免违规操作。
2. 约束前置验证：在订单"完成"阶段就校验所有不变量，只有合法的订单才会被交付给仓储，保证聚合根的一致性。
3. 符合DDD设计原则：聚合根的内部状态由自身和工厂共同维护，无需依赖外部服务，保持了聚合根的封装性和自治性。

内容的提问来源于stack exchange，提问作者user2484998