go web脚手架工具开发（cld模式）

最新推荐文章于 2025-05-30 01:44:27 发布

小廖廖同学

最新推荐文章于 2025-05-30 01:44:27 发布

阅读量369

点赞数 11

文章标签： golang 后端 go 七米老师 web viper zap

本文链接：https://blog.csdn.net/2302_80467436/article/details/148309149

版权

1、加载配置

2、初始化日志

3、初始化mysql连接

4、初始化redis连接

5、注册路由

6、启动服务（优雅关机）

第一步：加载配置

首先新建一个settings文件，里面建一个settings.go，settings.go里面要做的就是用viper库去读取配置文件，代码如下：

package settings
import (
    "fmt"

    "github.com/fsnotify/fsnotify"
    "github.com/spf13/viper"

)


func Init()(err error){
    viper.SetConfigFile("./config.yaml") // 指定配置文件路径
    viper.SetConfigName("config") // 配置文件名称(无扩展名)
    viper.SetConfigType("yaml") // 如果配置文件的名称中没有扩展名，则需要配置此项(从etcd、consul等远程来的)
    viper.AddConfigPath(".")   // 查找配置文件所在的路径
    err = viper.ReadInConfig() // 查找并读取配置文件
    if err != nil { // 处理读取配置文件的错误
        fmt.Printf("viper.ReadInConfig fail %v",err)
        return 
    }
    //实时监控
    viper.WatchConfig()
    viper.OnConfigChange(func(e fsnotify.Event) {
    // 配置文件发生变更之后会调用的回调函数
        fmt.Println("Config file changed:", e.Name)
    })
    return err

}

这时配置文件就搞定了。

我们在全局新建一个config.yaml文件，里面写一些需要用到的参数：比如app、log、mysql、redis相关的

⭐⭐这里需要注意：每一个的冒号后面要加一个空格之后才能些写内容

app:
  name: "web_app"
  mode: "dev"
  port: 8081

log:
  level: "debug"
  filename: "web_app.log"
  max_size: 20
  max_age: 5
  max_backups: 3

mysql:
  host: "127.0.0.1"
  port: "3306"
  user: "root"
  password: "12345677"
  dbname: "user"
  max_open_conns: "10"
  max_idle_conns: "5"
redis:
  host: "127.0.0.1"
  port: 16379
  password: ""
  db: 0
  pool_size: 100

第二步：初始化日志

全局新建一个logger文件，里面建一个logger.go文件，里面需要实现的是在gin框架使用zap库来记录日志，代码如下：

package logger

import (
    //"web_app/config"
    "net"
    "net/http"
    "net/http/httputil"
    "os"
    "runtime/debug"
    "strings"
    "time"

    "github.com/gin-gonic/gin"
    "github.com/natefinch/lumberjack"
    "github.com/spf13/viper"
    "go.uber.org/zap"
    "go.uber.org/zap/zapcore"

)

var lg *zap.Logger

// InitLogger 初始化Logger
func Init() (err error) {
    writeSyncer := getLogWriter(viper.GetString("log.filename"), 
    viper.GetInt("log.max_size"), viper.GetInt("log.max_backups"), viper.GetInt("log.max_age"))
    encoder := getEncoder()
    var l = new(zapcore.Level)
    err = l.UnmarshalText([]byte(viper.GetString("log.Level")))
    if err != nil {
        return
    }
    core := zapcore.NewCore(encoder, writeSyncer, l)

    lg = zap.New(core, zap.AddCaller())
    zap.ReplaceGlobals(lg) // 替换zap包中全局的logger实例，后续在其他包中只需使用zap.L()调用即可
    return
}

func getEncoder() zapcore.Encoder {
    encoderConfig := zap.NewProductionEncoderConfig()
    encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
    encoderConfig.TimeKey = "time"
    encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
    encoderConfig.EncodeDuration = zapcore.SecondsDurationEncoder
    encoderConfig.EncodeCaller = zapcore.ShortCallerEncoder
    return zapcore.NewJSONEncoder(encoderConfig)
}

func getLogWriter(filename string, maxSize, maxBackup, maxAge int) zapcore.WriteSyncer {
    lumberJackLogger := &lumberjack.Logger{
        Filename:   filename,
        MaxSize:    maxSize,
        MaxBackups: maxBackup,
        MaxAge:     maxAge,
    }
    return zapcore.AddSync(lumberJackLogger)
}

// GinLogger 接收gin框架默认的日志
func GinLogger() gin.HandlerFunc {
    return func(c *gin.Context) {
        start := time.Now()
        path := c.Request.URL.Path
        query := c.Request.URL.RawQuery
        c.Next()

        cost := time.Since(start)
        lg.Info(path,
            zap.Int("status", c.Writer.Status()),
            zap.String("method", c.Request.Method),
            zap.String("path", path),
            zap.String("query", query),
            zap.String("ip", c.ClientIP()),
            zap.String("user-agent", c.Request.UserAgent()),
            zap.String("errors", c.Errors.ByType(gin.ErrorTypePrivate).String()),
            zap.Duration("cost", cost),
        )
    }
}

// GinRecovery recover掉项目可能出现的panic，并使用zap记录相关日志
func GinRecovery(stack bool) gin.HandlerFunc {
    return func(c *gin.Context) {
        defer func() {
            if err := recover(); err != nil {
                // Check for a broken connection, as it is not really a
                // condition that warrants a panic stack trace.
                var brokenPipe bool
                if ne, ok := err.(*net.OpError); ok {
                    if se, ok := ne.Err.(*os.SyscallError); ok {
                        if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
                            brokenPipe = true
                        }
                    }
                }

                httpRequest, _ := httputil.DumpRequest(c.Request, false)
                if brokenPipe {
                    lg.Error(c.Request.URL.Path,
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                    )
                    // If the connection is dead, we can't write a status to it.
                    c.Error(err.(error)) // nolint: errcheck
                    c.Abort()
                    return
                }

                if stack {
                    lg.Error("[Recovery from panic]",
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                        zap.String("stack", string(debug.Stack())),
                    )
                } else {
                    lg.Error("[Recovery from panic]",
                        zap.Any("error", err),
                        zap.String("request", string(httpRequest)),
                    )
                }
                c.AbortWithStatus(http.StatusInternalServerError)
            }
        }()
        c.Next()
    }
}

⭐⭐这里注意：上面的代码设置l全局变量lg，是为了替换zap包中全局的logger实例，后续在其他包中只需使用zap.L()调用即可

GinLogger和GinRecovery是重写原先gin自己的日志记录

第三步：初始化MySQL

新建一个dao文件，再建立一个mysql文件，在里面新建mysql.go，在这里面是为了实现mysql的连接，我们使用sqlx库来完成，代码如下：

package mysql

import (
    "fmt"

    _ "github.com/go-sql-driver/mysql" // 不要忘了导入数据库驱动
    "github.com/jmoiron/sqlx"
    "github.com/spf13/viper"
    "go.uber.org/zap"

)

var db *sqlx.DB

func Init() (err error) {
    dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True",
    viper.GetString("mysql.user"),
    viper.GetString("mysql.password"),
    viper.GetString("mysql.host"),
    viper.GetInt("mysql.port"),
    viper.GetString("mysql.dbname"),
    )
    // 也可以使用MustConnect连接不成功就panic
    db, err = sqlx.Connect("mysql", dsn)
    if err != nil {
        zap.L().Error("connect to mysql fail",zap.Error(err))
        return
    }
    db.SetMaxOpenConns(viper.GetInt("mysql.max_open_conns"))
    db.SetMaxIdleConns(viper.GetInt("mysql.max_idle_conns"))
    return
}
func Close(){
    _=db.Close()
}

⭐这里注意几个细节：

① 不要忘了导入数据库驱动：

_ "github.com/go-sql-driver/mysql" // 不要忘了导入数据库驱动

②采用zap.L().Error()来打印错误：

zap.L().Error("connect to mysql fail",zap.Error(err))

③由于在main函数中需要defer关闭，但是这里的db全局变量是小写的，在mian.go中调用不了，所以这里一个自己写一个close，类似一个接口实现close

第四步：初始化redis

在dao文件建立一个redis文件，再建一个redis.go，写如下代码：

package redis

import (
    "fmt"

    "github.com/go-redis/redis"
    "github.com/spf13/viper"

)
var rdb *redis.Client
func Init()(err error){
    rdb=redis.NewClient(&redis.Options{
        Addr:fmt.Sprintf("%s:%d",viper.GetString("redis.host"),viper.GetInt("redis.port")),
        Password:viper.GetString("redis.password"),
        DB:viper.GetInt("redis.db"),
        PoolSize: viper.GetInt("redis.pool_size"),
    })
    _,err=rdb.Ping().Result()
    return 
}
func Close(){
    _=rdb.Close()
}

redisd操作和mysql差不多，close等操作

第五步：注册路由

在全局建一个routes文件，里面建一个routes.go,里面实现路由的注册，代码如下：

package routes

import (
    "net/http"
    "web_app/logger"

    "github.com/gin-gonic/gin"

)
func Setup()*gin.Engine{
    r:=gin.New()
    r.Use(logger.GinLogger(),logger.GinRecovery(true))
    r.GET("/hello",func(c *gin.Context){
        c.String(http.StatusOK,"ok")
    })
    return r
}

⭐这里要注意的就是，因为是使用自己重写的logger和recovery，所以是使用gin.New()，之后.Use()，而不是使用gin.Default()

第六步：启动服务（实现优雅关机）

在全局的main.go中实现，实现代码如下：

srv := &http.Server{
    Addr:    viper.GetString("app.port"),
    Handler: r,
}

go func() {
    // 开启一个goroutine启动服务
    if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
        log.Fatalf("listen: %s\n", err)
    }
}()

// 等待中断信号来优雅地关闭服务器，为关闭服务器操作设置一个5秒的超时
quit := make(chan os.Signal, 1) // 创建一个接收信号的通道
// kill 默认会发送 syscall.SIGTERM 信号
// kill -2 发送 syscall.SIGINT 信号，我们常用的Ctrl+C就是触发系统SIGINT信号
// kill -9 发送 syscall.SIGKILL 信号，但是不能被捕获，所以不需要添加它
// signal.Notify把收到的 syscall.SIGINT或syscall.SIGTERM 信号转发给quit
signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)  // 此处不会阻塞
<-quit  // 阻塞在此，当接收到上述两种信号时才会往下执行
zap.L().Info("Shutdown Server ...")
// 创建一个5秒超时的context
ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
defer cancel()
// 5秒内优雅关闭服务（将未处理完的请求处理完再关闭服务），超过5秒就超时退出
if err := srv.Shutdown(ctx); err != nil {
    zap.L().Fatal("Server Shutdown: ", zap.Error(err))
}

zap.L().Info("Server exiting")

这样就实现了

第七步：在main.go中调用前面的方法

// 1、加载配置
if err:=settings.Init();err!=nil{
    fmt.Printf("init settings fail %err",err)
    return
}
// 2、初始化日志
if err:=logger.Init();err!=nil{
    fmt.Printf("init logger fail %err",err)
    return
}
defer zap.L().Sync()
zap.L().Debug("init logger success")
// 3、初始化mysql连接
if err:=mysql.Init();err!=nil{
    fmt.Printf("init mysql fail %err",err)
    return
}
defer mysql.Close()
// 4、初始化redis连接
if err:=redis.Init();err!=nil{
    fmt.Printf("init redis fail %err",err)
    return
}
defer redis.Close()
// 5、注册路由
r:=routes.Setup()

⭐这里需要注意几个地方：

①需要将日志移到磁盘：defer zap.L().Sync()

②需要defer关闭mysql和redis的连接