Golang中间件设计与请求处理技巧

http.Handler

http.Handler

http.Handler

func LoggingMiddleware(next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        start := time.Now()
        next.ServeHTTP(w, r) // 请求继续向下传递
        log.Printf("Request: %s %s took %v", r.Method, r.URL.Path, time.Since(start))
    })
}

gorilla/mux

chi

http.HandlerFunc

context.Context

context.WithValue

context.WithValue

r.URL.Query()

r.FormValue()

r.ParseForm()

json.NewDecoder(r.Body).Decode(&data)

r.Body

defer r.Body.Close()

// 简化的JWT验证中间件示例
func JWTAuthMiddleware(secretKey []byte, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        tokenString := r.Header.Get("Authorization")
        if tokenString == "" {
            http.Error(w, "Authorization header required", http.StatusUnauthorized)
            return
        }
        // 通常是 "Bearer <token>"
        if !strings.HasPrefix(tokenString, "Bearer ") {
            http.Error(w, "Invalid Authorization header format", http.StatusUnauthorized)
            return
        }
        tokenString = tokenString[len("Bearer "):]

        token, err := jwt.Parse(tokenString, func(token *jwt.Token) (interface{}, error) {
            // 确保token的签名方法是我们期望的
            if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
                return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
            }
            return secretKey, nil
        })

        if err != nil || !token.Valid {
            http.Error(w, "Invalid or expired token", http.StatusUnauthorized)
            return
        }

        // 将用户ID或其他信息存入Context
        if claims, ok := token.Claims.(jwt.MapClaims); ok {
            ctx := context.WithValue(r.Context(), "userID", claims["user_id"])
            next.ServeHTTP(w, r.WithContext(ctx))
            return
        }
        http.Error(w, "Invalid token claims", http.StatusUnauthorized)
    })
}

map

sync.RWMutex

context.Context

context.Context

func TimeoutMiddleware(timeout time.Duration, next http.Handler) http.Handler {
    return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
        ctx, cancel := context.WithTimeout(r.Context(), timeout)
        defer cancel() // 确保在请求处理结束后释放资源

        // 将新的Context传递给后续的处理器
        next.ServeHTTP(w, r.WithContext(ctx))

        // 检查Context是否被取消（例如超时）
        select {
        case <-ctx.Done():
            if ctx.Err() == context.DeadlineExceeded {
                log.Printf("Request to %s timed out after %v", r.URL.Path, timeout)
                // 已经发送响应，这里可能无法再次发送HTTP错误码
                // 更合理的做法是让业务逻辑检查ctx.Done()并提前返回
            }
        default:
            // 请求正常完成
        }
    })
}

TimeoutMiddleware

ctx.Done()

func myHandler(w http.ResponseWriter, r *http.Request) {
    select {
    case <-r.Context().Done():
        // Context已被取消，可能是超时或客户端断开连接
        log.Printf("Request for %s cancelled: %v", r.URL.Path, r.Context().Err())
        http.Error(w, "Request cancelled or timed out", http.StatusServiceUnavailable)
        return
    default:
        // 继续处理业务逻辑
        time.Sleep(2 * time.Second) // 模拟耗时操作
        if r.Context().Err() != nil { // 再次检查以防在Sleep期间超时
            log.Printf("Request for %s cancelled during processing: %v", r.URL.Path, r.Context().Err())
            http.Error(w, "Request cancelled or timed out", http.StatusServiceUnavailable)
            return
        }
        w.Write([]byte("Hello from myHandler!"))
    }
}

sync.Mutex

sync.RWMutex

context.WithValue