之前练手使用基于gin的go web项目

目录结构：

`-- demo
    |-- cmd
    |   |-- api.go
    |   `-- root.go
    |-- common
    |   `-- consts
    |       `-- consts.go
    |-- config
    |   `-- viper.go
    |-- config.toml
    |-- go.mod
    |-- go.sum
    |-- handler
    |   |-- jwt.go
    |   |-- h_hello.go
    |   |-- helper.go
    |-- main.go
    |-- model
    |   |-- db.go
    |   |-- m_user.go
    |   |-- helper.go
    |-- scripts
    |   |-- Readme.md
    |   |-- package_cms.sh
    |   `-- package_tar.sh
    |-- service
    |   |-- product_service.go
    `-- util

main.go

package main

import "demo/cmd"

var buildTime, gitHash string

func main() {
	cmd.Execute(buildTime, gitHash)
}

cmd/root.go

package cmd

import (
	"github.com/fatih/color"
	"github.com/spf13/cobra"
	"os"
	"demo/config"
	"demo/util/log"
	"runtime"
)

var rootCmd = &cobra.Command{
	Use:   "demo",
	Short: "demo",
	Long:  "demo",
	Run: func(cmd *cobra.Command, args []string) {
		if isShowVersion {
			color.HiYellow("Golang Env: %s %s/%s", runtime.Version(), runtime.GOOS, runtime.GOARCH)
			color.Cyan("UTC build time: %s", buildTime)
			color.Yellow("Build from repo version: %s", gitHash)

		}
	},
}

var buildTime, gitHash, configFile string
var verbose, isShowVersion bool

func Execute(bTime, gHash string) {
	buildTime = bTime
	gitHash = gHash
	if err := rootCmd.Execute(); err != nil {
		log.Error(err)
		os.Exit(1)
	}
}

func init() {
	cobra.OnInitialize(initFunc)
	rootCmd.Flags().BoolVarP(&isShowVersion, "version", "V", false, "show binary build infomation")
	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", true, "verbose")
	rootCmd.PersistentFlags().StringVar(&configFile, "config", "config", "config file path")
}

func initFunc() {
	config.InitViper(configFile)
}

package cmd

import (
	"fmt"
	"pms/config"
	"pms/handler"
	"pms/model"
	"pms/util/log"
	"time"

	"github.com/gin-contrib/sessions"
	"github.com/gin-contrib/sessions/cookie"
	"github.com/gin-gonic/gin"
	"github.com/go-co-op/gocron"
	"github.com/spf13/cobra"
)

var apiCmd = &cobra.Command{
	Use:   "api",
	Short: "run asset crawler api",
	Long:  "",
	Run: func(cmd *cobra.Command, args []string) {
		port := config.GetInt("app.port")
		addr := fmt.Sprintf("0.0.0.0:%d", port)
		log.Debug("start demo api...")
		if err := initDb(); err != nil {
			log.Fatal("数据库初始化失败:", err)
		}

		if err := initCorn(); err != nil {
			log.Fatal("定时任务注册失败:", err)
		}

		if err := runRESTFulAPI(addr); err != nil {
			log.Fatal("run pms api failed, err : ", err)
		}
	},
}

func init() {
	rootCmd.AddCommand(apiCmd)
}

func runRESTFulAPI(addr string) error {
	r := gin.New()
	registerGinHandler(r)
	return r.Run(addr)
}

func initDb() error {
	var db model.DB
	db = new(model.LocalDb)
	err := db.Create()
	if err != nil {
		fmt.Println("LocalDb 初始化连接失败")
		return err
	}
	//defer db.Close()

	db = new(model.ProductDb)
	if err := db.Create(); err != nil {
		fmt.Println("ProductDb 初始化连接失败")
		return err
	}
	//defer db.Close()
	return nil
}

func initCorn() error {
	timezone, _ := time.LoadLocation("Asia/Shanghai")
	s := gocron.NewScheduler(timezone)
	//每周五晚上10点准时打包
	timeStr := config.GetString("cron.tar_time_set")
	_, err := s.Every(1).Day().At(timeStr).Do(func() {
		go handler.ReleaseFromCorn()
	})
	if err != nil {
		fmt.Println("定时任务初始化失败", err)
	}
	s.StartAsync()
	return nil
}

// 注册路由
func registerGinHandler(r *gin.Engine) {
	apiG := r.Group("/api/v1")
	apiG.Use(crossDomainMiddleware())
	store := cookie.NewStore([]byte("demo"))
	apiG.Use(sessions.Sessions("sessions", store))
	apiG.GET("hello", handler.Hello)
	apiG.POST("login", handler.Login)
	apiG.Static("images", handler.GetImagePath())

	//登陆认证组
	loginG := apiG.Use(handler.JWTCheck())
	{
	    loginG.GET("auth_hello", handler.Hello)
	}
}

//跨域中间件
func crossDomainMiddleware() gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		c.Header("Access-Control-Allow-Origin", "*")
		c.Next()
		latency := time.Since(start)
		log.Infof("%s %s cost: %v.", c.Request.Method, c.Request.RequestURI, latency)
	}
}

config/config.go

package config

import (
	"github.com/spf13/viper"
	"demo/util/log"
)

func InitViper(configFile string) {
	viper.SetConfigName(configFile)
	viper.AddConfigPath(".")
	err := viper.ReadInConfig()
	if err != nil {
		log.Error("application configuration'initialization is failed ", err)
	}
}

func GetString(key string) string {
	return viper.GetString(key)
}

func GetInt(key string) int {
	return viper.GetInt(key)
}

func GetBool(key string) bool {
	return viper.GetBool(key)
}

func GetStringMapString(key string) map[string]string {
	return viper.GetStringMapString(key)
}

func GetStringSlice(key string) []string {
	return viper.GetStringSlice(key)
}

db.go

package model

import (
	"fmt"
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
	"github.com/sirupsen/logrus"
	"demo/config"
)

var db *gorm.DB
var productDb *gorm.DB

type DB interface {
	Create() error
	Close()
}

type LocalDb struct {
}

func (l LocalDb) Create() error {
	dbUser := config.GetString("db.user")
	dbHost := config.GetString("db.host")
	dbPassword := config.GetString("db.password")
	dbPort := config.GetInt("db.port")
	dbName := config.GetString("db.dbname")
	dbSqlMode := config.GetString("db.sql_mode")

	conn := fmt.Sprintf("%s:%s@(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local&sql_mode='%s'", dbUser, dbPassword, dbHost, dbPort, dbName, dbSqlMode)
	mysqlDb, err := gorm.Open("mysql", conn)
	if err != nil {
		return err
	}
	db = mysqlDb
	db.LogMode(true)
	logrus.New()
	return nil
}

func (l LocalDb) Close() {
	if db != nil {
		err := db.Close()
		if err != nil {
			logrus.WithError(err).Error("close LocalDb db failed")
		}
	}
}

model/jwt.go

package handler

import (
	"errors"
	"github.com/gin-gonic/gin"
	"demo/model"
	"strings"
)

const tokenPrefix = "Bearer "
const bearerLen = len(tokenPrefix)

func JWTCheck() gin.HandlerFunc {
	return func(c *gin.Context) {
		rawToken := c.GetHeader("Authorization")
		if len(rawToken) < bearerLen {
			handleErrorAuth(c, errors.New("未找到承载令牌"))
			return
		}

		token := strings.TrimSpace(rawToken[bearerLen:])
		uid, err := model.JwtParseUid(token)
		if handleErrorAuth(c, err) {
			return
		}

		c.Set(jwtAuthedUserIdKey, uid)
		c.Next()
	}
}

model/helper.go

package model

import (
	"errors"
	"fmt"
	"github.com/golang-jwt/jwt/v5"
	"github.com/sirupsen/logrus"
	"demo/config"
	"strconv"
	"time"
)

type jwtObj struct {
	User
	Token    string    `json:"token"`
	Expire   time.Time `json:"expire"`
	ExpireTs int64     `json:"expire_ts"`
}

func jwtGenerateToken(m *User) (*jwtObj, error) {
	m.Password = ""
	expireAfterTime := time.Hour * time.Duration(config.GetInt("app.jwt_expire_hour"))
	iss := config.GetString("app.name")
	appSecret := config.GetString("app.secret")
	expireTime := time.Now().Add(expireAfterTime)

	claim := jwt.RegisteredClaims{
		ExpiresAt: jwt.NewNumericDate(expireTime),
		NotBefore: jwt.NewNumericDate(time.Now()),
		IssuedAt:  jwt.NewNumericDate(time.Now()),
		Issuer:    iss,
		ID:        fmt.Sprintf("%d", m.ID),
	}

	token := jwt.NewWithClaims(jwt.SigningMethodHS256, claim)
	tokenString, err := token.SignedString([]byte(appSecret))
	if err != nil {
		logrus.WithError(err).Fatal("config is wrong, can not generate jwt")
	}
	data := &jwtObj{User: *m, Token: tokenString, Expire: expireTime, ExpireTs: expireTime.Unix()}
	return data, err
}

func JwtParseUid(tokenString string) (uint, error) {
	if tokenString == "" {
		return 0, errors.New("授权承载中未找到令牌")
	}
	token, err := jwt.ParseWithClaims(tokenString, &jwt.RegisteredClaims{}, func(token *jwt.Token) (interface{}, error) {
		if _, ok := token.Method.(*jwt.SigningMethodHMAC); !ok {
			return nil, fmt.Errorf("unexpected signing method: %v", token.Header["alg"])
		}
		secret := config.GetString("app.secret")
		return []byte(secret), nil
	})
	if err != nil {
		return 0, errors.New("token 解析失败" + err.Error())
	}

	if !token.Valid {
		if errors.Is(err, jwt.ErrTokenMalformed) {
			return 0, errors.New("token格式错误,无法解析")
		} else if errors.Is(err, jwt.ErrTokenExpired) || errors.Is(err, jwt.ErrTokenNotValidYet) {
			return 0, errors.New("token时效性错误")
		} else {
			return 0, errors.New("token非法")
		}
	}

	if claims, ok := token.Claims.(*jwt.RegisteredClaims); ok {
		uid, err := strconv.ParseUint(claims.ID, 10, 64)
		return uint(uid), err
	} else {
		return 0, errors.New("token claims解析失败")
	}
}

type Pagination struct {
	PageSize uint `json:"page_size" form:"page_size"`
	Page     uint `json:"page" form:"page"`
}

//FixPageAndSize
//修正分页的参数
func (p *Pagination) FixPageAndSize() {
	if p.PageSize == 0 {
		p.PageSize = 10
	}
	if p.Page == 0 {
		p.Page = 1
	}
}

handler/helper.go

package handler

import (
	"bytes"
	"crypto/md5"
	"encoding/hex"
	"encoding/xml"
	"errors"
	"fmt"
	"github.com/gin-gonic/gin"
	"io/ioutil"
	"net/http"
	"os"
	"os/exec"
	"pms/model"
	"pms/util/log"
	"reflect"
	"regexp"
	"strconv"
)

const (
	StatusOK        uint = 200
	StatusAuthError      = 300
	StatusError          = 400
)

func jsonError(c *gin.Context, status uint, msg string) {
	c.AbortWithStatusJSON(http.StatusOK, gin.H{"status": status, "msg": msg})
}
func jsonData(c *gin.Context, data interface{}) {
	c.AbortWithStatusJSON(http.StatusOK, gin.H{"status": StatusOK, "data": data})
}
func jsonPagination(c *gin.Context, list interface{}, total uint, p model.Pagination) {
	c.AbortWithStatusJSON(http.StatusOK, gin.H{"status": StatusOK, "data": list, "total": total, "page": p.Page, "page_size": p.PageSize})
}

func jsonErrorAuth(c *gin.Context, status uint, msg string) {
	c.AbortWithStatusJSON(http.StatusOK, gin.H{"status": status, "msg": msg})
}
func handleError(c *gin.Context, err error) bool {
	if err != nil {
		jsonError(c, StatusError, err.Error())
		return true
	}
	return false
}
func handleErrorAuth(c *gin.Context, err error) bool {
	if err != nil {
		jsonErrorAuth(c, StatusAuthError, err.Error())
		return true
	}
	return false
}