Go错误处理最佳实践

错误处理是构建健壮应用程序的关键环节。Go语言采用了独特的错误处理机制，既不同于传统的异常机制，也不仅是简单的错误码返回。本文将深入探讨Go语言错误处理的各种高级技巧和工程实践。

一、错误基础与处理模式

1. 基本错误处理

func basicErrorHandling() {
    // 创建简单错误
    err := errors.New("something went wrong")
    fmt.Println(err)

    // 带格式的错误
    err = fmt.Errorf("input error: %s", "invalid format")
    fmt.Println(err)

    // 常见的错误处理模式
    if err := doSomething(); err != nil {
        log.Printf("operation failed: %v", err)
        return // 或者继续处理
    }
}

func doSomething() error {
    return fmt.Errorf("simulated error")
}

2. 错误类型断言

type InputError struct {
    Field string
    Msg   string
}

func (e *InputError) Error() string {
    return fmt.Sprintf("invalid input field %q: %s", e.Field, e.Msg)
}

func errorTypeAssertion() {
    err := validateInput("")

    // 类型断言方式1: type switch
    switch e := err.(type) {
    case *InputError:
        fmt.Printf("Field %s has error: %s\n", e.Field, e.Msg)
    case nil:
        // 没有错误
    default:
        fmt.Println("unexpected error:", e)
    }

    // 类型断言方式2: errors.As
    var inputErr *InputError
    if errors.As(err, &inputErr) {
        fmt.Printf("As: Field %s has error: %s\n", 
            inputErr.Field, inputErr.Msg)
    }
}

func validateInput(input string) error {
    if input == "" {
        return &InputError{
            Field: "input",
            Msg:   "cannot be empty",
        }
    }
    return nil
}

二、错误包装与解包

1. 错误包装技巧

func errorWrapping() {
    if err := processData(); err != nil {
        // 包装错误添加上下文
        wrappedErr := fmt.Errorf("data processing failed: %w", err)
        log.Println(wrappedErr)

        // 解包原始错误
        if originalErr := errors.Unwrap(wrappedErr); originalErr != nil {
            fmt.Println("Original error:", originalErr)
        }

        // 判断错误链中是否包含特定错误
        if errors.Is(wrappedErr, ErrInvalidInput) {
            fmt.Println("Error is an invalid input error")
        }
    }
}

var ErrInvalidInput = errors.New("invalid input")

func processData() error {
    if err := validateInput(""); err != nil {
        return fmt.Errorf("validation failed: %w", err)
    }
    return nil
}

2. 多级错误解包

type DetailedError struct {
    Code    int
    Message string
    Err     error
}

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

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

func multiLevelUnwrap() {
    err := &DetailedError{
        Code:    404,
        Message: "resource not found",
        Err:     os.ErrNotExist,
    }

    // 使用errors.Is检查错误链
    if errors.Is(err, os.ErrNotExist) {
        fmt.Println("Original error is os.ErrNotExist")
    }

    // 使用errors.As提取特定错误类型
    var detailed *DetailedError
    if errors.As(err, &detailed) {
        fmt.Printf("Error code: %d, message: %s\n", 
            detailed.Code, detailed.Message)
    }
}

三、错误分级策略

1. 错误分级标准

const (
    // 级别定义
    SeverityCritical = iota
    SeverityHigh
    SeverityMedium
    SeverityLow
)

type ClassifiedError struct {
    Err      error
    Severity int
}

func (e *ClassifiedError) Error() string {
    return fmt.Sprintf("[Severity %d] %v", e.Severity, e.Err)
}

func errorClassification() {
    err := &ClassifiedError{
        Err:      fmt.Errorf("database connection failed"),
        Severity: SeverityCritical,
    }

    handleError(err)
}

func handleError(err error) {
    var classified *ClassifiedError
    if !errors.As(err, &classified) {
        classified = &ClassifiedError{
            Err:      err,
            Severity: SeverityMedium, // 默认级别
        }
    }

    switch classified.Severity {
    case SeverityCritical:
        log.Fatal("Critical error:", err) // 终止程序
    case SeverityHigh:
        log.Println("High severity error:", err)
        // 告警通知等
    default:
        log.Println("Error occurred:", err)
    }
}

2. 可恢复错误处理

func recoverableErrorHandling() {
    if err := retryOperation(3, doUnstableWork); err != nil {
        log.Fatal("Operation failed after retries:", err)
    }
}

func retryOperation(attempts int, op func() error) (err error) {
    for i := 0; i < attempts; i++ {
        if err = op(); err == nil {
            return nil
        }
        log.Printf("Attempt %d failed: %v", i+1, err)
        time.Sleep(time.Second * time.Duration(i+1))
    }
    return fmt.Errorf("after %d attempts: %w", attempts, err)
}

func doUnstableWork() error {
    // 模拟不稳定操作
    if rand.Intn(5) == 0 {
        return nil
    }
    return fmt.Errorf("temporary failure")
}

四、错误日志记录

1. 结构化错误日志

type LoggableError struct {
    Err        error
    Timestamp  time.Time
    Context    map[string]interface{}
    StackTrace string
}

func (e *LoggableError) Error() string {
    return e.Err.Error()
}

func loggableErrorExample() {
    if err := processRequest(); err != nil {
        logError(err)
    }
}

func processRequest() error {
    return &LoggableError{
        Err:       fmt.Errorf("invalid request format"),
        Timestamp: time.Now(),
        Context: map[string]interface{}{
            "request_id":   12345,
            "client_ip":    "192.168.1.100",
            "request_path": "/api/data",
        },
        StackTrace: string(debug.Stack()),
    }
}

func logError(err error) {
    var logErr *LoggableError
    if errors.As(err, &logErr) {
        log.Printf("ERROR: %v\nContext: %+v\nStack: %s\n", 
            logErr.Err, logErr.Context, logErr.StackTrace)
    } else {
        log.Printf("ERROR: %v\n", err)
    }
}

2. 错误追踪集成

func traceableErrorExample() {
    ctx := context.Background()

    // 创建trace provider
    tp := sdktrace.NewTracerProvider(
        sdktrace.WithSampler(sdktrace.AlwaysSample()),
    )
    defer tp.Shutdown(context.Background())

    otel.SetTracerProvider(tp)
    tracer := tp.Tracer("example")

    ctx, span := tracer.Start(ctx, "operation")
    defer span.End()

    if err := businessOperation(ctx); err != nil {
        span.RecordError(err)
        log.Println("Operation failed:", err)
    }
}

func businessOperation(ctx context.Context) error {
    if rand.Intn(2) == 0 {
        return fmt.Errorf("business logic failed")
    }
    return nil
}

五、panic/recover机制

1. 合理使用panic

func panicRecoverUsage() {
    defer func() {
        if r := recover(); r != nil {
            log.Println("Recovered from panic:", r)
            debug.PrintStack()
        }
    }()

    // 应该panic的情景：无法恢复的编程错误
    if val := criticalLookup(); val == nil {
        panic("nil value from critical lookup")
    }
}

func criticalLookup() interface{} {
    return nil
}

2. HTTP服务中的panic恢复

func panicRecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if err := recover(); err != nil {
                log.Printf("Recovered panic: %v\n%s", 
                    err, debug.Stack())

                http.Error(w, "Internal Server Error", 
                    http.StatusInternalServerError)
            }
        }()

        next.ServeHTTP(w, r)
    })
}

func serverWithPanicProtection() {
    mux := http.NewServeMux()
    mux.HandleFunc("/panic", func(w http.ResponseWriter, r *http.Request) {
        panic("simulated handler panic")
    })

    protected := panicRecoveryMiddleware(mux)
    log.Fatal(http.ListenAndServe(":8080", protected))
}

六、错误处理工具链

1. 静态分析工具

# 使用errcheck检查未处理的错误
go install github.com/kisielk/errcheck@latest
errcheck ./...

# 使用go vet分析错误处理模式
go vet ./...

# 自定义分析工具示例检查错误是否被包装
package main

import (
    "go/ast"
    "golang.org/x/tools/go/analysis"
    "golang.org/x/tools/go/analysis/singlechecker"
)

var Analyzer = &analysis.Analyzer{
    Name: "errorwrapcheck",
    Doc:  "检查是否所有错误都正确包装",
    Run:  run,
}

func run(pass *analysis.Pass) (interface{}, error) {
    for _, file := range pass.Files {
        ast.Inspect(file, func(n ast.Node) bool {
            // 检测fmt.Errorf调用是否包含%w
            return true
        })
    }
    return nil, nil
}

func main() {
    singlechecker.Main(Analyzer)
}

2. 错误处理lint规则

# 使用golangci-lint检查错误处理
golangci-lint run --enable-all --disable=lll

# .golangci.yml配置示例
linters-settings:
    gocritic:
        enabled-tags:
            - diagnostic
            - experimental
            - opinionated
            - style
        settings:
            errorWrapf: 
                checkWrap: true

linters:
    enable:
        - gocritic
        - errcheck

预告：Go性能优化深度解析

在掌握了错误处理最佳实践后，下一期我们将深入Go程序的性能优化世界：

《Go性能优化深度解析》内容预告：

• 性能分析基础：pprof工具链的全面使用
• 内存优化技巧：减少分配与高效复用策略
• 并发性能瓶颈：识别和解决常见并发效率问题
• 编译器优化：了解Go编译器的优化边界
• 汇编分析：解读Go生成的汇编代码
• 高级优化技术：SIMD指令与平台特定优化

这些性能优化技术将帮助您构建极致高效的Go应用程序！