利用gin搭建一个api框架

在demo1中，我们简单使用了net/http搭建了一个server，其实在日常开发中，比较少去使用标准库去直接写api，更多的是使用前人搭建好的轮子（我呢，是个不太喜欢重复造轮子的开发者，有开源的靠谱的，直接用就好，自己调整成自己需要的即可），那么说的go的框架，不得不说gin了。

对于gin的介绍，是github上star最多的go框架了，其他不多说，我们上手写起来吧！

目标：

自定义配置
整合mysql和Redis
独立路由管理
日志
平滑重启
脚本打包

使用到的库：

初始化

modules的引入之后，我们就可以不必使用gopath去管理项目目录了，对于modules的基本使用，建议看文章：

gomodules

我们开始：

go mod init sai0556/demo2-gin-frame

因为我们暂时本地开发：

PS：当时理解有误，其实无需做local.com替换，import直接使用sai0556/demo2-gin-frame即可，这里有点多余

// 使用本地module
go mod edit -require=local.com/sai0556/demo2-gin-frame@v1.0.0
go mod edit -replace=local.com/sai0556/demo2-gin-frame@v1.0.0=$PWD

可以看到go.mod已生成：

module sai0556/demo2-gin-frame

go 1.13

require local.com/sai0556/demo2-gin-frame v1.0.0

replace local.com/sai0556/demo2-gin-frame v1.0.0 => /Users/@/Work/golang/go-example/demo2-gin-frame

/Users/@/Work/golang/go-example/demo2-gin-frame 此目录就是项目目录，视具体情况不一

自定义配置与读取：

在我们使用Redis和mysql之前，我们先来读取一下配置，配置呢我们使用常见的yaml，当然你也可以使用其他，比如env等。

新建config目录，用来读取与监听配置文件(config.yaml)：

package config

import (
    "fmt"

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

type Config struct {
    Name string
}

// 对外的初始化配置方法
func Run(cfg string) error {
    c := Config{
        Name: cfg,
    }

    if err := c.init(); err != nil {
        return err
    }

    c.watchConfig()

    return nil
}

func (c *Config) init() error {
    if c.Name != "" {
        viper.SetConfigFile(c.Name)
    } else {
        // 默认配置文件是./config.yaml
        viper.AddConfigPath(".")
        viper.SetConfigName("config")
    }

    viper.SetConfigType("yaml")
    // viper解析配置文件
    err := viper.ReadInConfig() 
    if err != nil {
        panic(fmt.Errorf("Fatal error config file: %s \n", err))
    }

	// 简单打印下配置
    fmt.Println(viper.GetString("name"))

    return nil
}

func (c *Config) watchConfig() {
    viper.WatchConfig()
    viper.OnConfigChange(func(e fsnotify.Event) {
        fmt.Println("Config file changed:", e.Name)
    })
}

main:

package main

import (
    "github.com/spf13/pflag"

    "local.com/sai0556/demo2-gin-frame/config"
)

var (
    conf = pflag.StringP("config", "c", "", "config filepath")
)

func main() {
    pflag.Parse()

    // 初始化配置
    if err := config.Run(*conf); err != nil {
        panic(err)
    }

}

这里有用到大牛spf13的两个包，pflag和viper，命令行参数解析包pflag可以看作flag的进阶版本，在我们这里可以用来指定配置文件，viper是读取配置文件的包，配合fsnotify可以实现配置的热更新。（spf13大神还有其他有用的包，相信在你的go编码生涯会用到的）

写完我们可以运行一下：

go run main.go -c ./config.yaml

可以看到有打印出我们配置的name。

整合mysql与Redis

mysql包我们就选用gorm，Redis的使用比较多的是redigo和go-Redis，redigo曾在我使用中出现过问题，因而我们选择后者，后者也支持连接池。

mysql：

package db

import (
    "fmt"
    "sync"
    "errors"

    orm "github.com/jinzhu/gorm"
    _ "github.com/jinzhu/gorm/dialects/mysql"
    "github.com/spf13/viper"
)

type MySqlPool struct {}

var instance *MySqlPool
var once sync.Once

var db *orm.DB
var err error 

// 单例模式
func GetInstance() *MySqlPool {
    once.Do(func() {
        instance = &MySqlPool{}
    })

    return instance
}

func (pool *MySqlPool) InitPool() (isSuc bool) {
	// 这里有一种常见的拼接字符串的方式
    dsn := fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=%s", viper.GetString("db.username"), viper.GetString("db.password"), viper.GetString("db.host"), viper.GetString("db.name"), viper.GetString("db.charset"))
    db, err = orm.Open("mysql", dsn)
    if err != nil {
        panic(errors.New("mysql连接失败"))
        return false
    }

    // 连接数配置也可以写入配置，在此读取
    db.DB().SetMaxIdleConns(viper.GetInt("db.MaxIdleConns"))
    db.DB().SetMaxOpenConns(viper.GetInt("db.MaxOpenConns"))
    // db.LogMode(true)
    return true
}

后面获取连接池就可以直接使用 db.GetInstance()

Redis：

package db

import (
    "fmt"

    "github.com/spf13/viper"
    "github.com/go-Redis/Redis"
)

var RedisClient *Redis.Client

func InitRedis() {
    RedisClient = Redis.NewClient(&Redis.Options{
        Addr:     fmt.Sprintf("%s:%s", viper.GetString("Redis.host"), viper.GetString("Redis.port")),
        Password: viper.GetString("Redis.auth"),
        DB:       0,
    })

    _, err := RedisClient.Ping().Result()
    if err != nil {
        panic("Redis ping error")
    }
}

RedisClient就是我们后面可以用的Redis连接池。

在main中加入初始化连接池的代码即可：

// 连接mysql数据库
btn := db.GetInstance().InitPool()
if !btn {
    log.Println("init database pool failure...")
    panic(errors.New("init database pool failure"))
}

// Redis
db.InitRedis()

路由与控制器

为了方便路由，我们把路由管理单独到router。

package router

import (
    "net/http"

    "github.com/gin-gonic/gin"

    "local.com/sai0556/demo2-gin-frame/controller"
)

func Load(g *gin.Engine) *gin.Engine {
    g.Use(gin.Recovery())
    // 404
    g.NoRoute(func (c *gin.Context)  {
        c.String(http.StatusNotFound, "404 not found");
    })

    g.GET("/", controller.Index)

    return g
}

controller:

package controller

import (
    "net/http"

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

// 返回
type Response struct {
    Code int `json:"code"`
    Message string `json:"message"`
    Data interface{} `json:"data"`
}

// api返回结构
func ApiResponse(c *gin.Context, code int, message string, data interface{}) {
    c.JSON(http.StatusOK, Response{
        Code: code,
        Message: message,
        Data: data,
    })
}

func Index(c *gin.Context) {
    ApiResponse(c, 0, "success", nil)
}

到这呢，基本也就差不多了。

我们来看下完整的main：

package main

// import 这里我习惯把官方库，开源库，本地module依次分开列出
import (
    "log"
    "errors"

    "github.com/spf13/pflag"
    "github.com/spf13/viper"
    "github.com/gin-gonic/gin"

    "local.com/sai0556/demo2-gin-frame/config"
    "local.com/sai0556/demo2-gin-frame/db"
    "local.com/sai0556/demo2-gin-frame/router"
)

var (
    conf = pflag.StringP("config", "c", "", "config filepath")
)

func main() {
    pflag.Parse()

    // 初始化配置
    if err := config.Run(*conf); err != nil {
        panic(err)
	}
	
	// 连接mysql数据库
    btn := db.GetInstance().InitPool()
    if !btn {
        log.Println("init database pool failure...")
        panic(errors.New("init database pool failure"))
    }

    // Redis
    db.InitRedis()

    gin.SetMode(viper.GetString("mode"))
    g := gin.New()
    g = router.Load(g)
    g.Run(viper.GetString("addr"))
}

整合日志

这里我们先定义下log：

log:
  level: debug # 日志级别，info，debug，error
  file_format: "%Y%m%d" # 文件格式
  max_save_days: 30 # 保存天数
  file_type: one # one, level 单文件存储还是以level级别存储

整合logger：

package logger

import (
	"io"
	"log"
	"time"

	"github.com/lestrrat-go/file-rotatelogs"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
        "github.com/spf13/viper"
)

var Logger *zap.Logger 
var LogLevel string
var FileFormat string

// 初始化日志 logger
func init() {
	// 设置一些基本日志格式
	config := zapcore.EncoderConfig{
		MessageKey:  "msg",
		LevelKey:    "level",
		EncodeLevel: zapcore.CapitalLevelEncoder,
		TimeKey:     "ts",
		EncodeTime: func(t time.Time, enc zapcore.PrimitiveArrayEncoder) {
			enc.AppendString(t.Format("2006-01-02 15:04:05"))
		},
		CallerKey:    "file",
		EncodeCaller: zapcore.ShortCallerEncoder,
		EncodeDuration: func(d time.Duration, enc zapcore.PrimitiveArrayEncoder) {
			enc.AppendInt64(int64(d) / 1000000)
		},
	}
	encoder := zapcore.NewConsoleEncoder(config)

	FileFormat, saveType, LogLevel := "%Y%m%d", "one", "info"

	if viper.IsSet("log.file_format") {
		FileFormat = viper.GetString("log.file_format")
	}

	if viper.IsSet("log.level") {
		LogLevel = viper.GetString("log.level")
	}

	if viper.IsSet("log.save_type") {
		saveType = viper.GetString("log.save_type")
	}

	logLevel := zap.DebugLevel
	switch LogLevel {
		case "debug":
			logLevel = zap.DebugLevel
		case "info":
			logLevel = zap.InfoLevel
		case "error":
			logLevel = zap.ErrorLevel
		default:
			logLevel = zap.InfoLevel
	}

	switch saveType {
		case "level":
			Logger = getLevelLogger(encoder, logLevel, FileFormat)
		default:
			Logger = getOneLogger(encoder, logLevel, FileFormat)
	}

	
}

func getLevelLogger(encoder zapcore.Encoder, logLevel zapcore.Level, fileFormat string) *zap.Logger {
	infoLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl == zapcore.InfoLevel && lvl >= logLevel
	})

	debugLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl == zapcore.DebugLevel && lvl >= logLevel
	})

	errorLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl >= zapcore.ErrorLevel && lvl >= logLevel
	})
	// 获取 info、warn日志文件的io.Writer 抽象 getLoggerWriter() 在下方实现
	infoWriter := getLoggerWriter("./log/info", fileFormat)
	errorWriter := getLoggerWriter("./log/error", fileFormat)
	debugWriter := getLoggerWriter("./log/debug", fileFormat)

	// 最后创建具体的Logger
	core := zapcore.NewTee(
		zapcore.NewCore(encoder, zapcore.AddSync(debugWriter), debugLevel),
		zapcore.NewCore(encoder, zapcore.AddSync(infoWriter), infoLevel),
		zapcore.NewCore(encoder, zapcore.AddSync(errorWriter), errorLevel),
	)
	return zap.New(core, zap.AddCaller(), zap.AddStacktrace(zap.WarnLevel))
}

func getOneLogger(encoder zapcore.Encoder, logLevel zapcore.Level, fileFormat string) *zap.Logger {
	infoWriter := getLoggerWriter("./log/info", fileFormat)

	infoLevel := zap.LevelEnablerFunc(func(lvl zapcore.Level) bool {
		return lvl == zapcore.InfoLevel && lvl >= logLevel
	})

	core := zapcore.NewTee(
		zapcore.NewCore(encoder, zapcore.AddSync(infoWriter), infoLevel),
	)
	return zap.New(core, zap.AddCaller(), zap.AddStacktrace(zap.WarnLevel))
}

func getLoggerWriter(filename, fileFormat string) io.Writer {
	// 生成rotatelogs的Logger 实际生成的文件名 file_YYmmddHH.log
	hook, err := rotatelogs.New(
		filename+fileFormat+".log",
		rotatelogs.WithLinkName(filename),
		// 保存天数
		rotatelogs.WithMaxAge(time.Hour*24*30),
		// 切割频率24小时
		rotatelogs.WithRotationTime(time.Hour*24),
	)
	if err != nil {
		log.Println("日志启动异常")
		panic(err)
	}
	return hook
}

func Debug(format string, v ...interface{}) {
	Logger.Sugar().Debugf(format, v...)
}

func Info(format string, v ...interface{}) {
	Logger.Sugar().Infof(format, v...)
}

func Error(format string, v ...interface{}) {
	Logger.Sugar().Errorf(format, v...)
}

这里注意init函数，我们直接调用logger其中函数即可，程序加载包的过程中会自动执行init函数。关于init有以下说明：

init函数是用于程序执行前做包的初始化的函数，比如初始化包里的变量等
每个包可以拥有多个init函数
包的每个源文件也可以拥有多个init函数
同一个包中多个init函数的执行顺序go语言没有明确的定义(说明)
不同包的init函数按照包导入的依赖关系决定该初始化函数的执行顺序
init函数不能被其他函数调用，而是在main函数执行之前，自动被调用

我们直接使用：

logger.Info("i'm log123-----Info")
logger.Error("i'm log123-----Error")

平滑重启

当程序在线上稳定运行后，我们可能会去更新一些功能，但发布代码的同时，假如有用户正在使用，盲目发布代码可能会造成用户短暂失真，这时候平滑重启就来了。

对于平滑重启，其实有很多方案，这里我们只从自身代码级别来完成，而即便是代码级别，目前也有多种实现方案，比如第三方库endless这种，我这里主要参考了

https://github.com/kuangchanglang/gracefulgithub.com/kuangchanglang/graceful

简单说明下处理步骤：

监听信号（USR2，可自定义其他信号）
收到信号时fork子进程（使用相同的启动命令），将服务监听的socket文件描述符传递给子进程
子进程监听父进程的socket，这个时候父进程和子进程都可以接收请求
子进程启动成功之后，父进程停止接收新的连接，等待旧连接处理完成（或超时）
父进程退出，重启完成

详细分析可看底部参考-Golang服务器热重启、热升级、热更新。

启动检查

结合上面的优雅重启，我们在启动时配置上启动健康检查：

package main

// import 这里我习惯把官方库，开源库，本地module依次分开列出
import (
	"fmt"
	"time"
	"errors"
	"net/http"

    "github.com/spf13/pflag"
    "github.com/spf13/viper"
    "github.com/gin-gonic/gin"

    "local.com/sai0556/demo2-gin-frame/config"
    "local.com/sai0556/demo2-gin-frame/db"
    "local.com/sai0556/demo2-gin-frame/router"
    "local.com/sai0556/demo2-gin-frame/logger"
    "local.com/sai0556/demo2-gin-frame/graceful"
)

var (
    conf = pflag.StringP("config", "c", "", "config filepath")
)

func main() {
    pflag.Parse()

    // 初始化配置
    if err := config.Run(*conf); err != nil {
        panic(err)
	}

	// logger.Info("i'm log123-----Info")
	// logger.Error("i'm log123-----Error")

	
	// 连接mysql数据库
	DB := db.GetDB()
	defer db.CloseDB(DB)

	// Redis
	db.InitRedis()

	gin.SetMode(viper.GetString("mode"))
	g := gin.New()
	g = router.Load(g)

	// g.Run(viper.GetString("addr"))

	go func() {
		if err := pingServer(); err != nil {
			fmt.Println("fail:健康检测失败", err)
		}
		fmt.Println("success:健康检测成功")
	}()

	logger.Info("启动http服务端口%s\n", viper.GetString("addr"))

	if err := graceful.ListenAndServe(viper.GetString("addr"), g); err != nil && err != http.ErrServerClosed {
		logger.Error("fail:http服务启动失败: %s\n", err)
	}
}

// 健康检查
func pingServer() error {
	for i := 0; i < viper.GetInt("max_ping_count"); i++ {
		url := fmt.Sprintf("%s%s%s", "http://127.0.0.1", viper.GetString("addr"), viper.GetString("healthCheck"))
		fmt.Println(url)
		resp, err := http.Get(url)
		if err == nil && resp.StatusCode == 200 {
			return nil
		}
		time.Sleep(time.Second)
	}
	return errors.New("健康检测404")
}

这里就比较简单，另外启动一个协程，去ping健康检测的url即可。

打包脚本

shell

#!/bin/bash
SERVER="demo2-gin-frame"

function status() 
{
	if [ "`pgrep $SERVER -u $UID`" != "" ];then
		echo $SERVER is running
	else
		echo $SERVER is not running
	fi
}

function build() 
{
	echo "build..."

    CGO_ENABLED=0 GOOS=linux GOARCH=amd64 go build -o ./$SERVER main.go
    if [ $? -ne "0" ];then  
        echo "built error!!!"
        return 
    fi  

    echo "built success!"
}


case "$1" in
	'status')
	status
	;; 
    'build')
	build
	;;  
	*)  
	echo "unknown, please: $0 {status or build}"
	exit 1
	;;  
esac

bat

echo "build..."
SET CGO_ENABLED=0
SET GOOS=linux
go build -o demo2-gin-frame
if %errorlevel% == 0 (
    echo "built successfully"
) else (
    echo "built fail!!!"
)

对于程序的重启和保活，建议配合supervisor使用。

好，到这里我们的round 2就结束了。下一轮我们来玩玩钉钉智能机器人。

点击直达完整代码

参考：

goexample

#goexample

利用gin搭建一个api框架

https://blog.puresai.com/2021/02/12/goexample2/

作者

puresai

许可协议

防止漏打卡，利用gin和cron来做一个智能提醒上一篇

go面向对象下一篇