异常捕获

Go语言的异常捕获采用的是延迟处理的方法实现的，实际上就是利用defer，panic和recover三个关键字和函数来实现的。

关键字

defer关键字(函数)

这个关键字在控制语句中就有所涉及，本质上是采用一个栈的存储结构，在整个函数执行完之后，再启用这个栈，依次执行这个函数。需要注意的是以下几点：

1. 由于是栈的结构，我们首先想到的便是先入后出，defer也是如此

   func f(){
   defer A
   defer B
   D
   defer C}
   

   执行的顺序是D，C，B，A

2. 被defer标记的语句是放在最后执行的，所以也就衍生出defer的玩法——放在开头加一个打印语句，来判断go程的结束（原理如此，至于稍复杂的结合等待组或者响应等也大同小异）

panic函数

让程序直接崩溃的函数，用法panic("<报错信息>")

Recover

Recover只在延时函数中有效，效果是将崩溃的程序恢复过来；如果是在正常的语句中使用Recover，就会返回一个nil并且没有任何效果。

实例(没意义)：

func main() {defer func() {if err := recover(); err != nil {fmt.Println("捕获异常：", err)}}()r := router.Router()r.Run(":9999")panic("雪豹毁了我的程序")}

运行结果：

服务端正常运行！

实例：

使用这个方法，使得程序不崩溃的情况下获得异常，并且保证只是使得前端无返回内容，而引起这个服务器的崩溃

改写user.go

func (u UserController) GetList(c *gin.Context) {//ReturnError(c *gin.Context, code int, msg string)defer func() {if err := recover(); err != nil {fmt.Println("捕获异常：", err)}}()num1, num2 := 1, 0num3 := num1 / num2ReturnUserGetListError(c, 404, num3)//<common.go>//func ReturnUserGetListError(c *gin.Context, code int, msg int) {//	json := &JsonErrStruct{Code: code, Msg: msg}//	c.JSON(http.StatusOK, json)//}}

运行结果

捕获异常： runtime error: integer divide by zero
[GIN] 2024/09/22 - 20:19:09 | 200 |            0s |       127.0.0.1 | POST     "/user/list"

日志

日志就是记录事件的记录表，主要分为以下三种

1. 项目的请求日志
2. 程序出现错误日志
3. 程序员开发的时候自己保存的日志

封装保存日志的包

1. 首先，创建一个pkg包，这个包的用途是防止开发时需要的工具。在pkg包下面创建一个子文件夹logger，用来存放日志工具，在这个子文件夹下创建logger.go文件
2. 之后，导入一下我们将要使用的日志工具包，在终端命令行输入go get github.com/sirupsen/logrus

文件结构

中间件logger.go内容

package loggerimport ("fmt""github.com/gin-gonic/gin""github.com/sirupsen/logrus""io""os""path""path/filepath""runtime/debug""time"
)// 初始化日志设置
func init() {// 设置日志的 JSON 格式logrus.SetFormatter(&logrus.JSONFormatter{TimestampFormat: "2006-01-02 15:04:05",})logrus.SetReportCaller(false)
}// 写入程序员自定义的日志
func Write(msg string, filename string) {setOutPutFile(logrus.InfoLevel, filename)logrus.Info(msg)
}// Debug 级别日志
func Debug(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.DebugLevel, "debug")logrus.WithFields(fields).Debug(args)
}// Info 级别日志
func Info(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.InfoLevel, "info")logrus.WithFields(fields).Info(args)
}// Warn 级别日志
func Warn(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.WarnLevel, "warn")logrus.WithFields(fields).Warn(args)
}// Fatal 级别日志
func Fatal(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.FatalLevel, "fatal")logrus.WithFields(fields).Fatal(args)
}// Error 级别日志
func Error(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.ErrorLevel, "error")logrus.WithFields(fields).Error(args)
}// Panic 级别日志
func Panic(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.PanicLevel, "panic")logrus.WithFields(fields).Panic(args)
}// Trace 级别日志
func Trace(fields logrus.Fields, args ...interface{}) {setOutPutFile(logrus.TraceLevel, "trace")logrus.WithFields(fields).Trace(args)
}// 设置日志输出文件 在各个函数方法中调用
func setOutPutFile(level logrus.Level, logName string) {// 创建日志目录logDir := "./runtime/log"if _, err := os.Stat(logDir); os.IsNotExist(err) {err = os.MkdirAll(logDir, 0777)if err != nil {panic(fmt.Errorf("create log dir '%s' error: %s", logDir, err))}}// 获取当前日期字符串timeStr := time.Now().Format("2006-01-02")fileName := filepath.Join(logDir, logName+"_"+timeStr+".log")// 打开日志文件，如果不存在则创建var err erroros.Stderr, err = os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)if err != nil {fmt.Println("open log file err:", err)}// 设置日志输出到文件logrus.SetOutput(os.Stderr)logrus.SetLevel(level)return
}// 创建了success开头的文件 在logger中以中间件的形式调用
func LoggerToFile() gin.LoggerConfig {logDir := "./runtime/log"if _, err := os.Stat(logDir); os.IsNotExist(err) {err = os.MkdirAll(logDir, 0777)if err != nil {panic(fmt.Errorf("create log dir '%s' error: %s", logDir, err))}}// 获取当前日期字符串timeStr := time.Now().Format("2006-01-02")fileName := path.Join(logDir, "success_"+timeStr+".log")os.Stdout, _ = os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)var conf = gin.LoggerConfig{Formatter: func(param gin.LogFormatterParams) string {return fmt.Sprintf("%s - [%s] \"%s %s %s %d %s \"%s\" %s\"\n",param.TimeStamp.Format(time.RFC1123),param.ClientIP,param.Method,param.Path,param.Request.Proto,param.StatusCode,param.Latency,param.Request.UserAgent(),param.ErrorMessage,)},Output: io.MultiWriter(os.Stdout, os.Stderr),}return conf
}// 将报错放在报文中返回回来 在logger中以中间件的形式调用
func Recover(c *gin.Context) {defer func() {if err := recover(); err != nil {if _, errDir := os.Stat("./runtime/log"); os.IsNotExist(errDir) {errDir := os.MkdirAll("./runtime/log", 0777)if errDir != nil {panic(fmt.Errorf("create log dir '%s' error: %s", "./runtime/log", err))}}timeStr := time.Now().Format("2006-01-02")//文件名fileName := path.Join("./runtime/log", timeStr+".log")f, errFile := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY|os.O_CREATE, 0644)if errFile != nil {fmt.Println(errFile)}timeFileStr := time.Now().Format("2006-01-02 15:04:05")//写入信息f.WriteString("panic error tome:" + timeFileStr + "\n")f.WriteString(fmt.Sprintf("%v", err) + "\n")f.WriteString("stacktrace from panic" + string(debug.Stack()) + "\n")f.Close()c.JSON(200, gin.H{"code": 500,"msg":  fmt.Sprintf("%v", err),})//终止后续接口调用，不加入recover到异常之后，还会继续执行接口中的后续代码c.Abort()}}()c.Next()
}

可以结合注释简单了解以下，然后cv使用即可

调用方式

对于前两种：项目的请求日志(LoggerToFile)和 程序出现错误日志(Recover)而言，调用的方式是在路由(router.go)的函数中以中间件的方式调用

//日志r.Use(gin.LoggerWithConfig(logger.LoggerToFile()))r.Use(logger.Recover)

而对于 程序员开发的时候自己保存的日志(setOutPutFile),则是以方法的形式在想要记录的函数(方法)中调用logger.Write("日志信息", "user")