Go HTTP Handler扩展：统一错误处理与中间件链式调用实践

func myHandler(w http.ResponseWriter, r *http.Request) {
    err := doSomething()
    if err != nil {
        serverError(w, r, err, http.StatusInternalServerError) // 重复的错误处理逻辑
        return
    }
    // 业务逻辑
}

package main

import (
    "fmt"
    "log"
    "net/http"
)

// appError 结构体用于封装自定义错误信息，包含HTTP状态码和原始错误
type appError struct {
    Code  int   // HTTP状态码
    Error error // 原始错误
}

// newAppError 是一个辅助函数，用于创建 appError 实例
func newAppError(code int, err error) *appError {
    return &appError{Code: code, Error: err}
}

// appHandler 是一个函数类型，它返回一个 appError，而不是直接处理响应
type appHandler func(http.ResponseWriter, *http.Request) *appError

// ServeHTTP 方法使得 appHandler 实现了 http.Handler 接口
// 所有的错误处理逻辑都集中在此方法中
func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 执行实际的处理器函数，如果返回错误，则进行统一处理
    if e := fn(w, r); e != nil {
        // 根据错误码进行不同的处理
        switch e.Code {
        case http.StatusNotFound:
            // 示例：处理404错误
            http.NotFound(w, r)
        case http.StatusInternalServerError:
            // 示例：处理500错误，并记录日志
            log.Printf("Internal Server Error: %v", e.Error)
            http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        default:
            // 默认错误处理
            log.Printf("Unhandled Error (%d): %v", e.Code, e.Error)
            http.Error(w, e.Error.Error(), e.Code)
        }
    }
}

// use 函数用于链式调用中间件。
// 它接收一个 appHandler 和一系列中间件函数，最终返回一个 http.Handler。
func use(h appHandler, middleware ...func(http.Handler) http.Handler) http.Handler {
    // 将 appHandler 转换为 http.Handler 类型，作为中间件链的起点
    var res http.Handler = h
    // 遍历并应用所有中间件
    for _, m := range middleware {
        res = m(res) // 每个中间件接收前一个处理器的结果，并返回新的处理器
    }
    return res // 返回最终的 http.Handler，可直接注册到路由器
}

// someMiddleware 示例中间件，用于设置响应头
func someMiddleware(h http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        // 在调用下一个处理器之前执行逻辑
        w.Header().Set("Cache-Control", "no-cache, no-store, must-revalidate")
        w.Header().Set("Pragma", "no-cache")
        w.Header().Set("Expires", "0")

        // 调用链中的下一个处理器
        h.ServeHTTP(w, r)
    })
}

// myBusinessHandler 是一个具体的业务处理器，它返回 *appError
func myBusinessHandler(w http.ResponseWriter, r *http.Request) *appError {
    // 模拟一个可能出错的业务操作
    if r.URL.Path == "/error" {
        return newAppError(http.StatusInternalServerError, fmt.Errorf("simulated internal error"))
    }

    name := r.URL.Query().Get("name")
    if name == "" {
        name = "World"
    }

    _, err := fmt.Fprintf(w, "Hello, %s!", name)
    if err != nil {
        return newAppError(http.StatusInternalServerError, err) // 业务逻辑只返回错误
    }

    return nil // 没有错误时返回nil
}

func main() {
    mux := http.NewServeMux()

    // 注册路由，使用 use 函数链式调用中间件
    mux.Handle("/greet", use(myBusinessHandler, someMiddleware))
    mux.Handle("/error", use(myBusinessHandler, someMiddleware)) // 触发模拟错误

    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", mux)
    if err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}