Go HTTP Handler与中间件扩展：优雅处理错误与链式调用

package main

import (
    "fmt"
    "net/http"
)

// appError 封装了应用层面的错误信息
type appError struct {
    Code  int   // HTTP 状态码
    Error error // 实际的错误对象
}

// 可选：添加一个生成 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) {
    // 执行实际的 appHandler 逻辑
    if e := fn(w, r); e != nil {
        // 如果返回了错误，则根据错误码进行统一处理
        switch e.Code {
        case http.StatusNotFound:
            // 示例：自定义的 404 错误处理
            http.NotFound(w, r)
        case http.StatusInternalServerError:
            // 示例：自定义的 500 错误处理，可能包含日志记录、错误页面渲染等
            // 这里简化为 http.Error
            http.Error(w, "Internal Server Error", http.StatusInternalServerError)
            fmt.Printf("Error: %v\n", e.Error) // 打印内部错误
        default:
            // 处理其他自定义错误码
            http.Error(w, fmt.Sprintf("Error: %s", e.Error.Error()), e.Code)
            fmt.Printf("Error with code %d: %v\n", e.Code, e.Error)
        }
    }
}

// use 函数用于链式调用中间件
// 它接受一个 appHandler 作为初始处理器，并接受一系列标准中间件
// 最终返回一个 http.Handler
func use(h appHandler, middleware ...func(http.Handler) http.Handler) http.Handler {
    // 将 appHandler 转换为 http.Handler 接口类型
    // 因为 appHandler 已经实现了 ServeHTTP 方法，所以可以直接赋值给 http.Handler
    var res http.Handler = h

    // 遍历并应用所有中间件
    for _, m := range middleware {
        res = m(res) // 每个中间件都会包装当前的 res
    }

    return res // 返回最终包装好的 http.Handler
}

// myHandler 是一个业务逻辑处理器示例
func myHandler(w http.ResponseWriter, r *http.Request) *appError {
    // 模拟一些可能出错的业务逻辑
    // 例如：数据库操作、外部API调用等
    // 这里简化为一个始终成功的操作
    name := "World"
    _, err := fmt.Fprintf(w, "Hello, %s!\n", name)
    if err != nil {
        // 如果发生错误，返回一个 appError
        return newAppError(http.StatusInternalServerError, fmt.Errorf("failed to write response: %w", err))
    }

    // 模拟一个可能返回错误的场景
    // if r.URL.Path == "/error" {
    //  return newAppError(http.StatusBadRequest, fmt.Errorf("simulated bad request"))
    // }

    return nil // 成功时返回 nil
}

// 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")
        w.Header().Set("X-Custom-Header", "Middleware-Applied")

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

        // 在调用下一个处理器之后执行操作（如果需要）
        fmt.Println("someMiddleware finished processing for:", r.URL.Path)
    })
}

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

    // 注册路由，使用 use 函数链式调用 myHandler 和 someMiddleware
    mux.Handle("/hello", use(myHandler, someMiddleware))

    // 示例：一个不带中间件的 appHandler
    mux.Handle("/simple", appHandler(func(w http.ResponseWriter, r *http.Request) *appError {
        if r.URL.Path == "/simple/error" {
            return newAppError(http.StatusBadRequest, fmt.Errorf("this is a simulated simple error"))
        }
        fmt.Fprintf(w, "This is a simple handler without middleware.\n")
        return nil
    }))

    fmt.Println("Server listening on :8080")
    http.ListenAndServe(":8080", mux)
}