[系列] Gin框架 - 自定义错误处理

时间  2019-12-15
标签 系列 gin 框架 自定义 错误 处理 繁體版
原文   原文链接

目录html

概述

不少读者在后台向我要 Gin 框架实战系列的 Demo 源码，在这里再说明一下，源码我都更新到 GitHub 上，地址：https://github.com/xinliangnote/Gogit

开始今天的文章，为何要自定义错误处理？默认的错误处理方式是什么？github

那好，我们就先说下默认的错误处理。json

默认的错误处理是 errors.New("错误信息")，这个信息经过 error 类型的返回值进行返回。数组

举个简单的例子：微信

func hello(name string) (str string, err error) {
    if name == "" {
        err = errors.New("name 不能为空")
        return
    }
    str = fmt.Sprintf("hello: %s", name)
    return
}

当调用这个方法时：框架

var name = ""
str, err :=  hello(name)
if err != nil {
    fmt.Println(err.Error())
    return
}

这就是默认的错误处理，下面还会用这个例子进行说。异步

这个默认的错误处理，只是获得了一个错误信息的字符串。函数

然而...ui

我还想获得发生错误时的 时间、文件名、方法名、行号 等信息。

我还想获得错误时进行告警，好比 短信告警、邮件告警、微信告警 等。

我还想调用的时候，不那么复杂，就和默认错误处理相似，好比：

alarm.WeChat("错误信息")
return

这样，咱们就获得了咱们想要的信息（时间、文件名、方法名、行号），并经过 微信 的方式进行告警通知咱们。

同理，alarm.Email("错误信息")、alarm.Sms("错误信息") 咱们获得的信息是同样的，只是告警方式不一样而已。

还要保证，咱们业务逻辑中，获取错误的时候，只获取错误信息便可。

上面这些想出来的，就是今天要实现的，自定义错误处理，咱们就实现以前，先说下 Go 的错误处理。

错误处理

package main

import (
    "errors"
    "fmt"
)

func hello(name string) (str string, err error) {
    if name == "" {
        err = errors.New("name 不能为空")
        return
    }
    str = fmt.Sprintf("hello: %s", name)
    return
}

func main() {
    var name = ""
    fmt.Println("param:", name)

    str, err := hello(name)
    if err != nil {
        fmt.Println(err.Error())
        return
    }

    fmt.Println(str)
}

输出：

param: Tom
hello: Tom

当 name = "" 时，输出：

param:
name 不能为空

建议每一个函数都要有错误处理，error 应该为最后一个返回值。

我们一块儿看下官方 errors.go

// Copyright 2011 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package errors implements functions to manipulate errors.
package errors

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

// errorString is a trivial implementation of error.
type errorString struct {
    s string
}

func (e *errorString) Error() string {
    return e.s
}

上面的代码，并不复杂，参照上面的，我们进行写一个自定义错误处理。

自定义错误处理

我们定义一个 alarm.go，用于处理告警。

废话很少说，直接看代码。

package alarm

import (
    "encoding/json"
    "fmt"
    "ginDemo/common/function"
    "path/filepath"
    "runtime"
    "strings"
)

type errorString struct {
    s string
}

type errorInfo struct {
    Time     string `json:"time"`
    Alarm    string `json:"alarm"`
    Message  string `json:"message"`
    Filename string `json:"filename"`
    Line     int    `json:"line"`
    Funcname string `json:"funcname"`
}

func (e *errorString) Error() string {
    return e.s
}

func New (text string) error {
    alarm("INFO", text)
    return &errorString{text}
}

// 发邮件
func Email (text string) error {
    alarm("EMAIL", text)
    return &errorString{text}
}

// 发短信
func Sms (text string) error {
    alarm("SMS", text)
    return &errorString{text}
}

// 发微信
func WeChat (text string) error {
    alarm("WX", text)
    return &errorString{text}
}

// 告警方法
func  alarm(level string, str string) {
    // 当前时间
    currentTime := function.GetTimeStr()

    // 定义 文件名、行号、方法名
    fileName, line, functionName := "?", 0 , "?"

    pc, fileName, line, ok := runtime.Caller(2)
    if ok {
        functionName = runtime.FuncForPC(pc).Name()
        functionName = filepath.Ext(functionName)
        functionName = strings.TrimPrefix(functionName, ".")
    }

    var msg = errorInfo {
        Time     : currentTime,
        Alarm    : level,
        Message  : str,
        Filename : fileName,
        Line     : line,
        Funcname : functionName,
    }

    jsons, errs := json.Marshal(msg)

    if errs != nil {
        fmt.Println("json marshal error:", errs)
    }

    errorJsonInfo := string(jsons)

    fmt.Println(errorJsonInfo)

    if level == "EMAIL" {
        // 执行发邮件

    } else if level == "SMS" {
        // 执行发短信

    } else if level == "WX" {
        // 执行发微信

    } else if level == "INFO" {
        // 执行记日志
    }
}

看下如何调用：

package v1

import (
    "fmt"
    "ginDemo/common/alarm"
    "ginDemo/entity"
    "github.com/gin-gonic/gin"
    "net/http"
)

func AddProduct(c *gin.Context)  {
    // 获取 Get 参数
    name := c.Query("name")

    var res = entity.Result{}

    str, err := hello(name)
    if err != nil {
        res.SetCode(entity.CODE_ERROR)
        res.SetMessage(err.Error())
        c.JSON(http.StatusOK, res)
        c.Abort()
        return
    }

    res.SetCode(entity.CODE_SUCCESS)
    res.SetMessage(str)
    c.JSON(http.StatusOK, res)
}

func hello(name string) (str string, err error) {
    if name == "" {
        err = alarm.WeChat("name 不能为空")
        return
    }
    str = fmt.Sprintf("hello: %s", name)
    return
}

访问：http://localhost:8080/v1/product/add?name=a

{
    "code": 1,
    "msg": "hello: a",
    "data": null
}

未抛出错误，不会输出信息。

访问：http://localhost:8080/v1/product/add

{
    "code": -1,
    "msg": "name 不能为空",
    "data": null
}

抛出了错误，输出信息以下：

{"time":"2019-07-23 22:19:17","alarm":"WX","message":"name 不能为空","filename":"绝对路径/ginDemo/router/v1/product.go","line":33,"funcname":"hello"}

可能这会有同窗说：“用上一篇分享的数据绑定和验证，将传入的参数进行 binding:"required" 也能够实现呀”。

我只能说：“同窗呀，你不理解个人良苦用心，这只是个例子，你们能够在一些复杂的业务逻辑判断场景中使用自定义错误处理”。

到这里，报错时咱们收到了 时间、错误信息、文件名、行号、方法名 了。

调用起来，也比较简单。

虽然标记了告警方式，仍是没有进行告警通知呀。

我想说，在这里存储数据到队列中，再执行异步任务具体去消耗，这块就不实现了，你们能够去完善。

读取 文件名、方法名、行号 使用的是 runtime.Caller()。

咱们还知道，Go 有 panic 和 recover，它们是干什么的呢，接下来我们就说说。

panic 和 recover

当程序不能继续运行的时候，才应该使用 panic 抛出错误。

当程序发生 panic 后，在 defer(延迟函数) 内部能够调用 recover 进行控制，不过有个前提条件，只有在相同的 Go 协程中才能够。

panic 分两个，一种是有意抛出的，一种是无心的写程序马虎形成的，我们一个个说。

有意抛出的 panic：

package main

import (
    "fmt"
)

func main() {

    fmt.Println("-- 1 --")

    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("panic: %s\n", r)
        }
        fmt.Println("-- 2 --")
    }()
    
    panic("i am panic")
}

输出：

-- 1 --
panic: i am panic
-- 2 --

无心抛出的 panic：

package main

import (
    "fmt"
)

func main() {

    fmt.Println("-- 1 --")

    defer func() {
        if r := recover(); r != nil {
            fmt.Printf("panic: %s\n", r)
        }
        fmt.Println("-- 2 --")
    }()


    var slice = [] int {1, 2, 3, 4, 5}

    slice[6] = 6
}

输出：

-- 1 --
panic: runtime error: index out of range
-- 2 --

上面的两个咱们都经过 recover 捕获到了，那咱们如何在 Gin 框架中使用呢？若是收到 panic 时，也想进行告警怎么实现呢？

既然想实现告警，先在 ararm.go 中定义一个 Panic() 方法，当项目发生 panic 异常时，调用这个方法，这样就实现告警了。

// Panic 异常
func Panic (text string) error {
    alarm("PANIC", text)
    return &errorString{text}
}

那咱们怎么捕获到呢？

使用中间件进行捕获，写一个 recover 中间件。

package recover

import (
    "fmt"
    "ginDemo/common/alarm"
    "github.com/gin-gonic/gin"
)

func Recover()  gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if r := recover(); r != nil {
                alarm.Panic(fmt.Sprintf("%s", r))
            }
        }()
        c.Next()
    }
}

路由调用中间件：

r.Use(logger.LoggerToFile(), recover.Recover())

//Use 能够传递多个中间件。

验证下吧，我们先抛出两个异常，看看可否捕获到？

仍是修改 product.go 这个文件吧。

有意抛出 panic：

package v1

import (
    "fmt"
    "ginDemo/entity"
    "github.com/gin-gonic/gin"
    "net/http"
)

func AddProduct(c *gin.Context)  {
    // 获取 Get 参数
    name := c.Query("name")

    var res = entity.Result{}

    str, err := hello(name)
    if err != nil {
        res.SetCode(entity.CODE_ERROR)
        res.SetMessage(err.Error())
        c.JSON(http.StatusOK, res)
        c.Abort()
        return
    }

    res.SetCode(entity.CODE_SUCCESS)
    res.SetMessage(str)
    c.JSON(http.StatusOK, res)
}

func hello(name string) (str string, err error) {
    if name == "" {
        // 有意抛出 panic
        panic("i am panic")
        return
    }
    str = fmt.Sprintf("hello: %s", name)
    return
}

访问：http://localhost:8080/v1/product/add

界面是空白的。

抛出了异常，输出信息以下：

{"time":"2019-07-23 22:42:37","alarm":"PANIC","message":"i am panic","filename":"绝对路径/ginDemo/middleware/recover/recover.go","line":13,"funcname":"1"}

很显然，定位的文件名、方法名、行号不是咱们想要的。

须要调整 runtime.Caller(2)，这个代码在 alarm.go 的 alarm 方法中。

将 2 调整成 4 ，看下输出信息：

{"time":"2019-07-23 22:45:24","alarm":"PANIC","message":"i am panic","filename":"绝对路径/ginDemo/router/v1/product.go","line":33,"funcname":"hello"}

这就对了。

无心抛出 panic：

// 上面代码不变

func hello(name string) (str string, err error) {
    if name == "" {
        // 无心抛出 panic
        var slice = [] int {1, 2, 3, 4, 5}
        slice[6] = 6
        return
    }
    str = fmt.Sprintf("hello: %s", name)
    return
}

访问：http://localhost:8080/v1/product/add

界面是空白的。

抛出了异常，输出信息以下：

{"time":"2019-07-23 22:50:06","alarm":"PANIC","message":"runtime error: index out of range","filename":"绝对路径/runtime/panic.go","line":44,"funcname":"panicindex"}

很显然，定位的文件名、方法名、行号也不是咱们想要的。

将 4 调整成 5 ，看下输出信息：

{"time":"2019-07-23 22:55:27","alarm":"PANIC","message":"runtime error: index out of range","filename":"绝对路径/ginDemo/router/v1/product.go","line":34,"funcname":"hello"}

这就对了。

奇怪了，这是为何？

在这里，有必要说下 runtime.Caller(skip) 了。

skip 指的调用的深度。

为 0 时，打印当前调用文件及行数。

为 1 时，打印上级调用的文件及行数。

依次类推...

在这块，调用的时候须要注意下，我如今尚未好的解决方案。

我是将 skip（调用深度），当一个参数传递进去。

好比：

// 发微信
func WeChat (text string) error {
    alarm("WX", text, 2)
    return &errorString{text}
}

// Panic 异常
func Panic (text string) error {
    alarm("PANIC", text, 5)
    return &errorString{text}
}

具体的代码就不贴了。

可是，有意抛出 Panic 和 无心抛出 Panic 的调用深度又不一样，怎么办？

一、尽可能将有意抛出的 Panic 改为抛出错误的方式。

二、想其余办法搞定它。

就到这吧。

里面涉及到的代码，我会更新到 GitHub。

推荐阅读

Gin 框架

基础篇

本文欢迎转发，转发请注明做者和出处，谢谢！

相关文章
相关标签/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公众号
   欢迎关注本站公众号,获取更多信息
联系我们 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程