错误处理

Go语言主要的设计准则是:简洁、明白,简洁是指语法和C类似,相当的简单,明白是指任何语句都是很明显的,不含有任何隐含的东西,在错误处理方案的设计中也贯彻了这一思想。

在C语言里面是通过返回-1或者NULL之类的信息来表示错误,但是对于使用者来说,不查看相应的API说明文档,根本搞不清楚这个返回值究竟代表什么意思,比如:返回0是成功,还是失败,而Go定义了一个叫做error的类型,来显式表达错误。在使用时,通过把返回的error变量与nil的比较,来判定操作是否成功。例如os.Open函数在打开文件失败时将返回一个不为nilerror变量

  1. func Open(name string) (file *File, err error)

下面这个例子通过调用os.Open打开一个文件,如果出现错误,那么就会调用log.Fatal来输出错误信息:

  1. f, err := os.Open("filename.ext")
  2. if err != nil {
  3. log.Fatal(err)
  4. }

类似于os.Open函数,标准包中所有可能出错的API都会返回一个error变量,以方便错误处理,这个小节将详细地介绍error类型的设计,和讨论开发Web应用中如何更好地处理error

Error类型

error类型是一个接口类型,这是它的定义:

  1. type error interface {
  2. Error() string
  3. }

error是一个内置的接口类型,可以在/builtin/包下面找到相应的定义。而在很多内部包里面用到的 errorerrors包下面的实现的私有结构errorString

  1. // errorString is a trivial implementation of error.
  2. type errorString struct {
  3. s string
  4. }
  5. func (e *errorString) Error() string {
  6. return e.s
  7. }

可以通过errors.New把一个字符串转化为errorString,以得到一个满足接口error的对象,其内部实现如下:

  1. // New returns an error that formats as the given text.
  2. func New(text string) error {
  3. return &errorString{text}
  4. }

下面这个例子演示了如何使用errors.New:

  1. func Sqrt(f float64) (float64, error) {
  2. if f < 0 {
  3. return 0, errors.New("math: square root of negative number")
  4. }
  5. // implementation
  6. }

在下面的例子中,在调用Sqrt的时候传递的一个负数,然后就得到了non-nilerror对象,将此对象与nil比较,结果为true,所以fmt.Println(fmt包在处理error时会调用Error方法)被调用,以输出错误,请看下面调用的示例代码:

  1. f, err := Sqrt(-1)
  2. if err != nil {
  3. fmt.Println(err)
  4. }

自定义Error

error是一个interface,所以在实现自己的包的时候,通过定义实现此接口的结构,就可以实现自己的错误定义,请看来自Json包的示例:

  1. type SyntaxError struct {
  2. msg string // 错误描述
  3. Offset int64 // 错误发生的位置
  4. }
  5. func (e *SyntaxError) Error() string { return e.msg }

Offset字段在调用Error的时候不会被打印,但可以通过类型断言获取错误类型,然后可以打印相应的错误信息,请看下面的例子:

  1. if err := dec.Decode(&val); err != nil {
  2. if serr, ok := err.(*json.SyntaxError); ok {
  3. line, col := findLine(f, serr.Offset)
  4. return fmt.Errorf("%s:%d:%d: %v", f.Name(), line, col, err)
  5. }
  6. return err
  7. }

需要注意的是,函数返回自定义错误时,返回值推荐设置为error类型,而非自定义错误类型,特别需要注意的是不应预声明自定义错误类型的变量。例如:

  1. func Decode() *SyntaxError { // 错误,将可能导致上层调用者err!=nil的判断永远为true。
  2. var err *SyntaxError // 预声明错误变量
  3. if 出错条件 {
  4. err = &SyntaxError{}
  5. }
  6. return err // 错误,err永远等于非nil,导致上层调用者err!=nil的判断始终为true
  7. }

原因见 http://golang.org/doc/faq#nil_error (需科学上网)

上面例子简单的演示了如何自定义Error类型。但是如果还需要更复杂的错误处理呢?此时,来参考一下net包采用的方法:

  1. package net
  2. type Error interface {
  3. error
  4. Timeout() bool // Is the error a timeout?
  5. Temporary() bool // Is the error temporary?
  6. }

在调用的地方,通过类型断言err是不是net.Error,来细化错误的处理,例如下面的例子,如果一个网络发生临时性错误,那么将会sleep 1秒之后重试:

  1. if nerr, ok := err.(net.Error); ok && nerr.Temporary() {
  2. time.Sleep(1e9)
  3. continue
  4. }
  5. if err != nil {
  6. log.Fatal(err)
  7. }

错误处理

Go在错误处理上采用了与C类似的检查返回值的方式,而不是其他多数主流语言采用的异常方式,这造成了代码编写上的一个很大的缺点:错误处理代码的冗余,对于这种情况是通过复用检测函数来减少类似的代码。

请看下面这个例子代码:

  1. func init() {
  2. http.HandleFunc("/view", viewRecord)
  3. }
  4. func viewRecord(w http.ResponseWriter, r *http.Request) {
  5. c := appengine.NewContext(r)
  6. key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
  7. record := new(Record)
  8. if err := datastore.Get(c, key, record); err != nil {
  9. http.Error(w, err.Error(), 500)
  10. return
  11. }
  12. if err := viewTemplate.Execute(w, record); err != nil {
  13. http.Error(w, err.Error(), 500)
  14. }
  15. }

上面的例子中获取数据和模板展示调用时都有检测错误,当有错误发生时,调用了统一的处理函数http.Error,返回给客户端500错误码,并显示相应的错误数据。但是当越来越多的HandleFunc加入之后,这样的错误处理逻辑代码就会越来越多,其实可以通过自定义路由器来缩减代码

  1. type appHandler func(http.ResponseWriter, *http.Request) error
  2. func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  3. if err := fn(w, r); err != nil {
  4. http.Error(w, err.Error(), 500)
  5. }
  6. }

上面定义了自定义的路由器,然后可以通过如下方式来注册函数:

  1. func init() {
  2. http.Handle("/view", appHandler(viewRecord))
  3. }

当请求/view的时候逻辑处理可以变成如下代码,和第一种实现方式相比较已经简单了很多。

  1. func viewRecord(w http.ResponseWriter, r *http.Request) error {
  2. c := appengine.NewContext(r)
  3. key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
  4. record := new(Record)
  5. if err := datastore.Get(c, key, record); err != nil {
  6. return err
  7. }
  8. return viewTemplate.Execute(w, record)
  9. }

上面的例子错误处理的时候所有的错误返回给用户的都是500错误码,然后打印出来相应的错误代码,其实可以把这个错误信息定义的更加友好,调试的时候也方便定位问题,可以自定义返回的错误类型:

  1. type appError struct {
  2. Error error
  3. Message string
  4. Code int
  5. }

这样自定义路由器可以改成如下方式:

  1. type appHandler func(http.ResponseWriter, *http.Request) *appError
  2. func (fn appHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  3. if e := fn(w, r); e != nil { // e is *appError, not os.Error.
  4. c := appengine.NewContext(r)
  5. c.Errorf("%v", e.Error)
  6. http.Error(w, e.Message, e.Code)
  7. }
  8. }

这样修改完自定义错误之后,逻辑处理可以改成如下方式:

  1. func viewRecord(w http.ResponseWriter, r *http.Request) *appError {
  2. c := appengine.NewContext(r)
  3. key := datastore.NewKey(c, "Record", r.FormValue("id"), 0, nil)
  4. record := new(Record)
  5. if err := datastore.Get(c, key, record); err != nil {
  6. return &appError{err, "Record not found", 404}
  7. }
  8. if err := viewTemplate.Execute(w, record); err != nil {
  9. return &appError{err, "Can't display record", 500}
  10. }
  11. return nil
  12. }

如上所示,在访问view的时候可以根据不同的情况获取不同的错误码和错误信息,虽然这个和第一个版本的代码量差不多,但是这个显示的错误更加明显,提示的错误信息更加友好,扩展性也比第一个更好。

总结

在程序设计中,容错是相当重要的一部分工作,在Go中它是通过错误处理来实现的,error虽然只是一个接口,但是其变化却可以有很多,可以根据自己的需求来实现不同的处理。