异常处理

Golang中对于一般的错误处理提供了error接口，对于不可预见的错误,也就是只会在程序运行时异常被抛出来。处理提供了两个内置函数panic和recover。panic和recover类似于java中的try/catch/throw。

panic

当在一个函数执行过程中调用panic()函数时，正常的函数执行流程将立即终止，但函数中之前使用defer关键字延迟执行的语句将正常展开执行，之后该函数将返回到调用函数，并导致逐层向上执行panic流程，直至所属的goroutine中所有正在执行的函数被终止。错误信息将被报告，包括在调用panic()函数时传入的参数，这个过程称为异常处理流程。

recover

recover函数用于终止错误处理流程。一般情况下，recover应该在一个使用defer关键字的函数中执行以有效截取错误处理流程。如果没有在发生异常的goroutine中明确调用恢复过程（调用recover函数），会导致该goroutine所属的进程打印异常信息后直接退出。
对于第三方库的调用，在不清楚是否有panic的情况下，最好在适配层统一加上recover过程，否则会导致当前进程的异常退出，而这并不是我们所期望的。
简单的实现如下：

  1. func thirdPartyAdaptedHandler(...) {
  2.     defer func() {
  3.         err := recover()
  4.         if err != nil {
  5.             fmt.Println("some exception has happend:", err)
  6.         }
  7.     }()
  8.     ...
  9. }

Error

error类型其实是一个接口类型，也是一个 Go 语言的内建类型。在这个接口类型的声明中只包含了一个方法Error。Error方法不接受任何参数，但是会返回一个string类型的结果。它的作用是返回错误信息的字符串表示形式。

接口Error()

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. type fileError struct {
  9.     err error
  10.     message string
  11. }
  13. func (f fileError)Error() string{
  14.     return f.err.Error()+f.message
  15. }
  17. func main() {
  18.     file, err := os.Open("demo.txt")
  19.     if err!= nil {
  20.         err = fileError{err:err,message:"文件打开失败"}
  21.         fmt.Println(err)
  22.     }
  23.     defer file.Close()
  24. }

fmt.Errorf

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

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. func main() {
  9.     file, err := os.Open("demo.txt")
  10.     if err!= nil {
  11.         err = fmt.Errorf("文件打开失败：%v", err)
  12.         fmt.Println(err)
  13.     }
  14.     defer file.Close()
  15. }

Wrapping Error

可以一个error嵌套另一个error功能，好处就是我们可以根据嵌套的error序列，生成一个error错误跟踪链，也可以理解为错误堆栈信息，这样可以便于我们跟踪调试，哪些错误引起了什么问题，根本的问题原因在哪里。
因为error可以嵌套，所以每次嵌套的时候，我们都可以提供新的错误信息，并且保留原来的error。现在我们看下如何生成一个嵌套的error。
Golang并没有提供什么Wrap函数，而是扩展了fmt.Errorf函数，加了一个%w来生成一个可以Wrapping Error,通过这种方式，我们可以创建一个个以Wrapping Error。

  1. package main
  3. import (
  4.     "fmt"
  5.     "os"
  6. )
  8. func main() {
  9.     file, err := os.Open("demo.txt")
  10.     if err!= nil {
  11.         e := fmt.Errorf("文件打开失败:%w",err)
  12.         fmt.Println(e)
  13.     }
  14.     defer file.Close()
  15. }

原理
  1. func Errorf(format string, a ...interface{}) error {
  2.     p := newPrinter()
  3.     p.wrapErrs = true
  4.     p.doPrintf(format, a)
  5.     s := string(p.buf)
  6.     var err error
  7.     if p.wrappedErr == nil {
  8.         err = errors.New(s)
  9.     } else {
  10.         err = &wrapError{s, p.wrappedErr}
  11.     }
  12.     p.free()
  13.     return err
  14. }

errors.New

  1. package main
  3. import (
  4.     "errors"
  5.     "fmt"
  6.     "os"
  7. )
  9. type fileError struct {
  10.     err error
  11.     message string
  12. }
  14. func (f fileError)Error() string{
  15.     return f.err.Error()+f.message
  16. }
  18. func main() {
  19.     file, err := os.Open("demo.txt")
  20.     if err!= nil {
  21.         err = errors.New("文件打开失败:"+err.Error())
  22.         fmt.Println(err)
  23.     }
  24.     defer file.Close()
  25. }

Unwrap 函数

Golang 1.13引入了wrapping error后，同时为errors包添加了3个工具函数，他们分别是Unwrap、Is和As，先来聊聊Unwrap。
顾名思义，它的功能就是为了获得被嵌套的error。

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

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

  1. func Unwrap(err error) error {
  2.     //先判断是否是wrapping error
  3.     u, ok := err.(interface {
  4.         Unwrap() error
  5.     })
  6.     //如果不是，返回nil
  7.     if !ok {
  8.         return nil
  9.     }
  10.     //否则则调用该error的Unwrap方法返回被嵌套的error
  11.     return u.Unwrap()
  12. }

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

Is 函数

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

  1. if err == os.ErrExist

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

  1. func Is(err, target error) bool
  1. 如果err和target是同一个，那么返回true
  2. 如果err 是一个wrap error,target也包含在这个嵌套error链中的话，那么也返回true。

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

  1. func Is(err, target error) bool {
  2.     if target == nil {
  3.         return err == target
  4.     }
  5.     isComparable := reflectlite.TypeOf(target).Comparable()
  6.     //for循环，把err一层层剥开，一个个比较，找到就返回true
  7.     for {
  8.         if isComparable && err == target {
  9.             return true
  10.         }
  11.         //这里意味着你可以自定义error的Is方法，实现自己的比较代码
  12.         if x, ok := err.(interface{ Is(error) bool }); ok && x.Is(target) {
  13.             return true
  14.         }
  15.         //剥开一层，返回被嵌套的err
  16.         if err = Unwrap(err); err == nil {
  17.             return false
  18.         }
  19.     }
  20. }

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

As 函数

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

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

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

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

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

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

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

  1. func As(err error, target interface{}) bool {
  2.     //一些判断，保证target，这里是不能为nil
  3.     if target == nil {
  4.         panic("errors: target cannot be nil")
  5.     }
  6.     val := reflectlite.ValueOf(target)
  7.     typ := val.Type()
  8.     //这里确保target必须是一个非nil指针
  9.     if typ.Kind() != reflectlite.Ptr || val.IsNil() {
  10.         panic("errors: target must be a non-nil pointer")
  11.     }
  12.     //这里确保target是一个接口或者实现了error接口
  13.     if e := typ.Elem(); e.Kind() != reflectlite.Interface && !e.Implements(errorType) {
  14.         panic("errors: *target must be interface or implement error")
  15.     }
  16.     targetType := typ.Elem()
  17.     for err != nil {
  18.         //关键部分，反射判断是否可被赋予，如果可以就赋值并且返回true
  19.         //本质上，就是类型断言，这是反射的写法
  20.         if reflectlite.TypeOf(err).AssignableTo(targetType) {
  21.             val.Elem().Set(reflectlite.ValueOf(err))
  22.             return true
  23.         }
  24.         //这里意味着你可以自定义error的As方法，实现自己的类型断言代码
  25.         if x, ok := err.(interface{ As(interface{}) bool }); ok && x.As(target) {
  26.             return true
  27.         }
  28.         //这里是遍历error链的关键，不停的Unwrap，一层层的获取err
  29.         err = Unwrap(err)
  30.     }
  31.     return false
  32. }

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

旧工程迁移

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

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

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

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

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

  1. if err == os.ErrExist

新工程

  1. if errors.Is(err, os.ErrExist)

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

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

新工程

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

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

  1. type MyError struct {
  2.     err error
  3.     msg string
  4. }
  5. func (e *MyError) Error() string {
  6.     return e.err.Error() + e.msg
  7. }

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

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

这样就可以了。