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

1. 在项目根目录下新建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")
}

配置端口和路由

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

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

2. 在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
   }
   

3. 修改main.go

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

4. 在根目录下新建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
   }
   

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

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

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

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

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

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

配置数据库连接池

1. 在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
     }
   }
   

2. 修改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"` // 连接可复用的最大时间（小时）
   }
   

3. 在根目录新建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
   }
   

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

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