一、资源管理

Java 有 try-finally，可以在 finally 中进行资源的关闭；Go 可以使用 defer

• defer 在函数结束时发生调用
• defer 的调用是栈类型 – 先进后出
• defer 通常用于资源关闭 Open/Close，Lock/UnLock 等

一句话总结：defer 的调用机制是 “将defer语句加入栈中，当函数结束时（包括正常执行结束 / return / panic 出错结束等），从栈中依次执行 defer”

func writeFile(filename string) {
   file, err := os.Create(filename)
   if err != nil {
      panic(err)
   }
   defer file.Close() // 将 "file.Close()" 压入 defer 栈中

   writer := bufio.NewWriter(file)
   defer writer.Flush() // 将 "writer.Flush()" 压入 defer 栈中

   fmt.Fprintln(writer, "123")
   // 当函数执行结束时，从 defer 栈中执行语句 - 后进先出，先 "writer.Flush()"，再 "file.Close()"
}

func main() {
   writeFile("defer.txt")
}

二、错误简单处理

使用机制

通过被调用函数的注释查看其可能发生的错误，然后依据错误类型并进行处理；
错误处理结束后要 return

func main() {
   file, err := os.Open(filename)
   // 错误处理
   if err != nil {
      // 判断 err 是否是 *os.PathError，因为 os.Open(filename) 的注释："If there is an error, it will be of type *PathError."
      if pathError, ok := err.(*os.PathError); ok {
         fmt.Printf("error: %s", pathError.Error())
      } else {
         fmt.Printf("notKnown error：%s", err.Error())
      }
      return // 返回
   }
}

//error 是一个接口，定义如下：

// The error built-in interface type is the conventional interface for
// representing an error condition, with the nil value representing no error.
type error interface {
   Error() string
}

基于该接口我们可以实现自定义的 error 实现。（ errors 是 error 接口的一个实现，可以直接仿照，也可以直接使用，如 err := errors.New(“my custom error”)）

三、panic & recover

• panic
  • 停止当前程序运行
  • 一直向上返回，执行每一层的 defer
  • 如果没有遇见 recover，程序退出
• recover（相当于对 panic 的 catch 语句）
  • 仅在 defer 调用中使用
  • 获取 panic 的值
  • 如果无法处理，可重新 panic

import (
   "fmt"
   "errors"
)

func recove() {
   defer func() {
      // func recover() interface{}，表示 recover() 函数的返回类型可以是各种类型，所以要判断是否是 error
      // 使用 recover() catch panic，防止程序直接退出
      r := recover()
      if err, ok := r.(error); ok {
         fmt.Println(err) // runtime error: integer divide by zero
      } else {
         panic(errors.New("not known error"))
      }
   }()

   b := 0
   a := 5/b // panic: runtime error: integer divide by zero
   fmt.Println(a)

   //panic("123") // panic: not known error
}

func main() {
   recove()
}

四、错误统一处理

一个生产系统通常包含两种异常

• 不可直接暴露给用户的异常：例如系统内部异常
• 需要暴露给用户的异常：例如部分自定义异常信息用于提示用户操作

本节写一个需求：实现一个读取文件的 httpServer 处理器。
代码结构如下：

4.1 userError 自定义用户异常接口

package exception

type UserError interface {
   error // 内嵌类型
   Message() string
}

4.2 myCustomError 自定义用户异常实现

package exception

// 基于基本类型创建自定义类型
type MyCustomError string

func (e MyCustomError) Error() string {
   return e.Message()
}

func (e MyCustomError) Message() string {
   return string(e)
}

4.3 handler 核心业务逻辑处理器

package handler

import (
"net/http"
"os"
"io/ioutil"
"strings"
"exception"
)

const PathPrefix = "/list/"

// 实现一个读取文件的 httpServer 处理器
// 假设访问 http://localhost:8888/list/abc.txt
func HandleFileListing(writer http.ResponseWriter, request *http.Request) error {
   // 1. 如果 urlPath 不是以 /list/ 开头的，则自定义用户错误
   if strings.Index(request.URL.Path, PathPrefix) != 0 {
      return exception.MyCustomError("url path need startWith /list/")
   }
   //fmt.Println("path", request.URL.Path)    // /list/abc.txt
   path := request.URL.Path[len(PathPrefix):] // abc.txt 字符串切割，subString

   // 2. 打开文件
   file, err := os.Open(path)
   if err != nil {
      // 遇到错误直接返回，由错误统一处理器进行处理
      return err
   }
   defer file.Close()

   // 3. 读取文件到 byte[]
   all, err := ioutil.ReadAll(file)
   if err != nil {
      return err
   }

   // 4. 将 byte[] all 写出到响应流
   writer.Write(all)
   return nil
}

4.4 errorWrapperHandler 统一错误处理器

package exception

import (
"net/http"
"log"
"os"
)

// 定义一个 function 类型的 type，返回值是 error
type appHandler func(writer http.ResponseWriter, request *http.Request) error

// 输入 appHandler 是一个函数，输出也是一个函数 - 函数式编程
func ErrWrapper(handler appHandler) func(http.ResponseWriter, *http.Request) {
   return func(writer http.ResponseWriter, request *http.Request) {
      // 1. 处理业务逻辑
      err := handler(writer, request)
      if err != nil {
         log.Printf("error occured, %s", err) // 2018/11/04 10:10:12 error occured, open abc.txt1: no such file or directory

         // 2. 处理可以抛给用户的错误
         if err, ok := err.(UserError); ok {
            // 将错误写回到 http.ResponseWriter
            http.Error(writer, err.Message(), http.StatusBadRequest)
         }

         // 3. 处理不可以抛给用户的错误
         code := http.StatusOK
         switch {
         case os.IsNotExist(err):
            code = http.StatusNotFound
         default:
            code = http.StatusInternalServerError
         }
         http.Error(writer, http.StatusText(code), code) // 浏览器：Not Found
      }
   }
}

注意这样的姿势：定义一个 function 类型的 type，返回值是 error

type appHandler func(xx) error

4.5 web httpServer 服务器

package main

import (
"net/http"
"handler"
"exception"
)

func main() {
   // 1. 注册处理 handler.PathPrefix 开头的业务逻辑处理器
   http.HandleFunc(handler.PathPrefix, exception.ErrWrapper(handler.HandleFileListing))

   // 2. 启动 httpServer，监听端口
   err := http.ListenAndServe("127.0.0.1:8888", nil)

   // 3. 如果启动失败，则直接抛出错误
   if err != nil {
      panic(err)
   }
}