2. Go领域驱动设计基础：DDD核心概念、实体与值对象、聚合与聚合根

领域驱动设计（Domain-Driven Design，DDD）为调度系统提供了从业务复杂度到代码结构的映射方法论。在Go语言中，DDD的边界划分与调度索引的“领域边界”概念高度契合——调度系统中的任务、队列、资源、策略等核心概念，都可以通过DDD的战术模式进行精确建模。

2.1 DDD核心概念：从问题空间到解空间

DDD将软件设计分为两个空间：问题空间（业务需求）和解空间（技术实现）。调度系统的领域专家关注“任务如何被调度执行”，而开发人员需要将这些业务规则转化为可维护的代码。

DDD概念 调度系统映射 Go实现要点
领域 任务调度全生命周期 独立的 scheduling 包
子域 任务管理、队列管理、资源管理 按子域拆分 internal/ 模块
限界上下文 调度引擎 vs 监控告警 通过接口隔离，避免循环依赖
通用语言 Task、Queue、Worker、Schedule 代码中的命名与业务术语一致
调度实践提示：在Go项目中，限界上下文通常对应一个顶级包。例如 pkg/scheduler/ 和 pkg/monitor/ 各自拥有独立的领域模型，通过事件或RPC通信，避免领域概念混淆。

2.2 实体与值对象：调度模型的基本构件

实体（Entity）和值对象（Value Object）是DDD中最基础的战术模式。在调度系统中，正确区分二者直接影响数据一致性和性能。

2.2.1 实体：具有唯一标识的可变对象

实体拥有唯一标识，其属性可以变化，但身份保持不变。调度系统中的典型实体包括：

  • Task（任务）：每个任务有唯一的 TaskID，状态从 Pending 变为 Running 再变为 Completed，但始终是同一个任务。
  • Worker（工作节点）：节点ID不变，但健康状态、负载指标会动态更新。
  • Schedule（调度计划）：Cron表达式或触发规则可以修改，但计划ID保持不变。
// Go实体示例：Task
type Task struct {
    ID          TaskID    // 值对象作为标识
    Type        TaskType
    Payload     []byte
    Status      TaskStatus
    Priority    int
    CreatedAt   time.Time
    UpdatedAt   time.Time
}

func (t *Task) ChangeStatus(newStatus TaskStatus) error {
    // 实体行为：状态变更校验
    if !t.Status.CanTransitionTo(newStatus) {
        return ErrInvalidStatusTransition
    }
    t.Status = newStatus
    t.UpdatedAt = time.Now()
    return nil
}

2.2.2 值对象：不可变且无标识的描述性对象

值对象描述实体的属性，没有唯一标识，通过所有属性值来定义相等性。在调度系统中，值对象用于封装不可变的数据结构：

  • TaskID：UUID或Snowflake ID，作为Task实体的标识。
  • ResourceRequirement：CPU、内存、磁盘需求，两个需求相同的对象可互换。
  • TimeRange：任务的执行时间窗口，不可变。
  • RetryPolicy：重试次数、间隔、退避策略。
// Go值对象示例：ResourceRequirement
type ResourceRequirement struct {
    CPU     float64 // 核心数
    MemoryMB int64
    DiskMB  int64
}

// 值对象应实现相等性比较
func (r ResourceRequirement) Equals(other ResourceRequirement) bool {
    return r.CPU == other.CPU &&
        r.MemoryMB == other.MemoryMB &&
        r.DiskMB == other.DiskMB
}

// 值对象应提供工厂方法，避免零值问题
func NewResourceRequirement(cpu float64, memMB, diskMB int64) (ResourceRequirement, error) {
    if cpu <= 0 || memMB <= 0 || diskMB <= 0 {
        return ResourceRequirement{}, ErrInvalidResource
    }
    return ResourceRequirement{CPU: cpu, MemoryMB: memMB, DiskMB: diskMB}, nil
}
实体 vs 值对象决策表：
判断标准 实体 值对象
是否有唯一标识 是（TaskID） 否
是否可变 是（状态变更） 否（不可变）
相等性依据 标识相等 所有属性相等
生命周期 独立管理 依附于实体
调度示例 Task, Worker, Schedule TaskID, ResourceReq, TimeRange

2.3 聚合与聚合根：调度一致性的边界守卫

聚合（Aggregate）是DDD中最重要的一致性边界。一个聚合是一组相关对象的集合，外部只能通过聚合根（Aggregate Root）访问聚合内的对象。在调度系统中，聚合保证了任务状态变更、资源分配等操作的原子性。

2.3.1 聚合的设计原则

  • 一致性边界：聚合内的所有对象必须保持业务一致性，一个事务只修改一个聚合。
  • 聚合根作为唯一入口：外部不能直接修改聚合内的实体或值对象，必须通过聚合根的方法。
  • 引用通过标识：聚合之间通过ID引用，而不是直接持有对象引用。

2.3.2 调度系统中的典型聚合

聚合 聚合根 内部对象 一致性规则
任务执行聚合 TaskExecution Task, ExecutionLog, RetryRecord 任务状态与重试次数必须同步
队列聚合 Queue QueueConfig, QueueMetrics 队列容量与待处理任务数一致
调度计划聚合 Schedule ScheduleRule, LastRunInfo 下次触发时间必须基于当前时间计算 
// Go聚合根示例：TaskExecution
type TaskExecution struct {
    task        *Task              // 聚合内的实体
    logs        []ExecutionLog     // 值对象集合
    retryRecord *RetryRecord       // 值对象
}

// 聚合根提供业务方法，保证一致性
func (te *TaskExecution) Execute(workerID WorkerID) error {
    if te.task.Status != TaskStatusPending {
        return ErrTaskNotPending
    }
    // 1. 更新任务状态
    te.task.ChangeStatus(TaskStatusRunning)
    // 2. 记录执行日志
    te.logs = append(te.logs, ExecutionLog{
        WorkerID:  workerID,
        StartedAt: time.Now(),
    })
    // 3. 重置重试记录
    te.retryRecord = NewRetryRecord()
    return nil
}

// 外部只能通过聚合根ID引用
type TaskExecutionID struct {
    TaskID TaskID
    RunID  string
}
常见陷阱：在Go中，开发者容易将聚合设计得过大，导致一个事务锁定过多数据。调度系统应遵循“小聚合”原则——例如将“任务执行”和“任务调度”拆分为两个聚合，通过领域事件协调，而不是放在一个巨型聚合中。

2.4 调度索引中的领域边界：DDD与Go的融合

调度索引的核心思想是“通过索引快速定位调度边界”，这与DDD的限界上下文和聚合边界高度一致。在Go中，我们可以通过包结构和接口设计来体现这些边界：

调度索引中的DDD领域边界（Go包结构） 限界上下文：调度引擎 pkg/scheduler/ 聚合：TaskExecution TaskExecution（根） ├─ Task（实体） ├─ ExecutionLog（值对象） └─ RetryRecord（值对象） 聚合：Queue Queue（根） ├─ QueueConfig（值对象） └─ QueueMetrics（值对象） 限界上下文：监控告警 pkg/monitor/ 聚合：AlertRule AlertRule（根） ├─ RuleCondition（值对象） └─ Notification（值对象） 聚合：EventStream EventStream（根） ├─ Event（实体） └─ EventFilter（值对象） 领域事件 调度索引映射 每个聚合对应一个调度索引表，聚合根ID作为索引主键 task_execution_index task_id (PK) run_id (PK) status worker_id queue_index queue_id (PK) name capacity pending_count alert_rule_index rule_id (PK) severity enabled last_triggered

2.5 领域事件：聚合间的异步协调

当聚合内的状态变更需要通知其他聚合时，使用领域事件（Domain Event）进行异步协调。在调度系统中，这是实现解耦的关键机制：

  • TaskExecutionCompleted：任务执行聚合发布，队列聚合监听后更新待处理计数。
  • WorkerHeartbeatTimeout：监控聚合发布，调度引擎监听后重新分配任务。
  • ScheduleTriggered：调度计划聚合发布，任务执行聚合监听后创建新任务。
// Go领域事件示例
type TaskExecutionCompleted struct {
    TaskID    TaskID
    RunID     string
    Status    TaskStatus
    CompletedAt time.Time
}

// 事件发布（在聚合根方法中）
func (te *TaskExecution) Complete() error {
    if te.task.Status != TaskStatusRunning {
        return ErrTaskNotRunning
    }
    te.task.ChangeStatus(TaskStatusCompleted)
    // 发布领域事件
    te.eventPublisher.Publish(TaskExecutionCompleted{
        TaskID:      te.task.ID,
        RunID:       te.retryRecord.RunID,
        Status:      te.task.Status,
        CompletedAt: time.Now(),
    })
    return nil
}
Go实现建议：使用接口定义事件发布器，避免直接依赖消息队列。在单元测试中注入mock事件发布器，验证事件是否按预期发布。推荐使用 github.com/uber-go/fx 或 google/wire 进行依赖注入。

2.6 小结：DDD为调度索引提供领域边界

通过DDD的战术模式，调度系统可以清晰地划分出：

  1. 实体：Task、Worker、Schedule——具有唯一标识，状态可变。
  2. 值对象：TaskID、ResourceRequirement、TimeRange——不可变，描述属性。
  3. 聚合：TaskExecution、Queue、AlertRule——一致性边界，通过聚合根访问。
  4. 限界上下文：调度引擎、监控告警——通过领域事件通信。
← 上一章 📖 返回目录 下一章 →