Go HTTP处理函数预处理：利用包装器实现通用逻辑

package main

import (
    "fmt"
    "net/http"
)

// 模拟获取用户数据的函数
func getUserData(r *http.Request) string {
    // 实际场景中可能从Session、JWT或数据库获取
    fmt.Println("正在获取用户数据...")
    return "用户A的数据"
}

// handler1 需要用户数据
func handler1(w http.ResponseWriter, r *http.Request) {
    userData := getUserData(r) // 重复调用
    fmt.Fprintf(w, "Welcome to /user, %s!\n", userData)
}

// handler2 也需要用户数据
func handler2(w http.ResponseWriter, r *http.Request) {
    userData := getUserData(r) // 重复调用
    fmt.Fprintf(w, "Viewing profile for %s.\n", userData)
}

// handler3 不需要用户数据
func handler3(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Viewing public post.\n")
}

func main() {
    http.HandleFunc("/user", handler1)
    http.HandleFunc("/user/profile", handler2)
    http.HandleFunc("/user/post", handler3)

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

package main

import (
    "fmt"
    "net/http"
    "context" // 用于在请求上下文中传递数据
)

// 定义一个键类型，用于在context中存储数据，避免键冲突
type contextKey string

const userDataKey contextKey = "userData"

// 模拟获取用户数据的函数
func getUserData(r *http.Request) string {
    fmt.Println("正在执行预处理：获取用户数据...")
    // 实际场景中可能从Session、JWT或数据库获取
    // 这里简化为返回一个固定字符串
    return "Alice"
}

// Prehook 是一个HTTP处理函数包装器，用于在实际处理函数之前执行通用逻辑
func Prehook(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 1. 执行预处理逻辑
        data := getUserData(r)

        // 2. 可以将预处理结果存储到请求的Context中，以便后续处理函数访问
        ctx := context.WithValue(r.Context(), userDataKey, data)
        r = r.WithContext(ctx)

        // 3. 调用原始的处理函数
        next(w, r)
    }
}

// handler1 业务逻辑：需要用户数据
func handler1(w http.ResponseWriter, r *http.Request) {
    // 从Context中获取预处理好的用户数据
    userData, ok := r.Context().Value(userDataKey).(string)
    if !ok {
        http.Error(w, "User data not found in context", http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "Welcome to /user, %s!\n", userData)
}

// handler2 业务逻辑：需要用户数据
func handler2(w http.ResponseWriter, r *http.Request) {
    userData, ok := r.Context().Value(userDataKey).(string)
    if !ok {
        http.Error(w, "User data not found in context", http.StatusInternalServerError)
        return
    }
    fmt.Fprintf(w, "Viewing profile for %s.\n", userData)
}

// handler3 业务逻辑：不需要用户数据
func handler3(w http.ResponseWriter, r *http.Request) {
    fmt.Fprintf(w, "Viewing public post.\n")
}

func main() {
    // 将需要预处理的handler包裹在Prehook中
    http.HandleFunc("/user", Prehook(handler1))
    http.HandleFunc("/user/profile", Prehook(handler2))
    // 不需要预处理的handler直接注册
    http.HandleFunc("/user/post", handler3)

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

// LoggerMiddleware 示例：记录请求日志
func LoggerMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        fmt.Printf("[%s] %s %s\n", r.RemoteAddr, r.Method, r.URL.Path)
        next(w, r)
    }
}

// AuthMiddleware 示例：身份验证
func AuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 模拟身份验证逻辑
        if r.Header.Get("X-Auth-Token") != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return
        }
        fmt.Println("执行预处理：身份验证通过")
        next(w, r)
    }
}

func main() {
    // 链式调用中间件：LoggerMiddleware -> Prehook -> AuthMiddleware -> handler
    // 注意调用顺序是从外到内执行，但数据流是先经过最外层中间件
    // 实际执行顺序是：Logger -> Auth -> Prehook -> handler
    http.HandleFunc("/admin", LoggerMiddleware(AuthMiddleware(Prehook(handler1))))
    // ... 其他路由
    fmt.Println("Server listening on :8080")
    http.ListenAndServe(":8080", nil)
}

func AuthMiddleware(next http.HandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        if r.Header.Get("X-Auth-Token") != "valid-token" {
            http.Error(w, "Unauthorized", http.StatusUnauthorized)
            return // 认证失败，直接返回，不再调用next
        }
        next(w, r)
    }
}

// MyMiddleware 实现了 http.Handler 接口
type MyMiddleware struct {
    next http.Handler // 存储下一个处理程序
    // 可以添加其他字段来维护中间件的状态
}

func NewMyMiddleware(next http.Handler) *MyMiddleware {
    return &MyMiddleware{next: next}
}

func (m *MyMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) {
    // 执行预处理逻辑
    fmt.Println("MyMiddleware: Doing some pre-processing.")
    // 调用下一个处理程序
    m.next.ServeHTTP(w, r)
}

// 使用方式
// func main() {
//     myHandler := http.HandlerFunc(handler1) // 将HandlerFunc转换为Handler
//     wrappedHandler := NewMyMiddleware(myHandler)
//     http.Handle("/path", wrappedHandler)
// }