Go语言(golang)新发布的1.13中的Error Wrapping深度分析

Posted 2021-04-05 飞雪无情

2019.09.03日，Golang 1.13版本发布，这次更新算是比较大的了，有大家期待的GOPROXY和GOPRIVATE等，具体的可以去看这个版本的 Go 1.13 Release Notes。

Go 1.13发布的功能还有一个值得深入研究的，就是对Error的增强，也是今天我们要分析的 Error Wrapping.

背景

做Go语言开发的，肯定经常用error，但是我们也知道error非常弱，只能自带一串文本其他什么都做不了，比如给已经存在的error增加一些附加文本，增加堆栈信息等都做不了。如果我们想给error增加一些附加文本怎么做呢？有两种办法：

第一种：

newErr:=fmt.Errorf("数据上传问题: %v", err)

通过fmt.Errorf函数，基于已经存在的err再生成一个新的newErr，然后附加上我们想添加的文本信息。这种办法比较方便，但是问题也很明显，我们丢失了原来的err，因为它已经被我们的fmt.Errorf函数转成一个新的字符串了。

第二种：

func main() {
    newErr := MyError{err, "数据上传问题"}
}

type MyError struct {
    err error
    msg string
}

func (e *MyError) Error() string {
    return e.err.Error() + e.msg
}

这种方式就是我们自定义自己的struct，添加用于存储我们需要额外信息的字段，我这里是err和msg，分别存储原始err和新附加的出错信息。然后这个MyError还会实现error接口，表示他是一个error，这样我们就可以自由的使用了。

这种方式有点很明显，大家可以看到了。缺点呢，就是我们要自定义很多struct，而且我们自己定义的，和第三方的可能还不太一样，无法统一和兼容。基于这个背景，Golang 1.13 为我们提供了Error Wrapping，翻译过来我更愿意叫Error嵌套。

如何生成一个Wrapping Error

Error Wrapping，顾名思义，就是为我们提供了，可以一个error嵌套另一个error功能，好处就是我们可以根据嵌套的error序列，生成一个error错误跟踪链，也可以理解为错误堆栈信息，这样可以便于我们跟踪调试，哪些错误引起了什么问题，根本的问题原因在哪里。

因为error可以嵌套，所以每次嵌套的时候，我们都可以提供新的错误信息，并且保留原来的error。现在我们看下如何生成一个嵌套的error。

e := errors.New("原始错误e")
w := fmt.Errorf("Wrap了一个错误%w", e)

Golang并没有提供什么Wrap函数，而是扩展了fmt.Errorf函数，加了一个%w来生成一个可以Wrapping Error,通过这种方式，我们可以创建一个个以Wrapping Error。

Wrapping Error原理

按照这种不丢失原error的思路，那么Wrapping Error的实现原理应该类似我们上面的自定义error.我们看下fmt.Errorf函数的源代码验证下我们的猜测是否正确。

func Errorf(format string, a ...interface{}) error {
    //省略无关代码
    var err error
    if p.wrappedErr == nil {
        err = errors.New(s)
    } else {
        err = &wrapError{s, p.wrappedErr}
    }
    p.free()
    return err
}

这里的关键核心代码就是p.wrappedErr的判断，这个值是否存在，决定是否要生成一个wrapping error。这个值是怎么来的呢？就是根据我们设置的%w解析出来的。

有了这个值之后，就生成了一个&wrapError{s, p.wrappedErr}返回了，这里有个结构体wrapError

type wrapError struct {
    msg string
    err error
}

func (e *wrapError) Error() string {
    return e.msg
}

func (e *wrapError) Unwrap() error {
    return e.err
}

如上所示，和我们想的一样。实现了Error方法说明它是一个error。Unwrap方法是一个特别的方法，所有的wrapping error 都会有这么一个方法，用于获得被嵌套的error。

Unwrap 函数

Golang 1.13引入了wrapping error后，同时为errors包添加了3个工具函数，他们分别是Unwrap、Is和As，先来聊聊Unwrap。

顾名思义，它的功能就是为了获得被嵌套的error。

func main() {
    e := errors.New("原始错误e")
    w := fmt.Errorf("Wrap了一个错误%w", e)
    fmt.Println(errors.Unwrap(w))
}

以上这个例子，通过errors.Unwrap(w)后，返回的其实是个e，也就是被嵌套的那个error。
这里需要注意的是，嵌套可以有很多层，我们调用一次errors.Unwrap函数只能返回最外面的一层error，如果想获取更里面的，需要调用多次errors.Unwrap函数。最终如果一个error不是warpping error，那么返回的是nil。

func Unwrap(err error) error {
    //先判断是否是wrapping error
    u, ok := err.(interface {
        Unwrap() error
    })
    //如果不是，返回nil
    if !ok {
        return nil
    }
    //否则则调用该error的Unwrap方法返回被嵌套的error
    return u.Unwrap()
}

看看该函数的的源代码吧，这样就会理解的更深入一些，我加了一些注释。

Is 函数

在Go 1.13之前没有wrapping error的时候，我们要判断error是不是同一个error可以使用如下办法：

if err == os.ErrExist

这样我们就可以通过判断来做一些事情。但是现在有了wrapping error后这样办法就不完美的，因为你根本不知道返回的这个err是不是一个嵌套的error,嵌套了几层。所以基于这种情况，Golang为我们提供了errors.Is函数。

func Is(err, target error) bool

1. 如果err和target是同一个，那么返回true

2. 如果err 是一个wrap error,target也包含在这个嵌套error链中的话，那么也返回true。

很简单的一个函数，要么咱俩相等，要么err包含target，这两种情况都返回true，其余返回false。

func Is(err, target error) bool {
    if target == nil {
        return err == target
    }

    isComparable := reflectlite.TypeOf(target).Comparable()

    //for循环，把err一层层剥开，一个个比较，找到就返回true
    for {
        if isComparable && err == target {
            return true
        }
        //这里意味着你可以自定义error的Is方法，实现自己的比较代码
        if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
            return true
        }
        //剥开一层，返回被嵌套的err
        if err = Unwrap(err); err == nil {
            return false
        }
    }
}

Is函数源代码如上，其实就是一层层反嵌套，剥开然后一个个的和target比较，相等就返回true。

As 函数

在Go 1.13之前没有wrapping error的时候，我们要把error转为另外一个error，一般都是使用type assertion 或者 type switch，其实也就是类型断言。

if perr, ok := err.(*os.PathError); ok {
    fmt.Println(perr.Path)
}

比如例子中的这种方式，但是现在给你返回的err可能是已经被嵌套了，甚至好几层了，这种方式就不能用了，所以Golang为我们在errors包里提供了As函数，现在我们把上面的例子，用As函数实现一下。

var perr *os.PathError
if errors.As(err, &perr) {
    fmt.Println(perr.Path)
}

这样就可以了，就可以完全实现类型断言的功能，而且还更强大，因为它可以处理wrapping error。

func As(err error, target interface{}) bool

从功能上来看，As所做的就是遍历err嵌套链，从里面找到类型符合的error，然后把这个error赋予target,这样我们就可以使用转换后的target了，这里有值得赋予，所以target必须是一个指针。

func As(err error, target interface{}) bool {
    //一些判断，保证target，这里是不能为nil
    if target == nil {
        panic("errors: target cannot be nil")
    }
    val := reflectlite.ValueOf(target)
    typ := val.Type()

    //这里确保target必须是一个非nil指针
    if typ.Kind() != reflectlite.Ptr || val.IsNil() {
        panic("errors: target must be a non-nil pointer")
    }

    //这里确保target是一个接口或者实现了error接口
    if e := typ.Elem(); e.Kind() != reflectlite.Interface && !e.Implements(errorType) {
        panic("errors: *target must be interface or implement error")
    }
    targetType := typ.Elem()
    for err != nil {
        //关键部分，反射判断是否可被赋予，如果可以就赋值并且返回true
        //本质上，就是类型断言，这是反射的写法
        if reflectlite.TypeOf(err).AssignableTo(targetType) {
            val.Elem().Set(reflectlite.ValueOf(err))
            return true
        }
        //这里意味着你可以自定义error的As方法，实现自己的类型断言代码
        if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
            return true
        }
        //这里是遍历error链的关键，不停的Unwrap，一层层的获取err
        err = Unwrap(err)
    }
    return false
}

这是As函数的源代码，看源代码比较清晰一些，我在代码里做了注释，这里就不一一分析了，大家可以结合注释读一下。

旧工程迁移

新特性的更新，如果要使想使用，不免会有旧项目的迁移，现在我们就针对几种常见的情况看如何进行迁移。
如果你以前是直接返回err，或者通过如下方式给err增加了额外信息。

return err

return fmt.Errorf("more info: %v", err)

这2种情况你直接切换即可。

return fmt.Errorf("more info: %w", err)

切换后，如果你有==的error判断，那么就用Is函数代替，比如：

旧工程

if err == os.ErrExist

新工程

if errors.Is(err, os.ErrExist)

同理，你旧的代码中，如果有对error进行类型断言的转换，就要用As函数代替，比如：

旧工程

if perr, ok := err.(*os.PathError); ok {
    fmt.Println(perr.Path)
}

新工程

var perr *os.PathError
if errors.As(err, &perr) {
    fmt.Println(perr.Path)
}

如果你自己自定义了一个struct实现了error接口，而且还嵌套了error，这个时候该怎么适配新特性呢？也就是我们上面举例的情况：

type MyError struct {
    err error
    msg string
}

func (e *MyError) Error() string {
    return e.err.Error() + e.msg
}

其实对于这种方式很简单，只需要给他添加一个Unwrap方法就可以了，让它变成一个wrap error。

func (e *MyError) Unwrap() error {
    return e.err
}

这样就可以了。

结语

这篇文章深度剖析了Error Wrapping的背景、实现原理以及工程迁移的注意事项，这个新特性是很值得使用的，毕竟增强了error，提供了强大的跟踪能力，再结合一些额外的数据，可以让我们调试、变成会更方便。

扫码关注