2. DDD 核心概念：通用语言、限界上下文、实体、值对象、聚合、领域事件

领域驱动设计（DDD）提供了一套精密的战术建模工具，用于将复杂的业务逻辑映射到软件实现中。本章将深入剖析 DDD 的六大核心概念，并结合 Go 语言的实现特性，展示如何在微服务架构中落地这些模式。

2.1 通用语言（Ubiquitous Language）

通用语言是 DDD 的基石，它要求开发团队与领域专家使用同一套术语进行沟通，并将这些术语精确地反映在代码、文档和测试中。

• 目标：消除“业务说一套，技术做一套”的鸿沟。
• 载体：代码中的类名、方法名、变量名；事件风暴中的贴纸；用户故事中的描述。
• 原则：术语必须精确、无歧义，且在整个限界上下文中保持一致。

2.2 限界上下文（Bounded Context）

限界上下文是 DDD 的战略核心，它划定了模型应用的边界。每个上下文内部有独立的通用语言和模型，上下文之间通过防腐层（ACL）或开放主机服务（OHS）进行通信。

2.3 实体（Entity）

实体是具有唯一标识且会随时间改变状态的对象。在 Go 中，实体通常通过结构体实现，并显式管理其标识。

// 订单实体：具有唯一标识 OrderID，状态会变化
type Order struct {
    ID        OrderID    // 值对象作为标识
    CustomerID CustomerID
    Items     []OrderItem
    Status    OrderStatus
    CreatedAt time.Time
    UpdatedAt time.Time
}

// 实体行为：封装业务逻辑
func (o *Order) Submit() error {
    if o.Status != OrderStatusPending {
        return ErrInvalidOrderStatus
    }
    o.Status = OrderStatusSubmitted
    o.UpdatedAt = time.Now()
    // 发布领域事件
    o.Events = append(o.Events, OrderSubmittedEvent{OrderID: o.ID})
    return nil
}

2.4 值对象（Value Object）

值对象通过属性值来定义，没有唯一标识，且不可变。在 Go 中，值对象通常不包含指针接收器方法，并通过构造函数保证不变性。

// 值对象：地址，不可变
type Address struct {
    Street   string
    City     string
    ZipCode  string
    Province string
}

// 工厂函数：保证创建时数据有效
func NewAddress(street, city, zipCode, province string) (Address, error) {
    if street == "" || city == "" {
        return Address{}, ErrInvalidAddress
    }
    return Address{
        Street:   street,
        City:     city,
        ZipCode:  zipCode,
        Province: province,
    }, nil
}

// 值对象相等性比较
func (a Address) Equals(other Address) bool {
    return a.Street == other.Street &&
        a.City == other.City &&
        a.ZipCode == other.ZipCode &&
        a.Province == other.Province
}

2.5 聚合（Aggregate）

聚合是一组相关对象的集群，外部只能通过聚合根（Aggregate Root）访问内部对象。聚合保证了数据的一致性和不变性。

• 聚合根：唯一能被外部引用的实体，负责协调内部所有操作。
• 边界：聚合内部对象不能从外部直接修改，必须通过聚合根。
• 事务范围：一个事务只修改一个聚合，避免跨聚合的事务。
• 不变条件：聚合根负责维护内部所有对象的不变规则。

// 聚合根：订单聚合
type Order struct {
    ID        OrderID
    Items     []OrderItem    // 内部实体
    Shipping  Address        // 值对象
    Status    OrderStatus
    Events    []DomainEvent  // 待发布的领域事件
}

// 聚合根方法：添加订单项
func (o *Order) AddItem(productID ProductID, quantity int, unitPrice Money) error {
    if o.Status != OrderStatusPending {
        return ErrCannotModifySubmittedOrder
    }
    if quantity <= 0 {
        return ErrInvalidQuantity
    }
    // 检查是否已存在相同商品
    for i, item := range o.Items {
        if item.ProductID == productID {
            o.Items[i].Quantity += quantity
            o.Items[i].UnitPrice = unitPrice
            return nil
        }
    }
    o.Items = append(o.Items, OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        UnitPrice: unitPrice,
    })
    return nil
}

// 聚合根方法：计算总价
func (o *Order) TotalAmount() Money {
    total := Money{Amount: 0, Currency: "CNY"}
    for _, item := range o.Items {
        total = total.Add(item.Subtotal())
    }
    return total
}

2.6 领域事件（Domain Event）

领域事件表示领域中发生的、领域专家关心的重要事件。它用于解耦聚合之间的通信，是实现事件驱动架构的核心。

// 领域事件接口
type DomainEvent interface {
    EventName() string
    OccurredAt() time.Time
    EventID() string
}

// 具体领域事件：订单已提交
type OrderSubmittedEvent struct {
    OrderID    OrderID
    CustomerID CustomerID
    TotalAmount Money
    Timestamp  time.Time
    ID         string
}

func (e OrderSubmittedEvent) EventName() string {
    return "order.submitted"
}

func (e OrderSubmittedEvent) OccurredAt() time.Time {
    return e.Timestamp
}

func (e OrderSubmittedEvent) EventID() string {
    return e.ID
}

// 在聚合中收集并发布事件
func (o *Order) Submit() error {
    // ... 业务逻辑 ...
    o.Events = append(o.Events, OrderSubmittedEvent{
        OrderID:    o.ID,
        CustomerID: o.CustomerID,
        TotalAmount: o.TotalAmount(),
        Timestamp:  time.Now(),
        ID:         uuid.New().String(),
    })
    return nil
}

2.7 六大概念关系总结

这六个概念并非孤立存在，它们共同构成了 DDD 的战术建模体系。以下表格展示了它们之间的协作关系：