3. panic 与 recover 机制：何时使用 panic，recover 的陷阱，在中间件中安全捕获 panic

在 Go 并发中间件的接入链路中，panic 与 recover 是错误处理体系的最后一道防线。与常规的 error 返回值不同，panic 会立即中断当前 goroutine 的正常执行流，并沿调用栈向上传播，直到被 recover 捕获或导致进程崩溃。本章将深入剖析 panic 的适用场景、recover 的常见陷阱，以及如何在中间件中构建安全的 panic 捕获机制。

3.1 panic 的适用场景与设计原则

Go 语言的设计哲学强调显式错误处理，但 panic 并非被废弃的机制。在以下场景中，panic 是合理且必要的选择：

3.2 recover 的机制与常见陷阱

recover 是 Go 提供的唯一能拦截 panic 的内建函数。它必须在 defer 函数中直接调用才能生效。以下表格总结了 recover 的常见陷阱及其后果：

3.3 中间件中安全捕获 panic 的实现

在 HTTP 或 RPC 中间件中，panic 捕获是防止单点故障扩散的关键。以下是一个标准的中间件 panic 恢复模式：

func RecoveryMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        defer func() {
            if rec := recover(); rec != nil {
                // 1. 记录 panic 信息与堆栈
                stack := debug.Stack()
                log.Printf("[PANIC] recovered: %v\nstack:\n%s", rec, stack)

                // 2. 返回 500 错误给客户端
                http.Error(w, "Internal Server Error", http.StatusInternalServerError)

                // 3. 可选：上报监控系统
                metrics.IncPanicCount(r.URL.Path)
            }
        }()

        next.ServeHTTP(w, r)
    })
}

对于并发场景，每个 goroutine 都需要独立的 recover 保护：

func handleConcurrentTask(task Task) {
    go func() {
        defer func() {
            if rec := recover(); rec != nil {
                log.Printf("[GOROUTINE PANIC] task %s failed: %v", task.ID, rec)
                // 清理资源，避免泄漏
                task.Cleanup()
            }
        }()

        task.Execute()
    }()
}

3.4 panic 传播与 recover 捕获流程

下图展示了 panic 在中间件调用链中的传播路径，以及 recover 如何拦截并转换为优雅的错误响应：

3.5 中间件 panic 捕获的架构设计

在分布式系统中，中间件层的 panic 捕获需要与链路追踪、熔断降级等机制协同工作。下图展示了 panic 捕获在中间件架构中的位置与数据流：

3.6 实战：构建可配置的 panic 恢复中间件

以下是一个支持自定义恢复逻辑和监控上报的通用 panic 恢复中间件：

type RecoveryOption func(*recoveryConfig)

type recoveryConfig struct {
    logFunc     func(format string, args ...interface{})
    metricsFunc func(path string)
    errorCode   int
}

func WithLogger(logger func(format string, args ...interface{})) RecoveryOption {
    return func(c *recoveryConfig) {
        c.logFunc = logger
    }
}

func WithMetrics(metrics func(path string)) RecoveryOption {
    return func(c *recoveryConfig) {
        c.metricsFunc = metrics
    }
}

func NewRecoveryMiddleware(opts ...RecoveryOption) func(http.Handler) http.Handler {
    config := &recoveryConfig{
        logFunc:     log.Printf,
        metricsFunc: func(path string) {},
        errorCode:   http.StatusInternalServerError,
    }
    for _, opt := range opts {
        opt(config)
    }

    return func(next http.Handler) http.Handler {
        return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
            defer func() {
                if rec := recover(); rec != nil {
                    stack := debug.Stack()
                    config.logFunc("[PANIC] %v | path: %s\nstack:\n%s", rec, r.URL.Path, stack)
                    config.metricsFunc(r.URL.Path)
                    http.Error(w, "Internal Server Error", config.errorCode)
                }
            }()
            next.ServeHTTP(w, r)
        })
    }
}