gin框架精通篇（一）

日志框架logrus（一）

package main

import (
	"fmt"
	"github.com/gin-gonic/gin"   // 引入 gin web框架
	"github.com/sirupsen/logrus" // 引入 logrus 日志库
	"net/http"
	"os"
)

// 全局变量，创建 logrus 的新实例，用于记录日志
var log = logrus.New()

// initLogrus 初始化日志系统
func initLogrus() error {
	log.Formatter = &logrus.JSONFormatter{} // 设置日志格式为 JSON
	// 打开文件（没有就创建），以追加、创建和写入模式打开或创建日志文件
	file, err := os.OpenFile("./gin_log.log", os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		// 如果创建文件或者打开文件失败，打印错误提示并返回错误
		fmt.Println("创建文件/打开文件失败！")
		return err
	}

	// 设置 logrus 实例的输出为日志文件
	log.Out = file

	// 设置 gin web 框架的运行模式为 ReleaseMode，通常用于产品部署时减少日志输出和调试信息
	gin.SetMode(gin.ReleaseMode)
	// 将 gin 框架的默认日志写入到 logrus 设置的输出中去，使得 gin 框架日志与业务日志同步
	gin.DefaultWriter = log.Out
	// 设置日志级别为 InfoLevel，此级别下，只有 Info 及以上级别的日志会被输出
	log.Level = logrus.InfoLevel
	return nil
}

func main() {
	// 初始化 logrus 日志设置
	err := initLogrus()
	if err != nil {
		// 初始化失败，输出错误信息后返回
		fmt.Println(err)
		return
	}

	// 创建一个默认的 gin 路由器实例
	r := gin.Default()
	// 响应 GET 请求，路径为 "/logrus"，后面的匿名函数为处理该路径请求的回调函数
	r.GET("/logrus", func(context *gin.Context) {
		// 使用 logrus 记录请求的相关信息
		log.WithFields(logrus.Fields{
			"url":    context.Request.RequestURI,    // 请求的 URL
			"method": context.Request.Method, // 请求的方法，如 GET、POST 等
			"params": context.Query("name"),  // 请求的查询参数
			"IP":     context.ClientIP(),     // 发起请求的客户端 IP
		}).Info() // 将这些字段信息打印为 Info 级别的日志

		// 定义响应数据结构，并初始化值
		resData := struct {
			Code int         `json:"code"` // 响应状态码
			Msg  string      `json:"msg"`  // 响应信息
			Data interface{} `json:"data"` // 响应数据
		}{http.StatusOK, "响应成功", "OK"}

		// 使用 JSON 格式响应请求
		context.JSON(http.StatusOK, resData)
	})

	// 启动监听，并在 9090 端口上运行
	r.Run(":9090")
}

日志框架logrus（二）

package main

import (
	"fmt"
	// 引入必要的包
	// Gin框架用于Web服务器的构建和请求的处理
	"github.com/gin-gonic/gin"
	// file-rotatelogs用于日志文件的自动分割
	"github.com/lestrrat-go/file-rotatelogs"
	// lfshook用于为logrus提供钩子功能，根据日志级别输出到不同的目的地
	"github.com/rifflock/lfshook"
	// logrus是Go的一个结构化日志库，提供了比标准库更丰富的日志功能
	"github.com/sirupsen/logrus"
	"net/http"
	"os"
	"path"
	"time"
)

// 定义日志文件的路径和名称
var (
	logFilePath = "./"
	logFileName = "system.log"
)

func main() {
	// 创建Gin的路由器实例
	r := gin.Default()

	// 添加自定义的日志中间件
	r.Use(logMiddleware())

	// 处理GET请求，路径为"/logrus"
	r.GET("/logrus", func(context *gin.Context) {
		// 以JSON格式响应请求
		context.JSON(http.StatusOK, gin.H{
			"code": 200,
			"msg":  "响应成功",
			"data": "OK",
		})
	})

	// 在9090端口上启动服务器
	r.Run(":9090")
}

// logMiddleware返回一个实现了Gin的中间件HandlerFunc的函数
// 用来为每个请求记录日志
func logMiddleware() gin.HandlerFunc {
	// 拼接日志文件的完整路径
	fileName := path.Join(logFilePath, logFileName)

	// 尝试打开或创建日志文件
	file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0644)
	if err != nil {
		fmt.Println(err)
	}

	// 创建logrus的logger
	logger := logrus.New()

	// 设置日志级别为DebugLevel
	logger.SetLevel(logrus.DebugLevel)

	// 设置日志输出到上面打开的文件
	logger.Out = file

	// 配置日志文件的分割策略
	logWriter, err := rotatelogs.New(
		fileName+".%Y%m%d.log",
		rotatelogs.WithLinkName(fileName),        // 设置软连接指向最新的日志文件
		rotatelogs.WithMaxAge(7*24*time.Hour),    // 设置日志文件的最大保存时间
		rotatelogs.WithRotationTime(1*time.Hour)) // 设置日志分割的时间间隔

	// 定义将日志写入到分割的日志文件中
	writerMap := lfshook.WriterMap{
		logrus.InfoLevel:  logWriter, // 根据日志级别使用不同的输出
		logrus.FatalLevel: logWriter,
		logrus.DebugLevel: logWriter,
		logrus.WarnLevel:  logWriter,
		logrus.ErrorLevel: logWriter,
		logrus.PanicLevel: logWriter,
	}

	// 为logrus添加一个钩子，使用自定义的分割策略和JSON格式器
	logger.AddHook(lfshook.NewHook(writerMap, &logrus.JSONFormatter{
		TimestampFormat: "2024-05-06 15:49:50", // 自定义的时间戳格式
	}))

	// 返回一个Gin的中间件，记录每次请求的详细信息
	return func(context *gin.Context) {
		context.Next() // 处理请求的其它部分

		// 获取请求的一些基本信息
		method := context.Request.Method
		uri := context.Request.RequestURI
		code := context.Writer.Status()
		ip := context.ClientIP()

		// 使用这些信息打印日志
		logger.WithFields(logrus.Fields{
			"code":   code,
			"ip":     ip,
			"method": method,
			"uri":    uri,
		}).Info() // 记录日志
	}
}