gin-start，实现一个通用的Gin项目模板

Gin 是一个用 Go (Golang) 编写的 web 框架，是性能和高效的追求者的不二选择。

随着开发的项目逐渐增多，现将一些经验整理出来，制作一个Gin项目的通用模板，欢迎大家一起学习讨论。

Github地址：https://github.com/melf-xyzh/gin-start

Gitee地址：https://gitee.com/melf-xyzh/gin-start

创建项目

1、在Goland中新建一个go项目，在环境输入框中配置代理：

https://goproxy.cn/

Helloworld 在项目根目录下新建main.go，输入如下内容：

package main

import (
    "net/http"
    "github.com/gin-gonic/gin"
)

func main() {
   // 创建路由
   r := gin.Default()
   // 绑定路由规则，执行的函数（gin.Context，封装了request和response）
   r.GET("/", func(c *gin.Context) {
      c.String(http.StatusOK, "hello World!")
   })
   // 3.监听端口，默认在8080，Run("里面不指定端口号默认为8080") 
   r.Run(":8000")
}

配置端口和路由

在项目根目录下新建config文件夹，在config文件夹新建Config.json输入如下内容：

{
  "Self": {
    "RouterHost": "0.0.0.0",
    "RouterPort": "2048"
  }
}

在config文件夹新建Config.go输入如下内容：

package config

import (
	"encoding/json"
	"fmt"
	"io/ioutil"
	"sync"
)

type GlobalConfig struct {
	Self     SelfConfig     `json:"Self"`
}

type SelfConfig struct {
	Host string `json:"RouterHost"`
	Port string `json:"RouterPort"`
}

var (
	globalConfig *GlobalConfig
	configMux    sync.RWMutex
)

func Config() *GlobalConfig {
	return globalConfig
}

// InitConfigJson
/**
 * @Description: 导入配置文件
 * @param fliepath config文件的路径
 * @return error 错误
 */
func InitConfigJson(fliepath string) error {
	var config GlobalConfig
	file, err := ioutil.ReadFile(fliepath)
	if err != nil {
		fmt.Println("配置文件读取错误,找不到配置文件", err)
		return err
	}

	if err = json.Unmarshal(file, &config); err != nil {
		fmt.Println("配置文件读取失败", err)
		return err
	}

	configMux.Lock()
	globalConfig = &config
	configMux.Unlock()
	return nil
}

修改main.go

func main() {
	//初始化配置文件
	err := config.InitConfigJson("config\Config.json")
	if err != nil {
		panic(err)
	}
}

在根目录下新建routers文件夹，在routers文件夹内新建Routers.go，输入如下内容：

package routers

import (
	"fmt"
	Config "gin-start/config"
	"github.com/gin-gonic/gin"
	"log"
	"net/http"
)

func Init() *gin.Engine {
	// 获取配置文件
	config := Config.Config()

	r := gin.Default()

	// 使用中间件
	r.Use(
	// 中间件
	)

	err := r.Run(fmt.Sprintf("%s:%s", config.Self.Host, config.Self.Port))
	if err != nil {
		log.Fatal("初始化路由出错")
	}
	return r
}

修改main.go中的路由配置：

func main() {
	// 初始化路由
	r := routers.Init()
	if err := r.Run(); err != nil {
		fmt.Printf("服务启动失败, 异常：%v\n", err)
	}
}

在根目录下新建template文件夹，用于存放tmpl文件

在根目录下新建static/css，static/js，static/img文件夹，用于存放静态文件

在Routers.go中配置模板路径和静态文件路径：

func Init() *gin.Engine {
	// 配置模板
	r.LoadHTMLGlob("./templates/**/*")
	// 配置静态文件夹路径 第一个参数是api，第二个是文件夹路径
	r.StaticFS("/static", http.Dir("./static"))
}

配置数据库连接池

在Config.json中添加数据库的配置：

{
  "Database": {
    "Type": "Mysql",
    "DbHost": "127.0.0.1",
    "DbPort": "3306",
    "DbUser": "root",
    "DbPassword": "123456789",
    "DbName": "gin-start",
    "MaxIdleConns": 10,
    "MaxOpenConns": 100,
    "ConnMaxLifetime": 1
  }
}

修改Config.go

type GlobalConfig struct {
	Database DatabaseConfig `json:"Database"`
	Self SelfConfig `json:"Self"`
}

type DatabaseConfig struct {
	Type            string `json:"Type"`            // 数据库类型
	DbHost          string `json:"DbHost"`          // 主机
	DbPort          string `json:"DbPort"`          // 端口
	DbUser          string `json:"DbUser"`          // 用户
	DbPassword      string `json:"DbPassword"`      // 密码
	DbName          string `json:"DbName"`          // 库名
	MaxIdleConns    int    `json:"MaxIdleConns"`    // 空闲连接池中连接的最大数量
	MaxOpenConns    int    `json:"MaxOpenConns"`    // 打开数据库连接的最大数量
	ConnMaxLifetime int    `json:"ConnMaxLifetime"` // 连接可复用的最大时间（小时）
}

在根目录新建models文件夹，在models文件夹中新建init.go，输入如下内容：

package models

import (
	"fmt"
	Config "gin-start/config"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"time"
)

var (
	DB *gorm.DB
)

// InitDB
/**
 * @Description: 初始化数据库
 * @return err 错误
 */
func InitDB() (err error) {
	// 获取配置文件
	config := Config.Config()

	switch config.Database.Type {
	case "Mysql":
		dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
			config.Database.DbUser, config.Database.DbPassword, config.Database.DbHost, config.Database.DbPort, config.Database.DbName,
		)
		fmt.Println("连接数据库")
		DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
		if err != nil {
			fmt.Println(err)
			//fmt.Println("数据库连接失败")
			panic("数据库连接失败")
		}
	default:
		dsn := fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?charset=utf8mb4&parseTime=True&loc=Local",
			config.Database.DbUser, config.Database.DbPassword, config.Database.DbHost, config.Database.DbPort, config.Database.DbName,
		)
		fmt.Println("连接数据库")
		DB, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
		if err != nil {
			fmt.Println(err)
			fmt.Println("数据库连接失败")
		}
	}

	// 维护连接池
	theDB, _ := DB.DB()
	// 设置空闲连接池中连接的最大数量
	theDB.SetMaxIdleConns(config.Database.MaxIdleConns)
	// 设置打开数据库连接的最大数量
	theDB.SetMaxOpenConns(config.Database.MaxOpenConns)
	// 设置了连接可复用的最大时间
	theDB.SetConnMaxLifetime(time.Hour * time.Duration(config.Database.ConnMaxLifetime))

	// 自动迁移
	err = DB.AutoMigrate(
	// 实体
	)
	if err != nil {
		fmt.Println(err)
		fmt.Println("自动迁移失败")
	}

	// 初始化数据表

	//测试连通性
	return nil
}

在main.go中添加初始化数据库连接池的 *** 作：

func main() {
	// 连接数据库
	errDB := myDB.InitDB()
	if errDB != nil {
		fmt.Println("数据库异常")
		//panic(err)
	}
}