Golang自定义错误带上下文怎么实现

自定义错误类型可携带上下文信息以提升调试效率，核心是通过结构体嵌入error并实现Error()和Unwrap()方法，支持errors.Is和errors.As进行错误判断与类型提取。

在 Golang 中，定义包含上下文信息的自定义错误类型，主要是为了在错误发生时，能够提供更丰富的调试信息，方便定位问题。核心在于创建一个结构体，该结构体不仅包含 error 接口，还包含你想要附加的上下文信息。

type ContextError struct {
    Context map[string]interface{}
    Err     error
}

func (e *ContextError) Error() string {
    if e.Err != nil {
        return e.Err.Error()
    }
    return "ContextError: no error specified"
}

func (e *ContextError) Unwrap() error {
    return e.Err
}

// 示例用法
func someFunction(input string) error {
    // 模拟出错
    if input == "bad_input" {
        return &ContextError{
            Context: map[string]interface{}{
                "input":     input,
                "timestamp": time.Now(),
            },
            Err: errors.New("invalid input provided"),
        }
    }
    return nil
}

func main() {
    err := someFunction("bad_input")
    if err != nil {
        // 类型断言
        if contextErr, ok := err.(*ContextError); ok {
            fmt.Printf("Error: %s\n", contextErr.Error())
            fmt.Printf("Context: %+v\n", contextErr.Context)
        } else {
            fmt.Println("Unexpected error type")
        }

        // 使用 errors.Is 和 errors.As
        if errors.Is(err, errors.New("invalid input provided")) {
            fmt.Println("Error is related to invalid input")
        }

        var contextErr *ContextError
        if errors.As(err, &contextErr) {
            fmt.Printf("Extracted Context: %+v\n", contextErr.Context)
        }
    }
}

为什么需要自定义错误类型？

Golang 的标准错误处理机制虽然简洁，但在复杂应用中，仅凭 error 接口返回的信息可能不足以快速诊断问题。自定义错误类型允许你携带更多上下文信息，例如请求 ID、时间戳、用户 ID 等，这对于追踪和调试至关重要。此外，通过实现 Unwrap 方法，可以方便地与 errors.Is 和 errors.As 等标准库函数配合使用，增强错误处理的灵活性。

如何选择合适的上下文信息？

选择哪些信息作为上下文取决于你的应用场景。一般来说，以下信息比较有用：

• 请求相关信息： 请求 ID、URL、HTTP 方法等，有助于追踪请求链路。
• 用户信息： 用户 ID、用户名等，方便定位用户相关问题。
• 时间戳： 记录错误发生的时间，方便排序和分析。
• 输入参数： 导致错误的输入参数，方便重现问题。
• 内部状态： 程序内部状态，例如当前执行的函数、变量值等。

需要注意的是，不要过度收集信息，以免影响性能和安全性。只收集必要的信息，并确保敏感信息得到妥善处理。

除了 map[string]interface{} 还有其他存储上下文信息的方式吗？

当然。虽然 map[string]interface{} 灵活，但类型不安全。更推荐的方式是使用结构体来定义上下文信息，这样可以保证类型安全，并且可以更好地组织数据。

type MyErrorContext struct {
    RequestID string
    UserID    int
    Timestamp time.Time
    Input     string
}

type MyCustomError struct {
    Context MyErrorContext
    Err     error
}

func (e *MyCustomError) Error() string {
    return fmt.Sprintf("MyCustomError: %s, Context: %+v", e.Err.Error(), e.Context)
}

func (e *MyCustomError) Unwrap() error {
    return e.Err
}

func anotherFunction(input string) error {
    if input == "invalid" {
        return &MyCustomError{
            Context: MyErrorContext{
                RequestID: "req123",
                UserID:    42,
                Timestamp: time.Now(),
                Input:     input,
            },
            Err: errors.New("input is invalid"),
        }
    }
    return nil
}

func main() {
    err := anotherFunction("invalid")
    if err != nil {
        var myErr *MyCustomError
        if errors.As(err, &myErr) {
            fmt.Printf("Error: %s\n", myErr.Error())
            fmt.Printf("Request ID: %s\n", myErr.Context.RequestID)
        }
    }
}

使用结构体定义上下文信息，可以避免类型断言的麻烦，并且可以更好地利用 Golang 的类型系统。

如何处理嵌套错误？

在实际应用中，错误可能嵌套多层。例如，一个函数调用了另一个函数，而后者又调用了更底层的函数。如果每个函数都返回自定义错误类型，那么错误信息可能会变得非常冗长。

为了解决这个问题，可以使用 Unwrap 方法来剥离嵌套的错误。errors.Is 和 errors.As 函数会自动递归地调用 Unwrap 方法，直到找到匹配的错误或到达错误链的末端。

func innerFunction() error {
    return &ContextError{
        Context: map[string]interface{}{
            "module": "inner",
        },
        Err: errors.New("inner error"),
    }
}

func outerFunction() error {
    err := innerFunction()
    if err != nil {
        return &ContextError{
            Context: map[string]interface{}{
                "module": "outer",
            },
            Err: fmt.Errorf("outer error: %w", err), // 使用 %w 包装内部错误
        }
    }
    return nil
}

func main() {
    err := outerFunction()
    if err != nil {
        if errors.Is(err, errors.New("inner error")) {
            fmt.Println("Inner error detected")
        }

        var contextErr *ContextError
        if errors.As(err, &contextErr) {
            fmt.Printf("Context: %+v\n", contextErr.Context) // 只会打印最外层的 Context
            // 如果需要打印所有 Context，需要递归遍历 Unwrap
        }

        fmt.Println(err) // 打印完整的错误链
    }
}

使用 %w 动词可以将内部错误包装到外部错误中，这样可以保持错误链的完整性，并且可以使用 errors.Is 和 errors.As 函数来查找特定类型的错误。需要注意的是，errors.As 只会返回最外层的自定义错误类型，如果需要访问所有层的上下文信息，需要递归地调用 Unwrap 方法。

总之，定义包含上下文信息的自定义错误类型是 Golang 中一种强大的错误处理技术。它可以帮助你更好地理解和调试你的代码，并且可以提高你的应用程序的可靠性。