Go Web开发：优雅地扩展HTTP处理器与集成自定义错误处理及中间件

func myHandler(w http.ResponseWriter, r *http.Request) {
    err := doSomething() // 假设这是一个可能返回错误的操作
    if err != nil {
        serverError(w, r, err, http.StatusInternalServerError) // 自定义错误响应函数
        return
    }
    // 业务逻辑...
}

type appError struct {
    Code int
    Error error
}

type appHandler func(http.ResponseWriter, *http.Request) *appError

func use(h http.HandlerFunc, middleware ...func(http.HandlerFunc) http.HandlerFunc) http.HandlerFunc {
    for _, m := range middleware {
        h = m(h)
    }
    return h
}

package main

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

// appError 结构体用于封装HTTP状态码和实际错误
type appError struct {
    Code  int
    Error error
}

// 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 {
        // 如果处理器返回错误，则进行集中处理
        log.Printf("Handler error: Code %d, Error: %v", e.Code, e.Error)
        switch e.Code {
        case http.StatusNotFound:
            http.NotFound(w, r) // 示例：404错误
        case http.StatusInternalServerError:
            // 示例：500错误，可以返回更友好的错误页面
            http.Error(w, "Internal Server Error", http.StatusInternalServerError)
        default:
            // 默认处理，例如返回通用错误信息
            http.Error(w, fmt.Sprintf("Error: %v", e.Error), e.Code)
        }
    }
}

// 辅助函数：模拟业务逻辑中可能出错的操作
func doSomething() error {
    // 模拟一个错误
    // return errors.New("something went wrong in business logic")
    return nil // 模拟成功
}

// use 函数用于链式应用中间件
// 它接受一个 appHandler 作为初始处理器，并返回一个 http.Handler
func use(h appHandler, middleware ...func(http.Handler) http.Handler) http.Handler {
    var res http.Handler = h // 将 appHandler 转换为 http.Handler 接口类型
    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", "max-age=0, private, must-revalidate")
        w.Header().Set("X-Accel-Expires", "0")
        h.ServeHTTP(w, r) // 调用链中的下一个处理器
    })
}

// myHandler 是一个示例业务处理器，返回 *appError
func myHandler(w http.ResponseWriter, r *http.Request) *appError {
    err := doSomething() // 调用业务逻辑
    if err != nil {
        return &appError{Code: http.StatusInternalServerError, Error: err}
    }

    // 模拟成功响应
    fmt.Fprintf(w, "Hello from myHandler!")
    return nil // 没有错误，返回 nil
}

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

    // 注册路由，使用 use 函数链式应用中间件和自定义处理器
    mux.Handle("/route", use(myHandler, someMiddleware))

    // 启动HTTP服务器
    log.Println("Server starting on :8080")
    err := http.ListenAndServe(":8080", mux)
    if err != nil {
        log.Fatalf("Server failed: %v", err)
    }
}