聚合与聚合根：聚合的定义、聚合根的选择原则、实体与值对象的区分

在领域驱动设计中，聚合（Aggregate）是事务一致性的最小边界，而聚合根（Aggregate Root）是访问该边界的唯一入口。支付订单领域对数据一致性要求极高，错误的设计会导致资金差错或订单状态混乱。本节将深入剖析聚合的定义、聚合根的选择原则，以及实体与值对象的本质区别。

1. 聚合的定义与边界

聚合是一组相关对象的集合，这些对象在业务上必须保持事务一致性。聚合外部只能通过聚合根访问内部对象，内部对象之间的引用仅限于聚合内部。

在支付订单上下文中，一个典型的聚合边界示例：

2. 聚合根的选择原则

聚合根是聚合中唯一能被外部访问的对象。选择正确的聚合根是DDD建模的关键步骤。以下是支付订单领域常用的选择原则：

1. 全局标识原则：聚合根必须拥有全局唯一的标识（ID），且该标识在整个系统中可被外部引用。
2. 生命周期原则：聚合根负责管理聚合内所有对象的生命周期，内部对象的创建、修改、删除都必须通过聚合根。
3. 业务不变量原则：聚合根必须确保聚合内的所有业务不变量不被破坏。例如，订单总金额必须等于所有订单项金额之和。
4. 最小化原则：尽量选择业务上最稳定、变化频率最低的对象作为聚合根。
5. 事务边界原则：聚合根的操作范围就是事务的边界，超出该范围的操作应通过领域服务或应用服务协调。

以下SVG图展示了支付订单聚合中聚合根与内部对象的关系：

3. 实体与值对象的区分

实体（Entity）和值对象（Value Object）是DDD中两种最基本的领域对象类型。它们的区分直接决定了聚合内部的结构设计。

4. 支付订单聚合中的实体与值对象设计

以下代码示例展示了支付订单聚合中实体与值对象的Go实现：

// 值对象：金额（不可变）
type Money struct {
    amount   decimal.Decimal
    currency string // ISO 4217 货币代码
}

func NewMoney(amount decimal.Decimal, currency string) Money {
    return Money{amount: amount, currency: currency}
}

func (m Money) Amount() decimal.Decimal { return m.amount }
func (m Money) Currency() string        { return m.currency }

// 值对象相等性比较：所有属性相等即相等
func (m Money) Equals(other Money) bool {
    return m.amount.Equal(other.amount) && m.currency == other.currency
}

// 值对象运算：返回新实例
func (m Money) Add(other Money) (Money, error) {
    if m.currency != other.currency {
        return Money{}, errors.New("currency mismatch")
    }
    return NewMoney(m.amount.Add(other.amount), m.currency), nil
}

// 实体：订单项（拥有局部标识）
type OrderLineItem struct {
    lineItemID string  // 在订单聚合内唯一
    productID  string
    quantity   int
    unitPrice  Money   // 值对象作为属性
}

func NewOrderLineItem(lineItemID, productID string, quantity int, unitPrice Money) *OrderLineItem {
    return &OrderLineItem{
        lineItemID: lineItemID,
        productID:  productID,
        quantity:   quantity,
        unitPrice:  unitPrice,
    }
}

// 实体相等性：通过标识判断
func (item *OrderLineItem) Equals(other *OrderLineItem) bool {
    return item.lineItemID == other.lineItemID
}

// 聚合根：订单
type Order struct {
    orderNo   string           // 全局唯一标识
    items     []*OrderLineItem // 内部实体列表
    total     Money            // 值对象
    status    OrderStatus      // 值对象（枚举）
    createdAt time.Time
}

func NewOrder(orderNo string) *Order {
    return &Order{
        orderNo:   orderNo,
        items:     make([]*OrderLineItem, 0),
        total:     NewMoney(decimal.Zero, "CNY"),
        status:    OrderStatusPending,
        createdAt: time.Now(),
    }
}

// 聚合根方法：添加订单项（维护业务不变量）
func (o *Order) AddItem(productID string, quantity int, unitPrice Money) error {
    lineItemID := fmt.Sprintf("%s-%d", o.orderNo, len(o.items)+1)
    item := NewOrderLineItem(lineItemID, productID, quantity, unitPrice)
    o.items = append(o.items, item)

    // 重新计算总金额（维护不变量）
    newTotal, _ := o.total.Add(unitPrice.Multiply(decimal.NewFromInt(int64(quantity))))
    o.total = newTotal
    return nil
}

5. 聚合设计中的常见陷阱

在支付订单领域，以下陷阱经常导致设计返工：

• 陷阱一：将值对象设计为实体——例如给“金额”加上ID，导致每次金额比较都需要查数据库，增加复杂度且无业务价值。
• 陷阱二：聚合边界过大——将订单、支付、账户、物流全部放在一个聚合中，导致每次订单状态变更都要锁定大量数据，并发性能急剧下降。
• 陷阱三：聚合根选择错误——将“订单项”作为聚合根，导致外部可以直接操作订单项，绕过订单的业务规则（如总金额校验）。
• 陷阱四：忽略值对象的不可变性——在Go中直接修改值对象的字段，导致多个实体共享同一个值对象实例时出现数据污染。

以下SVG图展示了实体与值对象在聚合中的不同角色：