2. Go 基础回顾：接口、错误处理与类型断言

在构建权限审计网关时，接口（interface） 定义了组件间的契约，错误处理（error） 是网关稳定性的基石，而 类型断言（type assertion） 则是实现多态与安全类型转换的核心工具。本章将系统回顾这三个关键语法，为后续实现错误码断言与审计逻辑打下坚实基础。

2.1 接口（interface）—— 抽象与契约

Go 的接口是隐式实现的，只要一个类型实现了接口的所有方法，它就自动满足该接口。这种“鸭子类型”风格让代码更加灵活，特别适合网关中不同后端服务的统一抽象。

2.1.1 接口定义与实现

// 定义一个审计接口
type Auditor interface {
    Audit(req *Request) (*AuditResult, error)
    Name() string
}

// 实现接口的具体类型
type DefaultAuditor struct {
    name string
}

func (d *DefaultAuditor) Audit(req *Request) (*AuditResult, error) {
    // 审计逻辑
    return &AuditResult{Passed: true}, nil
}

func (d *DefaultAuditor) Name() string {
    return d.name
}

2.1.2 空接口与任意类型

interface{}（Go 1.18 后可用 any）可以承载任何类型的值，在错误码断言中常用于接收不确定类型的错误上下文。

var v any = "error_code_1001"
// 后续通过类型断言取出具体值

2.2 错误处理（error）—— 显式与可控

Go 的错误处理哲学是“错误即值”。error 是一个内置接口，只包含一个 Error() string 方法。在网关中，错误处理不仅仅是返回错误，更要携带足够的上下文信息用于审计。

2.2.1 自定义错误类型

// 自定义审计错误，携带错误码
type AuditError struct {
    Code    int    // 错误码，如 1001
    Message string // 人类可读描述
    Detail  string // 详细上下文，用于审计日志
}

func (e *AuditError) Error() string {
    return fmt.Sprintf("[%d] %s: %s", e.Code, e.Message, e.Detail)
}

2.2.2 错误包装与 unwrap

Go 1.13 引入的 %w 和 errors.Is / errors.As 让错误链的检查更加安全。

func ValidateRequest(req *Request) error {
    if req.Token == "" {
        return fmt.Errorf("validate: %w", &AuditError{
            Code:    1001,
            Message: "missing token",
            Detail:  req.Path,
        })
    }
    return nil
}

// 在断言层使用 errors.As 提取自定义错误
var auditErr *AuditError
if errors.As(err, &auditErr) {
    // 使用 auditErr.Code 进行断言
}

2.3 类型断言（type assertion）—— 安全提取与多态

类型断言用于从接口值中提取底层具体值。在错误码断言场景中，我们经常需要从 error 接口中提取自定义错误类型，或从 any 中提取配置参数。

2.3.1 基本语法与安全模式

var e error = &AuditError{Code: 1001, Message: "denied"}

// 不安全断言：如果类型不匹配会 panic
// auditErr := e.(*AuditError)

// 安全断言：使用逗号 ok 模式
if auditErr, ok := e.(*AuditError); ok {
    fmt.Println("错误码:", auditErr.Code)
} else {
    fmt.Println("非预期错误类型")
}

2.3.2 类型 switch —— 多分支断言

当需要根据不同的错误类型执行不同逻辑时，类型 switch 是最清晰的方式。

func HandleError(err error) {
    switch e := err.(type) {
    case *AuditError:
        // 处理审计错误，提取错误码
        fmt.Printf("审计错误码: %d\n", e.Code)
    case *net.OpError:
        // 处理网络错误
        fmt.Println("网络错误:", e.Err)
    default:
        fmt.Println("未知错误:", err)
    }
}

2.4 三者协同：错误码断言的核心模式

在权限审计网关中，接口、错误处理与类型断言三者协同工作，形成以下核心模式：

1. 定义审计错误接口：通过 AuditError 结构体实现 error 接口，携带错误码。
2. 返回错误：审计插件返回 *AuditError 类型的错误。
3. 断言提取：在网关中间件中，使用 errors.As 或类型断言提取错误码。
4. 路由决策：根据错误码决定是否放行、拒绝或记录审计日志。

// 网关中间件中的错误码断言示例
func AuditMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        err := performAudit(r)
        if err != nil {
            var auditErr *AuditError
            if errors.As(err, &auditErr) {
                switch auditErr.Code {
                case 1001:
                    http.Error(w, "Token 缺失", http.StatusUnauthorized)
                case 1002:
                    http.Error(w, "权限不足", http.StatusForbidden)
                case 2001:
                    // 仅记录审计日志，不阻断请求
                    log.Printf("审计警告: %s", auditErr.Detail)
                default:
                    http.Error(w, "内部审计错误", http.StatusInternalServerError)
                }
                return
            }
            // 非审计错误，按通用错误处理
            http.Error(w, err.Error(), http.StatusInternalServerError)
            return
        }
        next.ServeHTTP(w, r)
    })
}

2.5 核心语法对比表

2.6 接口、错误与断言的关系图

2.7 本章小结

• 接口 是网关插件化的基石，通过隐式实现实现松耦合。
• 错误处理 应携带结构化信息（错误码、上下文），而非仅返回字符串。
• 类型断言 是提取错误码的核心手段，务必使用安全模式。
• 三者结合形成了“定义接口 → 返回结构化错误 → 断言提取 → 决策路由”的经典模式，这正是后续章节实现错误码断言网关的核心骨架。