搭建go脚手架

最新推荐文章于 2024-06-03 21:45:37 发布

风落不归处

最新推荐文章于 2024-06-03 21:45:37 发布

阅读量1.6k

点赞数 3

分类专栏： go项目搭建文章标签： golang 开发语言后端

本文链接：https://blog.csdn.net/weixin_43893483/article/details/122523315

版权

go项目搭建专栏收录该内容

2 篇文章 0 订阅

订阅专栏

1. 创建目录结构

（1）conf：存放配置文件

（2）controller：路由请求处理

（3）logic：业务逻辑处理

（4）dao：数据库操作及数据库初始化

（5）setting：读取conf目录下的配置文件配置信息

（6）logger：zap日志及日志归档

（7）log：存放日志信息文件

（8）pkg：存放一些工具

（9）model：存放数据库、请求的一些结构体

（10）middleware：存放接口的中间件

2.配置项目的自动导入和代理路径

（1）配置代理路径

https://goproxy.cn,direct为七牛云的镜像，可以提高下载第三方依赖速度

（2）配置自动导入和自动格式化

go fmt：自动格式化

goimports：自动导入

如不能直接添加，则下载后配置

3.新建配置文件及配置文件读取

3.1 配置文件

// conf/config.yaml配置文件
app:
  name: "blog_api"
  mode: "dev"
  port: 3000

3.2 使用viper读取配置文件配置信息

// setting/setting.go

package setting

import (
   "fmt"

   "github.com/fsnotify/fsnotify"

   "github.com/spf13/viper"
)

//定义conf全局变量，用来保存程序所有的配置信息
var Conf = new(Config)

type Config struct {
   *AppConfig `mapstructure:"app"`
}
type AppConfig struct {
   Name string `mapstructure:"name"`
   Mode string `mapstructure:"mode"`
   Port int64  `mapstructure:"port"`
}

func Init(filePath string) (err error) {
   // 导入viper读取配置文件
   // 1. 配置文件类型
   viper.SetConfigType("yaml")

   // 2.配置文件的路径
   // 2.1：直接指定配置文件的路径
   // 相对路径：相对路径的可执行文件的相对路径
   // 绝对路径：系统中实际的文件路径
   //viper.SetConfigFile("./conf/config.yaml")
   // 2.2：指定配置文件名和配置文件的加载路径，viper自行查找可用的配置文件
   //  2.2.1 配置文件名
   //viper.SetConfigName("config")
   //  2.2.2 配置文件路径
   //viper.AddConfigPath("./conf")
   // 2.3：使用命令行输入指定配置文件目录
   viper.SetConfigFile(filePath)

   // 3.读取配置文件
   err = viper.ReadInConfig()
   if err != nil {
      //读取配置信息失败
      fmt.Printf("viper.ReadInConfig() failed...err=%v\n", err)
      return err
   }
   // 4.将配置信息反序列化到相应变量上
   if err = viper.Unmarshal(Conf); err != nil {
      fmt.Printf("viper.Unmarshal failed...err=%v\n", err)
      return err
   }
   // 5.监听并重新读取配置文件
   viper.WatchConfig() // 监听配置文件
   viper.OnConfigChange(func(e fsnotify.Event) {
      // 配置文件发生变更后会调用的回调函数
      fmt.Println("Config file changed...", e.Name)
      viper.Unmarshal(Conf)
   })
   fmt.Printf("reading config success...info：%v\nAppConfig：%v\n", Conf, Conf.AppConfig)
   return nil
}

4. 在配置文件中初始化配置信息

// main.go

package main

import (
   "blog_api/setting"
   "fmt"
   "os"
)

func main() {
   // 1.读取配置文件
   if len(os.Args) < 2 {
      fmt.Println("need config file.eg:blog_api config.yaml")
      return
   }
   if err := setting.Init(os.Args[1]); err != nil {
      fmt.Println("reading config file failed by viper...err=%v\n", err)
      return
   }
}

注释：这里读取配置文件采用的是直接指定配置文件路径，并结合args实现命令行指定配置文件路径

5.配置zap日志到gin框架

5.1 配置文件config.yaml中添加日志模块相关的配置信息

// conf/config.yaml
app:
  name: "blog_api"
  mode: "dev"
  port: 3000

log:
  level: "debug"
  filename: "./log/log.log"
  max_size: 200
  max_backups: 5
  max_age: 30

5.2 存放配置文件的结构体增加相应信息

// setting/setting.go

package setting

import (
   "fmt"

   "github.com/fsnotify/fsnotify"

   "github.com/spf13/viper"
)

//定义conf全局变量，用来保存程序所有的配置信息
var Conf = new(Config)

type Config struct {
   *AppConfig    `mapstructure:"app"`
   *LoggerConfig `mapstructure:"log"`
}
type AppConfig struct {
   Name string `mapstructure:"name"`
   Mode string `mapstructure:"mode"`
   Port int64  `mapstructure:"port"`
}
type LoggerConfig struct {
   Level      string `mapstructure:"level"`
   Filename   string `mapstructure:"filename"`
   MaxSize    int    `mapstructure:"max_size"`
   MaxBackups int    `mapstructure:"max_backups"`
   MaxAge     int    `mapstructure:"max_age"`
}

func Init(filePath string) (err error) {
   // 导入viper读取配置文件
   // 1. 配置文件类型
   viper.SetConfigType("yaml")

   // 2.配置文件的路径
   // 2.1：直接指定配置文件的路径
   // 相对路径：相对路径的可执行文件的相对路径
   // 绝对路径：系统中实际的文件路径
   //viper.SetConfigFile("./conf/config.yaml")
   // 2.2：指定配置文件名和配置文件的加载路径，viper自行查找可用的配置文件
   //  2.2.1 配置文件名
   //viper.SetConfigName("config")
   //  2.2.2 配置文件路径
   //viper.AddConfigPath("./conf")
   // 2.3：使用命令行输入指定配置文件目录
   viper.SetConfigFile(filePath)

   // 3.读取配置文件
   err = viper.ReadInConfig()
   if err != nil {
      //读取配置信息失败
      fmt.Printf("viper.ReadInConfig() failed...err=%v\n", err)
      return err
   }
   // 4.将配置信息反序列化到相应变量上
   if err = viper.Unmarshal(Conf); err != nil {
      fmt.Printf("viper.Unmarshal failed...err=%v\n", err)
      return err
   }
   // 5.监听并重新读取配置文件
   viper.WatchConfig() // 监听配置文件
   viper.OnConfigChange(func(e fsnotify.Event) {
      // 配置文件发生变更后会调用的回调函数
      fmt.Println("Config file changed...", e.Name)
      viper.Unmarshal(Conf)
   })
   fmt.Printf("reading config success...info：%v\nAppConfig：%v\nLoggerConfig：%v\n", Conf, Conf.AppConfig, Conf.LoggerConfig)
   return nil
}

5.3 logger文件配置相关信息

package logger

import (
   "blog_api/setting"
   "fmt"
   "os"

   "github.com/natefinch/lumberjack"
   "go.uber.org/zap"
   "go.uber.org/zap/zapcore"
)

var lg *zap.Logger

// Init 初始化logger
func Init(cfg *setting.LoggerConfig, mode string) (err error) {
   encoder := getEncoder()
   writeSyncer := getLogWriter(cfg)
   var l = new(zapcore.Level)
   if err = l.UnmarshalText([]byte(cfg.Level)); err != nil {
      return err
   }
   var core zapcore.Core
   fmt.Println("mode=", mode)
   if mode == "dev" {
      //开发模式，日志输出到终端
      consoleEncoder := zapcore.NewConsoleEncoder(zap.NewDevelopmentEncoderConfig())
      core = zapcore.NewTee(
         zapcore.NewCore(encoder, writeSyncer, l),
         zapcore.NewCore(consoleEncoder, zapcore.Lock(os.Stdout), zapcore.DebugLevel),
      )
   } else {
      core = zapcore.NewCore(encoder, writeSyncer, l)
   }
   // zap.AddCaller() 获取调用的文件、函数名，行号
   lg = zap.New(core, zap.AddCaller())
   // 替换zap中全局的logger
   zap.ReplaceGlobals(lg)
   zap.L().Info("init logger success!")
   return nil
}

// 1.配置Encoder：编码器，如何写入日志
func getEncoder() zapcore.Encoder {
   encoderConfig := zap.NewProductionEncoderConfig()
   encoderConfig.EncodeTime = zapcore.ISO8601TimeEncoder
   //encoderConfig.EncodeLevel = zapcore.CapitalLevelEncoder
   return zapcore.NewJSONEncoder(encoderConfig)
}

// 2.使用lumberjack配置writeSyncer和日志归档
func getLogWriter(cfg *setting.LoggerConfig) zapcore.WriteSyncer {
   lumberJackLogger := &lumberjack.Logger{
      Filename:   "./log/log.log",
      MaxSize:    cfg.MaxSize,
      MaxBackups: cfg.MaxBackups,
      MaxAge:     cfg.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)
      zap.L().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 {
               zap.L().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 {
               zap.L().Error("[Recovery from panic]",
                  zap.Any("error", err),
                  zap.String("request", string(httpRequest)),
                  zap.String("stack", string(debug.Stack())),
               )
            } else {
               zap.L().Error("[Recovery from panic]",
                  zap.Any("error", err),
                  zap.String("request", string(httpRequest)),
               )
            }
            c.AbortWithStatus(http.StatusInternalServerError)
         }
      }()
      c.Next()
   }
}

5.4 自定义gin框架默认日志中间件

// routes/routes.go

package routes

import (
   "blog_api/logger"
   "net/http"

   "github.com/gin-gonic/gin"
)

func Setup(mode string) *gin.Engine {
   if mode == gin.ReleaseMode {
      gin.SetMode(gin.ReleaseMode) // gin设置成发布模式，可以去除一些不必要的控制台输出
   }
   r := gin.New()
   // 配置gin框架默认的日志中间件
   r.Use(logger.Ginlogger(), logger.GinRecovery(true))
   r.NoRoute(func(c *gin.Context) {
      c.JSON(http.StatusNotFound, gin.H{
         "msg": "404",
      })
   })
   return r
}

5.5 初始化日志配置、并配置优雅关机

// main.go

package main

import (
   "blog_api/logger"
   "blog_api/routes"
   "blog_api/setting"
   "context"
   "fmt"
   "net/http"
   "os"
   "os/signal"
   "syscall"
   "time"

   "go.uber.org/zap"
)

func main() {
   // 1.初始化配置文件
   if len(os.Args) < 2 {
      fmt.Println("need config file.eg:blog_api config.yaml")
      return
   }
   if err := setting.Init(os.Args[1]); err != nil {
      fmt.Println("reading config file failed by viper...err=%v\n", err)
      return
   }
   // 2.初始化zap日志
   if err := logger.Init(setting.Conf.LoggerConfig, setting.Conf.AppConfig.Mode); err != nil {
      zap.L().Error("init logger failed...", zap.Error(err))
      return
   }
   defer zap.L().Sync() // 将缓存中的日志同步到日志文件中
   zap.L().Debug("init logger success!")
   // 注册路由
   r := routes.Setup(setting.Conf.AppConfig.Mode)
   // 启动服务（配置优雅关机）
   srv := &http.Server{
      Addr:    fmt.Sprintf(":%d", setting.Conf.AppConfig.Port),
      Handler: r,
   }
   // 等待中断信号来优雅地关闭服务器，为关闭服务器操作设置一个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")
}

6.配置mysql

6.1 配置mysql连接及关闭方法

// dao/mysql/mysql.go

package mysql

import (
   "blog_api/setting"
   "fmt"

   _ "github.com/go-sql-driver/mysql"
   "github.com/jmoiron/sqlx"
)

var db *sqlx.DB

func Init(cfg *setting.MySQLConfig) (err error) {
   dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8mb4&parseTime=True",
      cfg.User,
      cfg.Password,
      cfg.Host,
      cfg.Port,
      cfg.DBName,
   )
   db, err = sqlx.Connect("mysql", dsn) // sqlx.Connect会自动ping，检验是否连接成功
   if err != nil {
      return err
   }
   db.SetMaxOpenConns(cfg.MaxOpenConns) // 设置连接池最大链接数量
   db.SetMaxIdleConns(cfg.MaxIdleConns) // 设置连接池中最大闲置链接数量
   return nil
}

// Close 关闭MySQL连接
func Close() {
   _ = db.Close()
}

6.2 在main.go中初始化mysql配置

package main

import (
   "blog_api/dao/mysql"
   "blog_api/logger"
   "blog_api/routes"
   "blog_api/setting"
   "context"
   "fmt"
   "net/http"
   "os"
   "os/signal"
   "syscall"
   "time"

   "go.uber.org/zap"
)

func main() {
   // 1.初始化配置文件
   if len(os.Args) < 2 {
      fmt.Println("need config file.eg:blog_api config.yaml")
      return
   }
   if err := setting.Init(os.Args[1]); err != nil {
      fmt.Println("reading config file failed by viper...err=%v\n", err)
      return
   }
   // 2.初始化zap日志
   if err := logger.Init(setting.Conf.LoggerConfig, setting.Conf.AppConfig.Mode); err != nil {
      fmt.Println("init logger failed... err=%v", err)
      return
   }
   defer zap.L().Sync() // 将缓存中的日志同步到日志文件中
   zap.L().Debug("init logger success!")
   // 3.初始化mysql
   if err := mysql.Init(setting.Conf.MySQLConfig); err != nil {
      zap.L().Error("init mysql failed...", zap.Error(err))
      return
   }
   defer mysql.Close()
   zap.L().Debug("init mysql success")
   // 注册路由
   r := routes.Setup(setting.Conf.AppConfig.Mode)
   // 启动服务（配置优雅关机）
   srv := &http.Server{
      Addr:    fmt.Sprintf(":%d", setting.Conf.AppConfig.Port),
      Handler: r,
   }
   // 等待中断信号来优雅地关闭服务器，为关闭服务器操作设置一个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")
}

7.配置redis

7.1 配置redis连接池及关闭

// dao/redis/redis.go

package redis

import (
   "blog_api/setting"
   "fmt"
   "time"

   "github.com/garyburd/redigo/redis"
   "go.uber.org/zap"
)

var pool *redis.Pool

func Init(cfg *setting.RedisConfig) {
   pool = &redis.Pool{
      Dial: func() (redis.Conn, error) {
         var addr = fmt.Sprintf("%s:%d", cfg.Host, cfg.Port)
         conn, err := redis.Dial("tcp", addr)
         if err != nil {
            zap.L().Error("init reids failed...", zap.Error(err))
            return nil, err
         }
         zap.L().Debug("init redis success")
         return conn, nil
      },
      MaxActive:   cfg.MaxActive,                  // 最大空闲连接数
      MaxIdle:     cfg.MaxIdle,                    // 表示和数据库的最大链接数，0表示没有限制
      IdleTimeout: time.Duration(cfg.IdleTimeout), // 最大空闲时间，在100s内没有使用这个链接，就自动放回空闲链接数中
   }
}
func Close() {
   pool.Close() // 关闭链接池，一旦关闭链接池就不能够再从链接池中再去链接了
}

7.2 在main.go中初始化redis

package main

import (
   "blog_api/dao/mysql"
   "blog_api/dao/redis"
   "blog_api/logger"
   "blog_api/routes"
   "blog_api/setting"
   "context"
   "fmt"
   "net/http"
   "os"
   "os/signal"
   "syscall"
   "time"

   "go.uber.org/zap"
)

func main() {
   // 1.初始化配置文件
   if len(os.Args) < 2 {
      fmt.Println("need config file.eg:blog_api config.yaml")
      return
   }
   if err := setting.Init(os.Args[1]); err != nil {
      fmt.Println("reading config file failed by viper...err=%v\n", err)
      return
   }

   // 2.初始化zap日志
   if err := logger.Init(setting.Conf.LoggerConfig, setting.Conf.AppConfig.Mode); err != nil {
      fmt.Println("init logger failed... err=%v", err)
      return
   }
   defer zap.L().Sync() // 将缓存中的日志同步到日志文件中
   zap.L().Debug("init logger success!")

   // 3.初始化mysql
   if err := mysql.Init(setting.Conf.MySQLConfig); err != nil {
      zap.L().Error("init mysql failed...", zap.Error(err))
      return
   }
   defer mysql.Close()
   zap.L().Debug("init mysql success")

   //4.初始化redis
   redis.Init(setting.Conf.RedisConfig) // 初始化redis
   defer redis.Close() 
   // 注册路由
   r := routes.Setup(setting.Conf.AppConfig.Mode)
   // 启动服务（配置优雅关机）
   srv := &http.Server{
      Addr:    fmt.Sprintf(":%d", setting.Conf.AppConfig.Port),
      Handler: r,
   }
   // 等待中断信号来优雅地关闭服务器，为关闭服务器操作设置一个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")
}

7.3 配置完redis后启动服务

配置完redis连接池方法后启动服务，首先得开启redis，我这里使用的是windows版的redis，可以去官网下，如下图，直接双击启动即可。cli启动后的端口为我这里redis初始化连接的redis端口号

启动服务后，看不到redis里执行的zap.L().Debug方法中的日志信息，是因为并未开启一个redis链接，这里不多做演示。可以通过开启一个链接测试。

自此，一个简单的go脚手架基本搭建完成，后续可以再加入jwt、自定义go内置的validator验证的翻译等...

风落不归处

关注

3
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
搭建go脚手架

1. 创建目录结构（1）conf：存放配置文件（2）controller：路由请求处理（3）logic：业务逻辑处理（4）dao：数据库操作及数据库初始化（5）setting：读取conf目录下的配置文件配置信息（6）logger：zap日志及日志归档（7）log：存放日志信息文件2.配置项目的自动导入和代理路径（1）配置代理路径https://goproxy.cn,direct为七牛云的镜像，可以提高下载第三方依赖速度（2）配置自动导...
复制链接

扫一扫

专栏目录