一、资源管理

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

    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 处理器。
代码结构如下：

image.png

userError 自定义用户异常接口

package exception

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

myCustomError 自定义用户异常实现

package exception

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

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

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

handler 核心业务逻辑处理器

package handler

import (
    "net/http"
    "os"
    "io/ioutil"
    "strings"
    "github.com/zhaojigang/helloworld/filelisting/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
}

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

web httpServer 服务器

package main

import (
    "net/http"
    "github.com/zhaojigang/helloworld/filelisting/handler"
    "github.com/zhaojigang/helloworld/filelisting/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)
    }
}