3. Go语言中的领域驱动设计基础

领域驱动设计（DDD）的核心在于用代码精确表达业务概念。在Go语言中，虽然缺少传统面向对象语言的继承和多态机制，但通过结构体、接口和组合模式，可以优雅地实现DDD的四大基础构造块：实体（Entity）、值对象（Value Object）、聚合（Aggregate）和领域事件（Domain Event）。本章将逐一剖析这些概念在Go中的实现模式与边界划分。

3.1 实体（Entity）

实体是具有唯一标识且会随时间变化的对象。在Go中，实体通常由结构体表示，并通过一个不可变的ID字段来区分不同的实例。

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

// UserID 值对象，封装标识的生成与验证
type UserID struct {
    value string
}

func NewUserID() UserID {
    return UserID{value: uuid.New().String()}
}

func (id UserID) String() string {
    return id.value
}

// 实体方法：修改内部状态
func (u *User) ChangeEmail(email string) error {
    if !isValidEmail(email) {
        return errors.New("invalid email format")
    }
    u.Email = email
    u.UpdatedAt = time.Now()
    return nil
}

实体通过指针接收器方法修改自身状态，确保业务逻辑内聚在实体内部。ID使用值对象封装，避免原始类型暴露。

3.2 值对象（Value Object）

值对象通过属性值来定义，没有唯一标识，且不可变。在Go中，值对象通常使用结构体，并暴露工厂函数而非直接暴露字段。

// 地址值对象
type Address struct {
    street   string
    city     string
    zipCode  string
}

func NewAddress(street, city, zipCode string) (Address, error) {
    if street == "" || city == "" || zipCode == "" {
        return Address{}, errors.New("address fields cannot be empty")
    }
    return Address{street: street, city: city, zipCode: zipCode}, nil
}

// 值对象相等性比较：基于所有字段
func (a Address) Equals(other Address) bool {
    return a.street == other.street &&
           a.city == other.city &&
           a.zipCode == other.zipCode
}

// 修改时返回新实例
func (a Address) WithStreet(newStreet string) Address {
    return Address{street: newStreet, city: a.city, zipCode: a.zipCode}
}

值对象常用于描述实体的属性，如金额、日期范围、颜色等。在Go中，值对象应避免暴露可变字段，所有修改操作返回新实例。

3.3 聚合（Aggregate）

聚合是一组相关对象的集合，聚合根（Aggregate Root）是外部访问的唯一入口。在Go中，聚合根通常是一个实体，内部包含其他实体和值对象。

// 订单聚合根
type Order struct {
    ID        OrderID
    customer  CustomerID
    items     []OrderItem
    status    OrderStatus
    createdAt time.Time
}

// 订单项（实体，在聚合内部）
type OrderItem struct {
    ProductID ProductID
    Quantity  int
    Price     Money
}

// 聚合根方法：添加订单项
func (o *Order) AddItem(productID ProductID, quantity int, price Money) error {
    if o.status != OrderStatusPending {
        return errors.New("can only add items to pending orders")
    }
    o.items = append(o.items, OrderItem{
        ProductID: productID,
        Quantity:  quantity,
        Price:     price,
    })
    return nil
}

// 聚合根方法：提交订单
func (o *Order) Submit() error {
    if len(o.items) == 0 {
        return errors.New("order must have at least one item")
    }
    o.status = OrderStatusSubmitted
    return nil
}

聚合通过聚合根封装内部一致性规则，确保业务不变量不被破坏。在Go中，聚合根的方法应返回错误而非panic，保持显式错误处理。

3.4 领域事件（Domain Event）

领域事件记录聚合中发生的业务重要事件，用于解耦聚合之间的通信。在Go中，领域事件通常定义为不可变结构体，并通过事件总线发布。

// 领域事件定义
type OrderSubmitted struct {
    OrderID   OrderID
    CustomerID CustomerID
    SubmittedAt time.Time
    TotalAmount Money
}

// 事件发布接口
type EventPublisher interface {
    Publish(event interface{}) error
}

// 在聚合根中触发事件
func (o *Order) Submit(publisher EventPublisher) error {
    if o.status != OrderStatusPending {
        return errors.New("order already submitted")
    }
    o.status = OrderStatusSubmitted
    // 发布领域事件
    event := OrderSubmitted{
        OrderID:     o.ID,
        CustomerID:  o.customer,
        SubmittedAt: time.Now(),
        TotalAmount: o.calculateTotal(),
    }
    return publisher.Publish(event)
}

3.5 四种构造块对比

3.6 构造块关系图

下图展示了实体、值对象、聚合和领域事件在Go中的协作关系：

3.7 实现注意事项

• 实体ID：使用值对象封装ID，避免原始类型（如string）直接暴露，便于后续修改ID生成策略。
• 值对象不可变性：所有字段小写，通过工厂函数创建，修改操作返回新实例。
• 聚合边界：聚合内部的对象不应暴露给外部，所有操作通过聚合根方法完成。
• 事件发布时机：领域事件应在聚合根方法执行成功后发布，确保事件与状态变更的一致性。
• Go接口设计：使用接口定义事件发布器、仓储等基础设施，便于测试和替换实现。