4. Go 语言 DDD 实践：项目结构布局、分层架构实现与依赖注入

领域驱动设计（DDD）在 Go 中的落地，核心在于项目结构如何映射业务边界、分层如何隔离关注点、以及依赖如何被显式管理。本章从这三个维度展开，给出可直接参考的实践模式。

4.1 Go 项目结构布局：按业务领域组织

传统 Go 项目常按技术层（controllers、models、services）组织，这在 DDD 中会导致业务逻辑分散。推荐按限界上下文（Bounded Context）划分顶层目录，每个上下文内部再按 DDD 分层。

这种布局让每个限界上下文自包含，团队可独立演进。跨上下文的通信通过领域事件或防腐层（ACL）完成，避免直接依赖。

4.2 DDD 分层架构在 Go 中的实现

DDD 经典四层架构（接口层、应用层、领域层、基础设施层）在 Go 中需要适配语言特性。核心原则是：依赖方向由外向内，领域层零外部依赖。

下面是一个典型的领域实体与仓储接口定义：

// internal/report/domain/report.go
package domain

import "time"

type ReportID string

type Report struct {
    ID        ReportID
    Name      string
    Status    ReportStatus
    CreatedAt time.Time
}

type ReportStatus string

const (
    ReportStatusPending  ReportStatus = "pending"
    ReportStatusRunning  ReportStatus = "running"
    ReportStatusComplete ReportStatus = "complete"
)

// ReportRepository 是仓储接口，定义在领域层
type ReportRepository interface {
    Save(report *Report) error
    FindByID(id ReportID) (*Report, error)
    FindAll() ([]*Report, error)
}

应用服务层编排领域对象和基础设施，但不直接依赖具体实现：

// internal/report/application/create_report_handler.go
package application

import (
    "context"
    "report-env-replay/internal/report/domain"
)

type CreateReportCommand struct {
    Name string
}

type CreateReportHandler struct {
    repo domain.ReportRepository // 依赖接口，而非具体实现
}

func NewCreateReportHandler(repo domain.ReportRepository) *CreateReportHandler {
    return &CreateReportHandler{repo: repo}
}

func (h *CreateReportHandler) Handle(ctx context.Context, cmd CreateReportCommand) (*domain.Report, error) {
    report := &domain.Report{
        ID:        domain.ReportID(generateUUID()),
        Name:      cmd.Name,
        Status:    domain.ReportStatusPending,
        CreatedAt: time.Now(),
    }
    return report, h.repo.Save(report)
}

基础设施层实现领域层定义的接口：

// internal/report/infrastructure/mysql_report_repo.go
package infrastructure

import (
    "database/sql"
    "report-env-replay/internal/report/domain"
)

type MySQLReportRepository struct {
    db *sql.DB
}

func NewMySQLReportRepository(db *sql.DB) *MySQLReportRepository {
    return &MySQLReportRepository{db: db}
}

func (r *MySQLReportRepository) Save(report *domain.Report) error {
    // 实现数据库持久化逻辑
    _, err := r.db.Exec("INSERT INTO reports ...", report.ID, report.Name, report.Status)
    return err
}

func (r *MySQLReportRepository) FindByID(id domain.ReportID) (*domain.Report, error) {
    // 实现查询逻辑
    return &domain.Report{}, nil
}

4.3 依赖注入与接口隔离

Go 没有内置 DI 容器，但通过构造函数注入和接口隔离可以优雅地实现依赖管理。核心思想是：依赖倒置——高层模块不依赖低层模块，两者都依赖抽象。

4.3.1 手动依赖注入（推荐）

在 main.go 或 wire.go 中显式组装依赖，避免隐式全局变量：

// cmd/report-service/main.go
package main

import (
    "database/sql"
    "report-env-replay/internal/report/application"
    "report-env-replay/internal/report/infrastructure"
    "report-env-replay/internal/report/interfaces"
)

func main() {
    db, _ := sql.Open("mysql", "dsn")

    // 手动组装依赖链
    reportRepo := infrastructure.NewMySQLReportRepository(db)
    createHandler := application.NewCreateReportHandler(reportRepo)
    httpHandler := interfaces.NewHTTPHandler(createHandler)

    // 启动 HTTP 服务
    httpHandler.RegisterRoutes()
    // ...
}

4.3.2 接口隔离原则（ISP）在 DDD 中的应用

领域层定义的仓储接口应小而专，避免臃肿的“上帝接口”。例如，将读操作和写操作分离：

// 领域层定义两个细粒度接口
type ReportWriter interface {
    Save(report *Report) error
}

type ReportReader interface {
    FindByID(id ReportID) (*Report, error)
    FindAll() ([]*Report, error)
}

// 基础设施层可以同时实现两者，但应用层只依赖所需接口
type ReportRepository interface {
    ReportWriter
    ReportReader
}

这样，应用服务只需注入 ReportWriter 或 ReportReader，而非整个仓储，降低耦合。

4.4 分层架构与依赖流向 SVG 图

下图展示了 DDD 四层架构在 Go 中的依赖关系与数据流向。注意所有箭头指向内层，领域层处于最核心位置。

4.5 依赖注入与接口隔离 SVG 图

下图展示了依赖注入容器如何将接口与实现绑定，以及接口隔离如何避免胖接口污染领域层。

4.6 实践要点与避坑清单