3. Go语言中的DDD实践

在Go语言中实践领域驱动设计（DDD），核心在于利用Go的结构体（struct）和接口（interface）来精确表达领域概念。本章将深入讲解如何使用Go结构体实现实体（Entity）、值对象（Value Object）以及聚合根（Aggregate Root），并提供可直接落地的代码示例与设计模式。

3.1 实体（Entity）的Go实现

实体具有唯一标识符（ID），其属性可以变化，但身份贯穿生命周期。在Go中，实体通常由一个包含ID字段的结构体表示，并通过方法封装行为。

3.1.1 实体结构体定义

// User 用户实体
type User struct {
    ID        UserID   // 值对象作为ID
    Name      string
    Email     string
    CreatedAt time.Time
    UpdatedAt time.Time
}

// UserID 用户ID值对象
type UserID struct {
    Value string
}

// NewUserID 创建新的用户ID
func NewUserID() UserID {
    return UserID{Value: uuid.New().String()}
}

// Equals 比较两个UserID是否相等
func (id UserID) Equals(other UserID) bool {
    return id.Value == other.Value
}

3.1.2 实体行为封装

// ChangeEmail 修改用户邮箱（实体行为）
func (u *User) ChangeEmail(newEmail string) error {
    if !isValidEmail(newEmail) {
        return errors.New("invalid email format")
    }
    u.Email = newEmail
    u.UpdatedAt = time.Now()
    // 可在此触发领域事件
    return nil
}

// IsSameAs 判断两个用户实体是否相同（基于ID）
func (u *User) IsSameAs(other *User) bool {
    return u.ID.Equals(other.ID)
}

3.2 值对象（Value Object）的Go实现

值对象通过属性值定义自身，不可变（Immutable），且没有唯一标识。两个值对象相等当且仅当它们的所有属性都相等。

3.2.1 值对象结构体定义

// Money 金额值对象
type Money struct {
    amount   decimal.Decimal
    currency string
}

// NewMoney 创建金额值对象（包含验证）
func NewMoney(amount decimal.Decimal, currency string) (Money, error) {
    if amount.IsNegative() {
        return Money{}, errors.New("amount cannot be negative")
    }
    if len(currency) != 3 {
        return Money{}, errors.New("currency must be ISO 4217 code")
    }
    return Money{amount: amount, currency: currency}, nil
}

// Add 加法运算（返回新对象，保持不可变）
func (m Money) Add(other Money) (Money, error) {
    if m.currency != other.currency {
        return Money{}, errors.New("currency mismatch")
    }
    newAmount := m.amount.Add(other.amount)
    return Money{amount: newAmount, currency: m.currency}, nil
}

// Equals 值比较
func (m Money) Equals(other Money) bool {
    return m.amount.Equal(other.amount) && m.currency == other.currency
}

3.2.2 值对象与实体的对比

3.3 聚合根（Aggregate Root）的设计模式

聚合根是聚合（Aggregate）的入口点，负责维护聚合内部的一致性边界。外部只能通过聚合根来操作聚合内的实体和值对象。

3.3.1 聚合根结构体定义

// Order 订单聚合根
type Order struct {
    ID          OrderID
    CustomerID  CustomerID
    Items       []OrderItem      // 聚合内的实体
    TotalAmount Money            // 值对象
    Status      OrderStatus
    Version     int              // 乐观锁版本号
    events      []DomainEvent    // 待发布的领域事件
}

// OrderItem 订单项（聚合内的实体）
type OrderItem struct {
    ProductID ProductID
    Quantity  int
    UnitPrice Money
}

// NewOrder 创建订单聚合根（工厂方法）
func NewOrder(customerID CustomerID) (*Order, error) {
    order := &Order{
        ID:         NewOrderID(),
        CustomerID: customerID,
        Items:      make([]OrderItem, 0),
        Status:     OrderStatusPending,
        Version:    1,
    }
    // 记录领域事件
    order.AddEvent(OrderCreatedEvent{
        OrderID:    order.ID,
        CustomerID: customerID,
        CreatedAt:  time.Now(),
    })
    return order, nil
}

3.3.2 聚合根行为方法

// AddItem 添加订单项（通过聚合根操作内部实体）
func (o *Order) AddItem(productID ProductID, quantity int, unitPrice Money) error {
    if o.Status != OrderStatusPending {
        return errors.New("can only add items to pending order")
    }
    item := OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        UnitPrice: unitPrice,
    }
    o.Items = append(o.Items, item)
    o.recalculateTotal()
    o.Version++
    o.AddEvent(OrderItemAddedEvent{
        OrderID:   o.ID,
        ProductID: productID,
        Quantity:  quantity,
    })
    return nil
}

// Submit 提交订单（聚合根行为）
func (o *Order) Submit() error {
    if o.Status != OrderStatusPending {
        return errors.New("order already submitted")
    }
    if len(o.Items) == 0 {
        return errors.New("cannot submit empty order")
    }
    o.Status = OrderStatusSubmitted
    o.Version++
    o.AddEvent(OrderSubmittedEvent{
        OrderID: o.ID,
        Total:   o.TotalAmount,
    })
    return nil
}

// recalculateTotal 重新计算总金额（私有方法）
func (o *Order) recalculateTotal() {
    total := decimal.Zero
    for _, item := range o.Items {
        itemTotal := item.UnitPrice.amount.Mul(decimal.NewFromInt(int64(item.Quantity)))
        total = total.Add(itemTotal)
    }
    o.TotalAmount, _ = NewMoney(total, "CNY")
}

3.3.3 领域事件管理

// AddEvent 添加领域事件到待发布列表
func (o *Order) AddEvent(event DomainEvent) {
    o.events = append(o.events, event)
}

// PullEvents 拉取并清空待发布事件
func (o *Order) PullEvents() []DomainEvent {
    events := o.events
    o.events = nil
    return events
}

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

3.4 聚合根设计模式SVG图

3.5 聚合根与仓储的协作

仓储（Repository）负责聚合根的持久化与重建。在事件溯源（Event Sourcing）场景下，仓储通过事件流重建聚合根状态。

// OrderRepository 订单仓储接口
type OrderRepository interface {
    Save(ctx context.Context, order *Order) error
    FindByID(ctx context.Context, id OrderID) (*Order, error)
    Delete(ctx context.Context, id OrderID) error
}

// EventStoreOrderRepository 基于事件溯源的仓储实现
type EventStoreOrderRepository struct {
    eventStore EventStore
}

// Save 保存聚合根并发布事件
func (r *EventStoreOrderRepository) Save(ctx context.Context, order *Order) error {
    // 1. 获取待发布事件
    events := order.PullEvents()
    
    // 2. 保存事件到事件存储
    for _, event := range events {
        if err := r.eventStore.Append(ctx, order.ID.String(), event); err != nil {
            return err
        }
    }
    
    // 3. 可选：发布事件到消息总线
    return nil
}

// FindByID 通过事件溯源重建聚合根
func (r *EventStoreOrderRepository) FindByID(ctx context.Context, id OrderID) (*Order, error) {
    // 1. 从事件存储读取所有事件
    events, err := r.eventStore.Load(ctx, id.String())
    if err != nil {
        return nil, err
    }
    
    // 2. 通过事件重建聚合根状态
    order := &Order{ID: id}
    for _, event := range events {
        order.applyEvent(event)
    }
    return order, nil
}

3.6 聚合根设计模式对比

3.7 聚合根设计中的常见陷阱

3.8 完整示例：订单聚合根实战

// 使用示例
func main() {
    // 创建客户ID
    customerID := NewCustomerID()
    
    // 创建订单聚合根
    order, err := NewOrder(customerID)
    if err != nil {
        log.Fatal(err)
    }
    
    // 添加商品
    productID := NewProductID()
    price, _ := NewMoney(decimal.NewFromFloat(99.99), "CNY")
    err = order.AddItem(productID, 2, price)
    if err != nil {
        log.Fatal(err)
    }
    
    // 提交订单
    err = order.Submit()
    if err != nil {
        log.Fatal(err)
    }
    
    // 获取并发布领域事件
    events := order.PullEvents()
    for _, event := range events {
        fmt.Printf("Event: %s at %s\n", event.EventName(), event.OccurredAt())
    }
}