Go应用中优雅处理Error的几个技巧

开发 前端
Go语言很强大并且现在也十分流行 — 许多项目都是用Go语言来实现的,如Kubernetes。

 

Go语言很强大并且现在也十分流行 — 许多项目都是用Go语言来实现的,如Kubernetes。Go语言的一个有趣特性是它的多值返回功能提供了一种与其他编程语言不同的错误处理方法。Go将error视为具有预定义类型的值,其本身是一个interface类型。然而,编写大型应用时需要有包含更多上下文信息的error才有价值,而不仅仅是一个值。本文我们将探讨如何封装Go的error类型以在应用程序中带来更大的价值。

用户自定义类型

我们将重写的Go里自带的 error 类型,首先从一个自定义的错误类型开始,该错误类型将在程序中识别为 error 类型。因此,我们引入一个封装了Go的 error 的新自定义Error类型。

  1. type GoError struct { 
  2.    error 

上下文数据

当我们在Go中说error是一个值时,它是字符串值 - 任何实现了 Error() string 函数的类型都可以视作error类型。将字符串值视为error会使跨层的error处理复杂化,因此处理error字符串信息并不是正确的方法。所以我们可以把字符串和错误码解耦:

  1. type GoError struct { 
  2.    error 
  3.    Code    string 

现在对error的处理将基于错误码 Code 字段而不是字符串。让我们通过上下文数据进一步对错误字符串进行解耦,在上下文数据中可以使用 i18n 包进行国际化。

  1. type GoError struct { 
  2.    error 
  3.    Code    string 
  4.    Data    map[string]interface{} 

Data 包含用于构造错误字符串的上下文数据。错误字符串可以通过数据模板化:

  1. //i18N def 
  2. "InvalidParamValue""Invalid parameter value '{{.actual}}', expected '{{.expected}}' for '{{.name}}'" 

在i18N定义文件中,错误码 Code 将会映射到使用 Data 构建的模板化的错误字符串中。

原因(Causes)

error可能发生在任何一层,有必要为每一层提供处理error的选项,并在不丢失原始error值的情况下进一步使用附加的上下文信息对error进行包装。 GoError 结构体可以用 Causes 进一步封装,用来保存整个错误堆栈。

  1. type GoError struct { 
  2.    error 
  3.    Code    string 
  4.    Data    map[string]interface{} 
  5.    Causes  []error 

如果必须保存多个error数据,则 causes 是一个数组类型,并将其设置为基本 error 类型,以便在程序中包含该原因的第三方错误。

组件(Component)

标记层组件将有助于识别error发生在哪一层,并且可以避免不必要的error wrap。例如,如果 service 类型的error组件发生在服务层,则可能不需要wrap error。检查组件信息将有助于防止暴露给用户不应该通知的error,比如数据库error:

  1. type GoError struct { 
  2.    error 
  3.    Code      string 
  4.    Data      map[string]interface{} 
  5.    Causes    []error 
  6.    Component ErrComponent 
  7.  
  8. type ErrComponent string 
  9. const ( 
  10.    ErrService  ErrComponent = "service" 
  11.    ErrRepo     ErrComponent = "repository" 
  12.    ErrLib      ErrComponent = "library" 

响应类型(ResponseType)

添加一个错误响应类型这样可以支持error分类,以便于了解什么错误类型。例如,可以根据响应类型(如 NotFound )对error进行分类,像 DbRecordNotFound 、 ResourceNotFound 、 UserNotFound 等等的error都可以归类为 NotFound error。这在多层应用程序开发过程中非常有用,而且是可选的封装:

  1. type GoError struct { 
  2.    error 
  3.    Code         string 
  4.    Data         map[string]interface{} 
  5.    Causes       []error 
  6.    Component    ErrComponent 
  7.    ResponseType ResponseErrType 
  8.  
  9. type ResponseErrType string 
  10.  
  11. const ( 
  12.    BadRequest    ResponseErrType = "BadRequest" 
  13.    Forbidden     ResponseErrType = "Forbidden" 
  14.    NotFound      ResponseErrType = "NotFound" 
  15.    AlreadyExists ResponseErrType = "AlreadyExists" 

重试

在少数情况下,出现error会进行重试。retry字段可以通过设置 Retryable 标记来决定是否要进行error重试:

  1. type GoError struct { 
  2.    error 
  3.    Code         string 
  4.    Message      string 
  5.    Data         map[string]interface{} 
  6.    Causes       []error 
  7.    Component    ErrComponent 
  8.    ResponseType ResponseErrType 
  9.    Retryable    bool 

GoError 接口

通过定义一个带有 GoError 实现的显式error接口,可以简化error检查:、

  1. package goerr 
  2.  
  3. type Error interface { 
  4.    error 
  5.  
  6.    Code() string 
  7.    Message() string 
  8.    Cause() error 
  9.    Causes() []error 
  10.    Data() map[string]interface{} 
  11.    String() string 
  12.    ResponseErrType() ResponseErrType 
  13.    SetResponseType(r ResponseErrType) Error 
  14.    Component() ErrComponent 
  15.    SetComponent(c ErrComponent) Error 
  16.    Retryable() bool 
  17.    SetRetryable() Error 

抽象error

有了上述的封装方式,更重要的是对error进行抽象,将这些封装保存在同一地方,并提供error函数的可重用性

  1. func ResourceNotFound(id, kind string, cause error) GoError { 
  2.    data := map[string]interface{}{"kind": kind, "id": id} 
  3.    return GoError{ 
  4.       Code:         "ResourceNotFound"
  5.       Data:         data, 
  6.       Causes:       []error{cause}, 
  7.       Component:    ErrService, 
  8.       ResponseType: NotFound, 
  9.       Retryable:    false
  10.    } 

这个error函数抽象了 ResourceNotFound 这个error,开发者可以使用这个函数来返回error对象而不是每次创建一个新的对象:

  1. //UserService 
  2. user, err := u.repo.FindUser(ctx, userId) 
  3. if err != nil { 
  4.    if err.ResponseType == NotFound { 
  5.       return ResourceNotFound(userUid, "User", err) 
  6.    } 
  7.    return err 

结论

我们演示了如何使用添加上下文数据的自定义Go的error类型,从而使得error在多层应用程序中更有意义。你可以在 这个GitHub Gist [1]看到完整的代码实现和定义。

责任编辑:张燕妮 来源: 网管叨bi叨
相关推荐

2022-09-07 00:04:37

JavaScript运算符技巧

2021-07-12 15:35:56

JavaScript代码运算符

2009-06-25 14:05:40

Java应用技巧

2022-07-18 08:08:16

Go​语言技巧

2021-05-07 06:27:29

JavaScript运算符开发

2022-04-06 07:32:41

Java运算符变量

2021-07-05 07:55:11

Goroutine错误语言

2024-05-06 12:30:51

Go语言中间件

2023-11-06 08:01:09

Go同步异步

2024-10-16 12:23:55

技巧Spring验证

2022-07-19 08:01:55

函数Go格式化

2024-02-19 08:07:31

Go版本语言

2009-01-05 09:14:17

.NETcatch性能损失

2019-03-11 09:18:20

Java 8Stream数据结构

2014-07-22 09:01:53

SwiftJSON

2022-06-09 10:42:47

GoJSON

2024-08-29 08:07:59

GoAPI开发

2024-10-30 09:29:30

Go项目Error

2023-11-06 09:32:52

Java实践

2024-09-27 12:27:31

点赞
收藏

51CTO技术栈公众号