Golang HTTP中间件统一错误处理方法

通过定义包含状态码、消息和详情的AppError结构体，可在中间件中统一处理并记录含请求信息的错误日志，实现对数据库、API等不同错误类型的分类响应与日志输出。

在Golang的HTTP中间件中统一处理请求错误，主要是为了避免在每个handler中重复编写错误处理逻辑，提高代码的可维护性和可读性。核心思路是创建一个中间件，它接收一个handler作为参数，并在执行handler后检查是否发生了错误，如果发生错误，则进行统一处理。

解决方案：

package main

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

// AppError 定义一个自定义错误类型，包含状态码和错误信息
type AppError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
}

// Error 实现 error 接口
func (e *AppError) Error() string {
    return e.Message
}

// ErrorHandlerFunc 定义一个返回错误的 handler 函数类型
type ErrorHandlerFunc func(w http.ResponseWriter, r *http.Request) error

// Middleware 错误处理中间件
func Middleware(next ErrorHandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 执行 handler 函数并捕获错误
        err := next(w, r)
        if err != nil {
            // 统一错误处理逻辑
            log.Printf("Error: %v", err)

            // 根据错误类型进行处理
            var appError *AppError
            switch e := err.(type) {
            case *AppError:
                appError = e
            default:
                appError = &AppError{
                    Code:    http.StatusInternalServerError,
                    Message: "Internal Server Error",
                }
            }

            // 设置响应头
            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(appError.Code)

            // 返回 JSON 格式的错误信息
            fmt.Fprintf(w, `{"error": "%s"}`, appError.Message) // 简化了JSON序列化，实际应用中建议使用json.Marshal
        }
    }
}

// ExampleHandler 示例 handler 函数，可能返回错误
func ExampleHandler(w http.ResponseWriter, r *http.Request) error {
    // 模拟一个错误
    if r.URL.Query().Get("error") == "true" {
        return &AppError{
            Code:    http.StatusBadRequest,
            Message: "Simulated error occurred",
        }
    }

    // 正常处理
    fmt.Fprintln(w, "Hello, World!")
    return nil
}

func main() {
    // 使用中间件包装 handler 函数
    handler := Middleware(ExampleHandler)

    // 注册 handler 函数
    http.HandleFunc("/", handler)

    // 启动服务器
    log.Fatal(http.ListenAndServe(":8080", nil))
}

如何自定义错误类型以提供更详细的错误信息？

在上面的代码中，我们已经定义了一个 AppError 结构体，它包含了状态码和错误信息。你可以根据你的需要，添加更多的字段到 AppError 结构体中，例如：

type AppError struct {
    Code    int    `json:"code"`
    Message string `json:"message"`
    Details interface{} `json:"details,omitempty"` // 可选的错误详情
}

然后，在你的 handler 函数中，你可以创建 AppError 实例，并填充这些字段：

func AnotherExampleHandler(w http.ResponseWriter, r *http.Request) error {
    // 模拟一个错误
    if r.URL.Query().Get("error") == "true" {
        return &AppError{
            Code:    http.StatusBadRequest,
            Message: "Invalid input",
            Details: map[string]interface{}{
                "field":   "username",
                "message": "Username is required",
            },
        }
    }

    // 正常处理
    fmt.Fprintln(w, "Another Hello, World!")
    return nil
}

在中间件中，你需要使用 json.Marshal 将 AppError 序列化为 JSON 字符串，并将其写入响应体。

如何处理不同类型的错误，例如数据库错误、API 调用错误等？

关键在于中间件内部的错误判断和处理逻辑。你可以使用类型断言来判断错误的具体类型，并根据不同的错误类型执行不同的处理逻辑。

func Middleware(next ErrorHandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        err := next(w, r)
        if err != nil {
            log.Printf("Error: %v", err)

            var appError *AppError
            switch e := err.(type) {
            case *AppError:
                appError = e
            case *DatabaseError: // 假设你定义了一个 DatabaseError 类型
                appError = &AppError{
                    Code:    http.StatusInternalServerError,
                    Message: "Database error",
                    Details: e.Error(),
                }
            case *APIError: // 假设你定义了一个 APIError 类型
                appError = &AppError{
                    Code:    http.StatusBadGateway,
                    Message: "API error",
                    Details: e.Error(),
                }
            default:
                appError = &AppError{
                    Code:    http.StatusInternalServerError,
                    Message: "Internal Server Error",
                }
            }

            w.Header().Set("Content-Type", "application/json")
            w.WriteHeader(appError.Code)
            // 实际应用中建议使用 json.Marshal
            fmt.Fprintf(w, `{"error": "%s", "details": "%v"}`, appError.Message, appError.Details)
        }
    }
}

记得定义 DatabaseError 和 APIError 类型，并实现 Error() 方法。

如何在中间件中记录详细的错误日志，包括请求信息、用户信息等？

你可以在中间件中访问 http.Request 对象，并从中提取你需要的信息。例如：

func Middleware(next ErrorHandlerFunc) http.HandlerFunc {
    return func(w http.ResponseWriter, r *http.Request) {
        // 获取请求信息
        requestURL := r.URL.String()
        requestMethod := r.Method
        // 假设你有一个函数可以从请求中提取用户信息
        userID := GetUserIDFromRequest(r)

        err := next(w, r)
        if err != nil {
            // 记录详细的错误日志
            log.Printf("Error: %v, Request URL: %s, Method: %s, User ID: %d", err, requestURL, requestMethod, userID)

            // ... 错误处理逻辑 ...
        }
    }
}

// 假设的函数，用于从请求中提取用户信息
func GetUserIDFromRequest(r *http.Request) int {
    // 在实际应用中，你需要根据你的认证机制来提取用户信息
    // 例如，从 Cookie 中获取用户 ID
    return 123 // 示例用户 ID
}

确保你的日志记录包含了足够的信息，以便于调试和排查问题。同时，注意保护用户的隐私信息，避免记录敏感数据。