3. Go 语言基础回顾：模块管理、接口与结构体、错误处理、并发模型

在进入权限审计网关的发布回滚实战之前，有必要系统回顾 Go 语言的核心基础。本章聚焦于四个关键领域：模块管理（依赖与版本）、接口与结构体（类型系统与抽象）、错误处理（惯用模式）以及并发模型（goroutine 与 channel）。这些知识将直接支撑后续网关的插件化设计、异步审计日志处理以及优雅重启等高级特性。

3.1 Go 模块管理

Go 从 1.11 版本开始引入 go mod，彻底解决了依赖管理与版本冲突问题。在网关项目中，我们使用 go.mod 文件锁定依赖版本，并通过 go.sum 确保完整性。

3.2 接口与结构体：网关的抽象基石

Go 的接口是隐式实现的，这为网关的插件化架构提供了天然支持。结构体负责承载数据，接口负责定义行为契约。

// 定义审计日志接口
type Auditor interface {
    Record(ctx context.Context, req *Request, resp *Response) error
    Name() string
}

// 具体实现：文件审计
type FileAuditor struct {
    Path string
}

func (f *FileAuditor) Record(ctx context.Context, req *Request, resp *Response) error {
    // 将审计日志写入文件
    return nil
}

func (f *FileAuditor) Name() string { return "file" }

// 具体实现：数据库审计
type DBAuditor struct {
    DSN string
}

func (d *DBAuditor) Record(ctx context.Context, req *Request, resp *Response) error {
    // 将审计日志写入数据库
    return nil
}

func (d *DBAuditor) Name() string { return "db" }

通过接口，网关可以在运行时动态切换审计后端，而无需修改核心路由逻辑。这正是“面向接口编程”在回滚场景中的价值：你可以通过配置快速切换审计实现，而不需要重新编译整个网关。

3.3 错误处理：显式与可控

Go 的错误处理哲学是“显式处理每一个错误”。在网关中，错误处理直接影响审计日志的完整性和回滚决策的准确性。

// 自定义错误类型，携带上下文
type AuditError struct {
    Op      string // 操作名称
    Err     error  // 原始错误
    Code    int    // 业务错误码
}

func (e *AuditError) Error() string {
    return fmt.Sprintf("audit %s failed: %s (code=%d)", e.Op, e.Err, e.Code)
}

func (e *AuditError) Unwrap() error {
    return e.Err
}

// 使用 errors.Is 和 errors.As 进行错误链判断
func handleAudit(ctx context.Context, req *Request) error {
    err := auditor.Record(ctx, req, nil)
    if err != nil {
        var ae *AuditError
        if errors.As(err, &ae) {
            // 根据错误码决定是否触发回滚
            if ae.Code == 503 {
                return fmt.Errorf("service unavailable, trigger rollback: %w", err)
            }
        }
        return fmt.Errorf("audit record failed: %w", err)
    }
    return nil
}

3.4 并发模型：goroutine 与 channel

Go 的并发模型基于 CSP（Communicating Sequential Processes）理论。在网关中，每个请求通常由一个 goroutine 处理，而审计日志的异步写入则通过 channel 进行协调。

// 异步审计日志写入器
type AsyncAuditWriter struct {
    ch      chan *AuditLog
    workers int
}

func NewAsyncAuditWriter(bufferSize int, workers int) *AsyncAuditWriter {
    w := &AsyncAuditWriter{
        ch:      make(chan *AuditLog, bufferSize),
        workers: workers,
    }
    for i := 0; i < workers; i++ {
        go w.worker(i)
    }
    return w
}

func (w *AsyncAuditWriter) worker(id int) {
    for log := range w.ch {
        // 实际写入存储（文件/数据库）
        fmt.Printf("worker %d writing audit log: %+v\n", id, log)
    }
}

func (w *AsyncAuditWriter) Write(log *AuditLog) {
    select {
    case w.ch <- log:
        // 正常入队
    default:
        // 缓冲区满，降级处理（记录到本地日志）
        fmt.Printf("audit channel full, dropping log: %+v\n", log)
    }
}