Go语言中如何序列化与反序列化错误字符串及嵌套错误？

在两个共享Message结构体的Go服务场景中，要实现嵌套错误的序列化（客户端）和可检查的反序列化（服务器），可以按以下步骤处理：

一、客户端：将嵌套错误序列化为完整字符串 #

嵌套错误包含多层包装信息，直接调用err.Error()只能获取顶层错误，需要递归遍历整个错误链，把所有层级的错误信息拼接成字符串：

import (
	"errors"
	"strings"
)

// errorToString 递归遍历错误链，拼接所有错误信息
func errorToString(err error) string {
	var errSegments []string
	for currentErr := err; currentErr != nil; currentErr = errors.Unwrap(currentErr) {
		errSegments = append(errSegments, currentErr.Error())
	}
	return strings.Join(errSegments, ": ")
}

// 序列化示例
func serializeError(err error) ([]byte, error) {
	msg := Message{
		Error: errorToString(err),
	}
	return json.Marshal(msg)
}

比如嵌套错误fmt.Errorf("请求失败: %w", fmt.Errorf("数据库连接超时"))，会被序列化为字符串"请求失败: 数据库连接超时"。

二、服务器：将字符串反序列化为可检查的嵌套错误 #

需要自定义一个实现error接口且支持Unwrap方法的类型，根据序列化后的字符串重建错误链：

import (
	"strings"
)

// WrappedError 支持嵌套的错误类型，实现Unwrap方法
type WrappedError struct {
	message string
	nextErr error
}

func (w *WrappedError) Error() string {
	return w.message
}

func (w *WrappedError) Unwrap() error {
	return w.nextErr
}

// stringToError 从拼接字符串重建嵌套错误链
func stringToError(errStr string) error {
	errSegments := strings.Split(errStr, ": ")
	var currentErr error
	// 从最底层错误开始向上包装
	for i := len(errSegments) - 1; i >= 0; i-- {
		currentErr = &WrappedError{
			message: errSegments[i],
			nextErr: currentErr,
		}
	}
	return currentErr
}

// 反序列化示例
func deserializeError(jsonBytes []byte) (error, error) {
	var msg Message
	if err := json.Unmarshal(jsonBytes, &msg); err != nil {
		return nil, err
	}
	return stringToError(msg.Error), nil
}

三、验证错误检查能力 #

反序列化后的错误可以直接用errors.As或errors.Is检查嵌套的原始错误：

// 客户端侧的原始嵌套错误
baseErr := fmt.Errorf("数据库连接超时")
clientErr := fmt.Errorf("请求失败: %w", baseErr)

// 序列化+反序列化
jsonBytes, _ := serializeError(clientErr)
serverErr, _ := deserializeError(jsonBytes)

// 检查是否包含baseErr
fmt.Println(errors.Is(serverErr, baseErr)) // 输出: true

// 检查错误类型（假设baseErr是自定义类型）
var customErr *CustomDBError
fmt.Println(errors.As(serverErr, &customErr)) // 输出: true

内容的提问来源于stack exchange，提问作者Ado Ren