# /etc/profile
export GOROOT=/usr/local/go 
export PATH=$PATH:$GOROOT/bin
 

 brew install go
 
# 升级
 brew upgrade go

go
├── api # 用于存放依照 Go 版本顺序的 API 增量列表文件。这里所说的 API 包含公开的变量、常量、函数等。
# 这些 API 增量列表文件用于 Go 语言 API 检查
├── bin # 用于存放主要的标准命令文件（可执行文件），包含go、godoc、gofmt
├── blog # 用于存放官方博客中的所有文章
├── doc # 用于存放标准库的 HTML 格式的程序文档。我们可以通过godoc命令启动一个 Web 程序展示这些文档
├── lib # 用于存放一些特殊的库文件
├── misc # 用于存放一些辅助类的说明和工具
├── pkg # 用于存放安装Go标准库后的所有归档文件（以.a结尾的文件）。注意，你会发现其中有名称为linux_amd64
# 的文件夹，我们称为平台相关目录。这类文件夹的名称由对应的操作系统和计算架构的名称组合而
# 成。通过go install命令，Go程序会被编译成平台相关的归档文件存放到其中
├── src # 用于存放 Go自身、Go 标准工具以及标准库的所有源码文件
├── test
└── ... # 存放用来测试和验证Go本身的所有相关文件
 
# 在我们的可执行cli的bin 目录下它的结构有两个文件
_ go # 二进制可执行文件
_ gifmt # 格式化工具

# 下面 完整的表述了 了创建一个 工程 的所需要的初始化命令
$ mkdir go-gin-example && cd go-gin-example
 
$ go env -w GO111MODULE=on # 打开 Go modules 开关（目前在 Go1.13 中默认值为 auto）。
 
$ go env -w GOPROXY=https://goproxy.cn,direct 
# 置 GOPROXY 代理，这里主要涉及到两个值，第一个是 https://goproxy.cn，它是由七牛云背 
# 书的一个强大稳定的 Go 模块代理，可以有效地解决你的外网问题；第二个是 direct，它是一个特殊
# 的 fallback 选项，它的作用是用于指示 Go 在拉取模块时遇到错误会回源到模块版本的源地址去抓
# 取（比如 GitHub 等）。
 
$ go mod init github.com/EDDYCJY/go-gin-example # 初始化
# 主要 github.com/EDDYCJY/go-gin-example 填写的是模块引入路径，你可以根据自己的情况修改路径。
go: creating new go.mod: module github.com/EDDYCJY/go-gin-example
 
$ ls
go.mod

module  语句指定包的名字（路径）
require 语句指定的依赖项模块
replace 语句可以替换依赖项模块
exclude 语句可以忽略依赖项模块
 
# 一个类似的例子如下 
module github.com/EDDYCJY/go-gin-example // 当前mod 名字
 
go 1.12 // 依赖go的版本
 
// 工程需要指定的依赖
require (
	github.com/labstack/echo v3.3.10+incompatible // indirect 这个是不直接引用，而是传递下去
	github.com/labstack/gommon v0.2.8 // 这个是直接引用
	github.com/mattn/go-colorable v0.1.1 // indirect
	github.com/mattn/go-isatty v0.0.7 // indirect
	github.com/valyala/fasttemplate v1.0.0 // indirect
	golang.org/x/crypto v0.0.0-20190313024323-a1f597ede03a // indirect
)

go get [?xxx]
# 用 go get 拉取新的依赖
# 拉取最新的版本(优先择取 tag)：go get golang.org/x/text@latest
# 拉取 master 分支的最新 commit：go get golang.org/x/text@master
# 拉取 tag 为 v0.3.2 的 commit：go get golang.org/x/text@v0.3.2
# 拉取 hash 为 342b231 的 commit，最终会被转换为 v0.3.2：go get golang.org/x/text@342b2e
 
go get -u # 更新现有的依赖
go mod download # 下载 go.mod 文件中指明的所有依赖
go mod tidy # 整理现有的依赖 也可以自动的处理 代码中的 indirect/ 非indirect 报错
go mod graph # 查看现有的依赖结构
go mod init # 生成 go.mod 文件 (Go 1.13 中唯一一个可以生成 go.mod 文件的子命令)
go mod edit # 编辑 go.mod 文件
go mod vendor # 导出现有的所有依赖 (事实上 Go modules 正在淡化 Vendor 的概念)
go mod verify # 校验一个模块是否被篡改过
 
# 注意⚠️ 这个有一个issues
# https://github.com/golang/go/issues/52179  也许你不应该使用go get -u 而是使用
 
$ go get ./...
 

# 注意哈，我们继续沿用上面的 工程 
# install
go get -u github.com/gin-gonic/gin
 

package main
 
import "github.com/gin-gonic/gin"
 
func main() {
  r := gin.Default()
  r.GET("/ping", func(c *gin.Context) {
    c.JSON(200, gin.H{
      "message": "pong",
    })
  })
  r.Run() // listen and serve on 0.0.0.0:8080
}
 
// 返回json格式 {message ：pong }

-- 你需要用到的
 

go-gin-example/
├── conf
│   └── app.ini
├── main.go
├── middleware
├── models
│   └── models.go
├── pkg
│   ├── e
│   │   ├── code.go
│   │   └── msg.go
│   ├── setting
│   │   └── setting.go
│   └── util
│       └── pagination.go
├── routers
│   └── router.go
├── runtime

replace (
		github.com/EDDYCJY/go-gin-example/pkg/setting => ~/go-application/go-gin-example/pkg/setting
		github.com/EDDYCJY/go-gin-example/conf    	  => ~/go-application/go-gin-example/pkg/conf
		github.com/EDDYCJY/go-gin-example/middleware  => ~/go-application/go-gin-example/middleware
		github.com/EDDYCJY/go-gin-example/models 	  => ~/go-application/go-gin-example/models
		github.com/EDDYCJY/go-gin-example/routers 	  => ~/go-application/go-gin-example/routers
)
 
# 基本上 都是每一个 都需要自己去加一遍 ，截止2022/12/23 日这个不用自己写了 会自动处理
# 如果有问题请看 go 18 这种写法 replace github.com/golang-queue/queue => ../../

go get -u github.com/go-ini/ini

#debug or release
RUN_MODE = debug
 
[app]
PAGE_SIZE = 10
JWT_SECRET = 23347$040412
 
[server]
HTTP_PORT = 8000
READ_TIMEOUT = 60
WRITE_TIMEOUT = 60
 
[database]
TYPE = mysql
USER = 数据库账号
PASSWORD = 数据库密码
#127.0.0.1:3306
HOST = 数据库IP:数据库端口号
NAME = blog
TABLE_PREFIX = blog_

package setting
 
import (
	"log"
	"time"
 
	"github.com/go-ini/ini"
)
 
var (
	Cfg *ini.File
 
	RunMode string
 
	HTTPPort int
	ReadTimeout time.Duration
	WriteTimeout time.Duration
 
	PageSize int
	JwtSecret string
)
 
func init() {
	var err error
	Cfg, err = ini.Load("conf/app.ini")
	if err != nil {
		log.Fatalf("Fail to parse 'conf/app.ini': %v", err)
	}
 
	LoadBase()
	LoadServer()
	LoadApp()
}
 
func LoadBase() {
	RunMode = Cfg.Section("").Key("RUN_MODE").MustString("debug")
}
 
func LoadServer() {
	sec, err := Cfg.GetSection("server")
	if err != nil {
		log.Fatalf("Fail to get section 'server': %v", err)
	}
 
	HTTPPort = sec.Key("HTTP_PORT").MustInt(8000)
	ReadTimeout = time.Duration(sec.Key("READ_TIMEOUT").MustInt(60)) * time.Second
	WriteTimeout =  time.Duration(sec.Key("WRITE_TIMEOUT").MustInt(60)) * time.Second
}
 
func LoadApp() {
	sec, err := Cfg.GetSection("app")
	if err != nil {
		log.Fatalf("Fail to get section 'app': %v", err)
	}
 
	JwtSecret = sec.Key("JWT_SECRET").MustString("!@)*#)!@U#@*!@!)")
	PageSize = sec.Key("PAGE_SIZE").MustInt(10)
}

// code.go
package e
 
const (
	SUCCESS = 200
	ERROR = 500
	INVALID_PARAMS = 400
 
	ERROR_EXIST_TAG = 10001
	ERROR_NOT_EXIST_TAG = 10002
	ERROR_NOT_EXIST_ARTICLE = 10003
 
	ERROR_AUTH_CHECK_TOKEN_FAIL = 20001
	ERROR_AUTH_CHECK_TOKEN_TIMEOUT = 20002
	ERROR_AUTH_TOKEN = 20003
	ERROR_AUTH = 20004
)
 
// msg.go
package e
 
var MsgFlags = map[int]string {
	SUCCESS : "ok",
	ERROR : "fail",
	INVALID_PARAMS : "请求参数错误",
	ERROR_EXIST_TAG : "已存在该标签名称",
	ERROR_NOT_EXIST_TAG : "该标签不存在",
	ERROR_NOT_EXIST_ARTICLE : "该文章不存在",
	ERROR_AUTH_CHECK_TOKEN_FAIL : "Token鉴权失败",
	ERROR_AUTH_CHECK_TOKEN_TIMEOUT : "Token已超时",
	ERROR_AUTH_TOKEN : "Token生成失败",
	ERROR_AUTH : "Token错误",
}
 
func GetMsg(code int) string {
	msg, ok := MsgFlags[code]
	if ok {
		return msg
	}
 
	return MsgFlags[ERROR]
}

package util
 
import (
	"github.com/gin-gonic/gin"
	"github.com/unknwon/com"
 
	"github.com/EDDYCJY/go-gin-example/pkg/setting"
)
 
func GetPage(c *gin.Context) int {
	result := 0
	page, _ := com.StrTo(c.Query("page")).Int()
    if page > 0 {
        result = (page - 1) * setting.PageSize
    }
 
    return result
}

go get -u github.com/jinzhu/gorm
go get -u github.com/go-sql-driver/mysql

package models
 
import (
	"log"
	"fmt"
 
	"github.com/jinzhu/gorm"
	_ "github.com/jinzhu/gorm/dialects/mysql"
 
	"github.com/EDDYCJY/go-gin-example/pkg/setting"
)
 
var db *gorm.DB
 
type Model struct {
	ID int `gorm:"primary_key" json:"id"`
	CreatedOn int `json:"created_on"`
	ModifiedOn int `json:"modified_on"`
}
 
func init() {
	var (
		err error
		dbType, dbName, user, password, host, tablePrefix string
	)
 
	sec, err := setting.Cfg.GetSection("database")
	if err != nil {
		log.Fatal(2, "Fail to get section 'database': %v", err)
	}
 
	dbType = sec.Key("TYPE").String()
	dbName = sec.Key("NAME").String()
	user = sec.Key("USER").String()
	password = sec.Key("PASSWORD").String()
	host = sec.Key("HOST").String()
	tablePrefix = sec.Key("TABLE_PREFIX").String()
 
	db, err = gorm.Open(dbType, fmt.Sprintf("%s:%s@tcp(%s)/%s?charset=utf8&parseTime=True&loc=Local",
		user,
		password,
		host,
		dbName))
 
	if err != nil {
		log.Println(err)
	}
 
	gorm.DefaultTableNameHandler = func (db *gorm.DB, defaultTableName string) string  {
	    return tablePrefix + defaultTableName;
	}
 
	db.SingularTable(true)
	db.LogMode(true)
	db.DB().SetMaxIdleConns(10)
	db.DB().SetMaxOpenConns(100)
}
 
func CloseDB() {
	defer db.Close()
}

package routers
 
import (
    "github.com/gin-gonic/gin"
 
    "github.com/EDDYCJY/go-gin-example/pkg/setting"
)
 
func InitRouter() *gin.Engine {
    r := gin.New()
 
    r.Use(gin.Logger())
 
    r.Use(gin.Recovery())
 
    gin.SetMode(setting.RunMode)
 
    r.GET("/test", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "test",
        })
    })
 
    return r
}

package main
 
import (
	"fmt"
	"net/http"
 
	"github.com/EDDYCJY/go-gin-example/routers"
	"github.com/EDDYCJY/go-gin-example/pkg/setting"
)
 
func main() {
	router := routers.InitRouter()
 
	s := &http.Server{
		Addr:           fmt.Sprintf(":%d", setting.HTTPPort),
		Handler:        router,
		ReadTimeout:    setting.ReadTimeout,
		WriteTimeout:   setting.WriteTimeout,
		MaxHeaderBytes: 1 << 20,
	}
 
	s.ListenAndServe()
}

...
├── routers
│   ├── api
│   │   └── v1
│   │       └── tag.go
│   └── router.go
└── main.go
...

//  我们冲从底层开始先上构建，(这种思维方式是一个优秀程序员应该有的)
 
//tag.go
package v1
 
import (
    "github.com/gin-gonic/gin"
)
 
//获取多个文章标签
func GetTags(c *gin.Context) {
    
}
 
//新增文章标签
func AddTag(c *gin.Context) {
    
}
 
//修改文章标签
func EditTag(c *gin.Context) {
    
}
 
//删除文章标签
func DeleteTag(c *gin.Context) {
    
}
 
// router.go
package routers
 
import (
    "github.com/gin-gonic/gin"
 
    "gin-blog/routers/api/v1"
    "gin-blog/pkg/setting"
)
 
func InitRouter() *gin.Engine {
    r := gin.New()
 
    r.Use(gin.Logger())
 
    r.Use(gin.Recovery())
 
    gin.SetMode(setting.RunMode)
 
    apiv1 := r.Group("/api/v1")
    {
        //获取标签列表
        apiv1.GET("/tags", v1.GetTags)
        //新建标签
        apiv1.POST("/tags", v1.AddTag)
        //更新指定标签
        apiv1.PUT("/tags/:id", v1.EditTag)
        //删除指定标签
        apiv1.DELETE("/tags/:id", v1.DeleteTag)
    }
 
    return r
}
 
// main.go
 
 
 

package models
 
 
type Tag struct {
    Model
 
    Name string `json:"name"`
    CreatedBy string `json:"created_by"`
    ModifiedBy string `json:"modified_by"`
    State int `json:"state"`
}
 
// 这个是orm 在直线sql的时候的几个hook
func (tag *Tag) BeforeCreate(scope *gorm.Scope) error {
    scope.SetColumn("CreatedOn", time.Now().Unix())
 
    return nil
}
 
func (tag *Tag) BeforeUpdate(scope *gorm.Scope) error {
    scope.SetColumn("ModifiedOn", time.Now().Unix())
 
    return nil
}
 
 
// 由于我们声明了这个返回的tags，所以你不需要 显示的return
func GetTags(pageNum int, pageSize int, maps interface {}) (tags []Tag) {
    db.Where(maps).Offset(pageNum).Limit(pageSize).Find(&tags)
 
    return
}
 
func GetTagTotal(maps interface {}) (count int){
    db.Model(&Tag{}).Where(maps).Count(&count)
 
    return
}
 
func ExistTagByName(name string) bool {
    var tag Tag
    db.Select("id").Where("name = ?", name).First(&tag)
    if tag.ID > 0 {
        return true
    }
 
    return false
}
 
func AddTag(name string, state int, createdBy string) bool{
    db.Create(&Tag {
        Name : name,
        State : state,
        CreatedBy : createdBy,
    })
 
    return true
}
 
func ExistTagByID(id int) bool {
    var tag Tag
    db.Select("id").Where("id = ?", id).First(&tag)
    if tag.ID > 0 {
        return true
    }
 
    return false
}
 
func DeleteTag(id int) bool {
    db.Where("id = ?", id).Delete(&Tag{})
    return true
}
 
func EditTag(id int, data interface {}) bool {
    db.Model(&Tag{}).Where("id = ?", id).Updates(data)
    return true
}

// 关于gin如何取 参数我们来看下面的几种情形
// 1. query 参数 （不管是get/post/put/
r.POST("/test", func(ctx *gin.Context) {
 
    id := ctx.Query("id")
    page := ctx.DefaultQuery("page", "0")
 
    fmt.Printf("id: %s; page: %s; ", id, page)
 
    ctx.JSON(http.StatusOK, gin.H{
        "code": 200,
        "msg":  "success",
        "data": make(map[string]string),
    })
})
 
// 2. params 参数
r.POST("/test/:ids/my/:is", func(ctx *gin.Context) {
 
    ids := ctx.Param("ids")
    is := ctx.Param("is")
    // 通过这个方法可以获取到params的值 ，并且其它值也依然能够获取到
 
    id := ctx.Query("id")
    page := ctx.DefaultQuery("page", "0")
 
    name := ctx.PostForm("name") // xxxx
    message := ctx.PostForm("message")
 
    fmt.Printf("id: %s; page: %s; name: %s; message: %s;  ids : %s; is: %s", id, page, name, message, ids, is)
 
    ctx.JSON(http.StatusOK, gin.H{
        "code": 200,
        "msg":  "success",
        "data": make(map[string]string),
    })
})
 
// 3. header
	token := ctx.GetHeader("x-token")
    fmt.Printf("this is header x-token: %s \n", token)
// 这也就能获取这些数据了
 
// post put 请求等带在body中的参数类型
// 4. body- json参数
r.POST("/test/:ids/my/:is", func(ctx *gin.Context) {
 
    // 解析json 有多种方式，这里只讲一种 通过bindJson来解析json结构体
    //定义匿名结构体，字段与json字段对应
    var body struct {
        Email string `json:"email"`
        Name  string `json:"name"`
    }
    if err := ctx.BindJSON(&body); err != nil {
        return
    }
 
    fmt.Printf("email -> %s \n name -> %s", body.Email, body.Name)
 
    ctx.JSON(http.StatusOK, gin.H{
        "code": 200,
        "msg":  "success",
        "data": make(map[string]string),
    })
})
 
// 5. body- from-data (通用用于上传文件) 下面是个例子
r.POST("uploadFIles", func(c *gin.Context) {
		// 单文件
		// file, _ := c.FormFile("file")
		// log.Println(file.Filename)
 
		// dst := "./" + file.Filename
		// // 上传文件至指定的完整文件路径
		// c.SaveUploadedFile(file, dst)
 
		// 多文件
		// Multipart form
		form, _ := c.MultipartForm()
		files := form.File["upload[]"]
 
		for _, file := range files {
			log.Println(file.Filename)
 
		}
		c.String(http.StatusOK, fmt.Sprintf("%d files uploaded!", len(files)))
 
		// c.String(http.StatusOK, fmt.Sprintf("'%s' uploaded!", file.Filename))
	})
 
 
 
// 6. body- xxx-wwww-form-urllencoded
r.POST("/test", func(ctx *gin.Context) {
 
    id := ctx.Query("id")
    page := ctx.DefaultQuery("page", "0")
 
    fmt.Printf("id: %s; page: %s; name: %s; message: %s", id, page, name, message)
 
    ctx.JSON(http.StatusOK, gin.H{
        "code": 200,
        "msg":  "success",
        "data": make(map[string]string),
    })
})
 
 

type User struct {
	Name string
	Age int
}
 
// 简单的
u := User{"man", 40}
	valid := validation.Validation{}
	valid.Required(u.Name, "name")
	valid.MaxSize(u.Name, 15, "nameMax")
	valid.Range(u.Age, 0, 140, "age")
	if valid.HasErrors() {
		// validation does not pass
		// print invalid message
		for _, err := range valid.Errors {
			log.Println(err.Key, err.Message)
		}
	}
	// or use like this
	if v := valid.Max(u.Age, 140, "ageMax"); !v.Ok {
		log.Println(v.Error.Key, v.Error.Message)
	}
 
// 复杂的 实际上好像我们也不需要用到怎么负责的东西
type user struct {
	Id   int
	Name string `valid:"Required;Match(/^(test)?\\w*@;com$/)"`
	Age  int    `valid:"Required;Range(1, 140)"`
}
 
func main() {
	valid := validation.Validation{}
	// ignore empty field valid
	// see CanSkipFuncs
	// valid := validation.Validation{RequiredFirst:true}
	u := user{Name: "test", Age: 40}
	b, err := valid.Valid(u)
	if err != nil {
		// handle error
	}
	if !b {
		// validation does not pass
		// blabla...
	}
}
 
// 下面也许是一个奇怪的东西，但是你还是有可能会用到它
type user struct {
	Id   int
	Name string `valid:"Required;IsMe"`
	Age  int    `valid:"Required;Range(1, 140)"`
}
 
func IsMe(v *validation.Validation, obj interface{}, key string) {
	name, ok:= obj.(string)
	if !ok {
		// wrong use case?
		return
	}
 
	if name != "me" {
		// valid false
		v.SetError("Name", "is not me!")
	}
}
 
func main() {
	valid := validation.Validation{}
	if err := validation.AddCustomFunc("IsMe", IsMe); err != nil {
		// hadle error
	}
	u := user{Name: "test", Age: 40}
	b, err := valid.Valid(u)
	if err != nil {
		// handle error
	}
	if !b {
		// validation does not pass
		// blabla...
	}
}

func GetTags(c *gin.Context) {
    name := c.Query("name")
 
    maps := make(map[string]interface{})
    data := make(map[string]interface{})
 
    if name != "" {
        maps["name"] = name
    }
 
    var state int = -1
    if arg := c.Query("state"); arg != "" {
        state = com.StrTo(arg).MustInt() // com是一个非常简单高效的工具🔧
        maps["state"] = state
    }
 
    code := e.SUCCESS
 
    data["lists"] = models.GetTags(util.GetPage(c), setting.PageSize, maps)
    data["total"] = models.GetTagTotal(maps)
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : data,
    })
}
 
func AddTag(c *gin.Context) {
    name := c.Query("name")
    state := com.StrTo(c.DefaultQuery("state", "0")).MustInt()
    createdBy := c.Query("created_by")
 
    valid := validation.Validation{}
    valid.Required(name, "name").Message("名称不能为空")
    valid.MaxSize(name, 100, "name").Message("名称最长为100字符")
    valid.Required(createdBy, "created_by").Message("创建人不能为空")
    valid.MaxSize(createdBy, 100, "created_by").Message("创建人最长为100字符")
    valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if ! models.ExistTagByName(name) {
            code = e.SUCCESS
            models.AddTag(name, state, createdBy)
        } else {
            code = e.ERROR_EXIST_TAG
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : make(map[string]string),
    })
}
 
func EditTag(c *gin.Context) {
    id := com.StrTo(c.Param("id")).MustInt()
    name := c.Query("name")
    modifiedBy := c.Query("modified_by")
 
    valid := validation.Validation{}
 
    var state int = -1
    if arg := c.Query("state"); arg != "" {
        state = com.StrTo(arg).MustInt()
        valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
    }
 
    valid.Required(id, "id").Message("ID不能为空")
    valid.Required(modifiedBy, "modified_by").Message("修改人不能为空")
    valid.MaxSize(modifiedBy, 100, "modified_by").Message("修改人最长为100字符")
    valid.MaxSize(name, 100, "name").Message("名称最长为100字符")
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        code = e.SUCCESS
        if models.ExistTagByID(id) {
            data := make(map[string]interface{})
            data["modified_by"] = modifiedBy
            if name != "" {
                data["name"] = name
            }
            if state != -1 {
                data["state"] = state
            }
 
            models.EditTag(id, data)
        } else {
            code = e.ERROR_NOT_EXIST_TAG
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : make(map[string]string),
    })
}
 
//删除文章标签
func DeleteTag(c *gin.Context) {
    id := com.StrTo(c.Param("id")).MustInt()
 
    valid := validation.Validation{}
    valid.Min(id, 1, "id").Message("ID必须大于0")
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        code = e.SUCCESS
        if models.ExistTagByID(id) {
            models.DeleteTag(id)
        } else {
            code = e.ERROR_NOT_EXIST_TAG
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : make(map[string]string),
    })
}
 

go-gin-example/
├── conf
│   └── app.ini
├── main.go
├── middleware
├── models
│   ├── article.go
│   ├── models.go
│   └── tag.go
├── pkg
│   ├── e
│   │   ├── code.go
│   │   └── msg.go
│   ├── setting
│   │   └── setting.go
│   └── util
│       └── pagination.go
├── routers
│   ├── api
│   │   └── v1
│   │       ├── article.go
│   │       └── tag.go
│   └── router.go
├── runtime

package v1
 
import (
    "github.com/gin-gonic/gin"
)
 
//获取单个文章
func GetArticle(c *gin.Context) {
}
 
//获取多个文章
func GetArticles(c *gin.Context) {
}
 
//新增文章
func AddArticle(c *gin.Context) {
}
 
//修改文章
func EditArticle(c *gin.Context) {
}
 
//删除文章
func DeleteArticle(c *gin.Context) {
}

func InitRouter() *gin.Engine {
    ...
    apiv1 := r.Group("/api/v1")
    {
        ...
        //获取文章列表
        apiv1.GET("/articles", v1.GetArticles)
        //获取指定文章
        apiv1.GET("/articles/:id", v1.GetArticle)
        //新建文章
        apiv1.POST("/articles", v1.AddArticle)
        //更新指定文章
        apiv1.PUT("/articles/:id", v1.EditArticle)
        //删除指定文章
        apiv1.DELETE("/articles/:id", v1.DeleteArticle)
    }
 
    return r
}

-- 下面👇是一些sql 来构建 和查询多表
--（我们举个例子来看 User用户表，Order订单表，Orderdetail订单详情，item商品表 ）
-- 下面的关系如下： 一个用户对应多个订单，一个订单只能对应一个用户；一个订单对应多个订单详情，
-- 一个订单详情只对应一个订单；一个订单详情只对应一个商品，一个商品可以包括在多个订单详情中；
-- 所以，用户和商品之间是多对多关系
 
-- 进入mysql 创建一个库 用来做演示
CREATE DATABASE GODEMO;
SHOW DATANASES;
USE GODEMO;
 
-- 创建 几张关系表
-- 注意下面的几个语法说明
-- KEY `FK_user` (`user_id`) 设置外健名
 
-- 设置外健约束 
-- [CONSTRAINT <外键名>] FOREIGN KEY 字段名 [，字段名2，…] REFERENCES [关联到哪里去]
-- CONSTRAINT `FK_user` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`) 
 
-- 下面是一些可选项
-- on update cascade  同步更新
-- on delete cascade  同步删除
 
CREATE TABLE `user` (
  `id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户id(主键)',
  `username` varchar(32) NOT NULL COMMENT '客户名称',
  `birthday` date DEFAULT NULL COMMENT '客户生日',
  `sex` char(1) DEFAULT NULL COMMENT '客户性别',
  `address` varchar(256) DEFAULT NULL COMMENT '客户地址',
  PRIMARY KEY (`id`)
  -- ON UPDATE CASCADE 我这里就不加了
  -- ON DELETE CASCADE
) ENGINE=InnoDB AUTO_INCREMENT=8 DEFAULT CHARSET=utf8;
 
CREATE TABLE `orders` (
  `id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT '客户id(主键)',
  `user_id` bigint(32) NOT NULL COMMENT '下单客户id(外键)',
  `number` varchar(32) NOT NULL COMMENT '订单号',
  `createtime` datetime NOT NULL COMMENT '创建时间',
  `note` varchar(32) DEFAULT NULL COMMENT '备注',
  PRIMARY KEY (`id`),
    -- 建立索引（优化用）
  KEY `FK_user` (`user_id`),
    -- 建立外健约束
  CONSTRAINT `FK_user` FOREIGN KEY (`user_id`) REFERENCES `user` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=9 DEFAULT CHARSET=utf8;
 
CREATE TABLE `orderdetail` (
  `id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT 'id(主键)',
  `order_id` bigint(32) NOT NULL COMMENT '订单id',
  `item_id` bigint(32) NOT NULL COMMENT '商品id',
  `item_num` bigint(32) DEFAULT NULL COMMENT '商品购买数量',
  PRIMARY KEY (`id`),
  KEY `order_id` (`order_id`),
  KEY `orderdetail_ibfk_2_idx` (`item_id`),
  CONSTRAINT `orderdetail_ibfk_1` FOREIGN KEY (`order_id`) REFERENCES `orders` (`id`),
  CONSTRAINT `orderdetail_ibfk_2` FOREIGN KEY (`item_id`) REFERENCES `item` (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=18 DEFAULT CHARSET=utf8;
 
CREATE TABLE `item` (
  `id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT 'id(主键)',
  `name` varchar(32) NOT NULL COMMENT '商品名称',
  `price` float(10,1) NOT NULL COMMENT '商品价格',
  `detail` text COMMENT '商品描述',
  `pic` varchar(512) DEFAULT NULL COMMENT '商品图片',
  `createtime` datetime DEFAULT NULL COMMENT '生产日期',
  PRIMARY KEY (`id`)
) ENGINE=InnoDB AUTO_INCREMENT=5 DEFAULT CHARSET=utf8;
 
-- 注意这个表实际上没有什么特别大的意义，这里仅仅是演示
CREATE TABLE `usertoitem` (
  `id` bigint(32) NOT NULL AUTO_INCREMENT COMMENT 'id(主键)',
  `item_id` bigint(32) NOT NULL COMMENT '商品id',
  `user_id` bigint(32) NOT NULL COMMENT '用户id',
  PRIMARY KEY (`id`),
  CONSTRAINT `usertoitem_ibfk_1` FOREIGN KEY (`item_id`) REFERENCES `item`(`id`),
  CONSTRAINT `usertoitem_ibfk_2` FOREIGN KEY (`user_id`) REFERENCES `user`(`id`)
) ENGINE = InnoDB AUTO_INCREMENT = 5 DEFAULT CHARSET = utf8;
 
-- 简单的看看如何新增 数据 和查询数据 CURD (CR) --> UD 也类似 属于sql知识 这里不详细说明了 
-- 建立user 
INSERT INTO user (username, birthday, sex, address)
VALUES (
    'AIKEN',
    NOW(),
    2,
    'address:varchar'
  );
-- 建立item
SELECT *
FROM user
INSERT INTO item (name, price, detail, pic, createtime)
VALUES (
    'P3',
    111.3,
    'P3_',
    'P3_img',
    NOW()
  );
 
-- 创建一个order
INSERT INTO orders (user_id, number, createtime, note)
VALUES (
    8,
    '8u2uwbUBU',
    NOW(),
    'note:varchar'
  );
 
-- 给这个订单加三个item
INSERT INTO orderdetail (order_id, item_id, item_num)
VALUES (9, 5, 12423);
INSERT INTO orderdetail (order_id, item_id, item_num)
VALUES (9, 7, 12423);
INSERT INTO orderdetail (order_id, item_id, item_num)
VALUES (9, 7, 12423);
 
-- 给usertoitem 表添加数据 （下面仅仅是添加一条记录，你可以换item_id添加多条）
INSERT INTO usertoitem (item_id, user_id)
VALUES (
    6,
    10 
  );
 
-- 查询某用户的 orderDetail 
SELECT *
FROM orderdetail
  LEFT JOIN orders ON orderdetail.order_id = orders.id
  LEFT JOIN user ON orders.user_id = user.id
WHERE orders.user_id = 8;
 
-- 查询某用户的 所有item
SELECT * 
FROM usertoitem
  LEFT JOIN user ON user_id = user.id
  LEFT JOIN item ON usertoitem.item_id = item.id
WHERE user_id = 8;
 

// 通过前面的学习我们都明白了 gorm的一般操作。现在我们来看看关于gorm的多表操作
// 由于上面说的SQL 例子 么有办法用尽 gorm中的多表操作关系，所以我们依然以gorm官方为准
 
// BelongTo 这种模型的每一个实例都“属于”另一个模型的一个实例。
// `User` 属于 `Company`，`CompanyID` 是外键
type User struct {
  gorm.Model
  Name      string
  CompanyID int
  Company   Company
}
 
type Company struct {
  ID   int
  Name string
}
 
 
// has one 与另一个模型建立一对一的关联，但它和一对一关系有些许不同。 
// 这种关联表明一个模型的每个实例都包含或拥有另一个模型的一个实例。我们用 gorm的例子做说明
// User 有一张 CreditCard，UserID 是外键 且每个 user 只能有一张 credit card。
type User struct {
  gorm.Model
  CreditCard CreditCard
}
 
type CreditCard struct {
  gorm.Model
  Number string
  UserID uint // 这就是一对一 
}
 
// has Many 不同于 has one，拥有者可以有零或多个关联模型。 每个 user 可以有多张 credit card。
// User 有多张 CreditCard，UserID 是外键
type User struct {
  gorm.Model
  CreditCards []CreditCard
}
 
type CreditCard struct {
  gorm.Model
  Number string
  UserID uint
}
 
// Many to Many 会在两个 model 中添加一张连接表。GORM 会自动创建连接表
// User 拥有并属于多种 language，`user_languages` 是连接表
type User struct {
  gorm.Model
  Languages []Language `gorm:"many2many:user_languages;"`
}
 
type Language struct {
  gorm.Model
  Name string
}
 
// 自定义的中间表 （实际业务中 这种情况居多）
type Person struct {
  ID        int
  Name      string
  Addresses []Address `gorm:"many2many:person_addresses;"`
}
 
type Address struct {
  ID   uint
  Name string
}
 
type PersonAddress struct {
  PersonID  int `gorm:"primaryKey"`
  AddressID int `gorm:"primaryKey"`
  CreatedAt time.Time
  DeletedAt gorm.DeletedAt
}
 
func (PersonAddress) BeforeCreate(db *gorm.DB) error {
  // ...
}
 
// 修改 Person 的 Addresses 字段的连接表为 PersonAddress
// PersonAddress 必须定义好所需的外键，否则会报错
err := db.SetupJoinTable(&Person{}, "Addresses", &PersonAddress{})
 
 
// **创建数据和修改数据**
user := User{
  Name:            "jinzhu",
  BillingAddress:  Address{Address1: "Billing Address - Address 1"},
  ShippingAddress: Address{Address1: "Shipping Address - Address 1"},
  Emails:          []Email{
    {Email: "jinzhu@example.com"},
    {Email: "jinzhu-2@example.com"},
  },
  Languages:       []Language{
    {Name: "ZH"},
    {Name: "EN"},
  },
}
 
db.Create(&user) // 创建
db.Save(&user) // 更新
 
 
// **查询 📖注意 查询有很多方式我们举例几个好吧，剩下的在文档中**
db.Model(&user).Association("Languages").Find(&languages)
codes := []string{"zh-CN", "en-US", "ja-JP"}
db.Model(&user).Where("code IN ?", codes).Association("Languages").Find(&languages)
db.Model(&user).Where("code IN ?", codes).Order("code desc").Association("Languages").Find(&languages)
 
// 预加载一些数据
type User struct {
  gorm.Model
  Username string
  Orders   []Order
}
 
type Order struct {
  gorm.Model
  UserID uint
  Price  float64
}
 
// 查找 user 时预加载相关 Order
db.Preload("Orders").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4);
 
db.Preload("Orders").Preload("Profile").Preload("Role").Find(&users)
// SELECT * FROM users;
// SELECT * FROM orders WHERE user_id IN (1,2,3,4); // has many
// SELECT * FROM profiles WHERE user_id IN (1,2,3,4); // has one
// SELECT * FROM roles WHERE id IN (4,5,6); // belongs to
 
 

// 这里的例子是 关于tag 和 article 之间的关系，他们属于  belong to 
package models
 
import (
    "time"
 
    "github.com/jinzhu/gorm"
)
 
type Article struct {
    Model
 
    TagID int `json:"tag_id" gorm:"index"`//// 直接用它 做为外健 目前tag 和article ，为belong to 关系
·    Tag   Tag `json:"tag"` 
 
    Title string `json:"title"`
    Desc string `json:"desc"`
    Content string `json:"content"`
    CreatedBy string `json:"created_by"`
    ModifiedBy string `json:"modified_by"`
    State int `json:"state"`
}
 
 
// 是否已经存在
func ExistArticleByID(id int) bool {
    var article Article
    db.Select("id").Where("id = ?", id).First(&article)
 
    if article.ID > 0 {
        return true
    }
 
    return false
}
 
// 获取总数据
func GetArticleTotal(maps interface {}) (count int){
    db.Model(&Article{}).Where(maps).Count(&count)
 
    return
}
 
// 获取详情，用到了 预加载 和分页
func GetArticles(pageNum int, pageSize int, maps interface {}) (articles []Article) {
    db.Preload("Tag").Where(maps).Offset(pageNum).Limit(pageSize).Find(&articles)
 
    return
}
 
// 获取某文章具体详情 Related 查询
func GetArticle(id int) (article Article) {
    db.Where("id = ?", id).First(&article)
    db.Model(&article).Related(&article.Tag)
    // 补充一个话题 https://segmentfault.com/q/1010000021168438
/*
 
    db.Model(&user).Related(&company) user 是源，company 说 关联源中的字段名，这段
主要是意思是 查user -> company
 
    db.Model(&user).Association("company").Find(&company)
这段说的意思是 。company表是要查主表 源，主查company表。user实例只是条件填充对象
 
*/
    return
}
 
// 编辑
func EditArticle(id int, data interface {}) bool {
    db.Model(&Article{}).Where("id = ?", id).Updates(data)
 
    return true
}
 
// 新增
func AddArticle(data map[string]interface {}) bool {
    db.Create(&Article {
        TagID : data["tag_id"].(int),
        Title : data["title"].(string),
        Desc : data["desc"].(string),
        Content : data["content"].(string),
        CreatedBy : data["created_by"].(string),
        State : data["state"].(int),
    })
 
    return true
}
 
// 删除
func DeleteArticle(id int) bool {
    db.Where("id = ?", id).Delete(Article{})
 
    return true
}
 
// 两个model hook
func (article *Article) BeforeCreate(scope *gorm.Scope) error {
    scope.SetColumn("CreatedOn", time.Now().Unix())
 
    return nil
}
 
func (article *Article) BeforeUpdate(scope *gorm.Scope) error {
    scope.SetColumn("ModifiedOn", time.Now().Unix())
 
    return nil
}

package v1
 
import (
    "net/http"
    "log"
 
    "github.com/gin-gonic/gin"
    "github.com/astaxie/beego/validation"
    "github.com/unknwon/com"
 
    "github.com/EDDYCJY/go-gin-example/models"
    "github.com/EDDYCJY/go-gin-example/pkg/e"
    "github.com/EDDYCJY/go-gin-example/pkg/setting"
    "github.com/EDDYCJY/go-gin-example/pkg/util"
)
 
//获取单个文章
func GetArticle(c *gin.Context) {
    id := com.StrTo(c.Param("id")).MustInt()
 
    valid := validation.Validation{}
    valid.Min(id, 1, "id").Message("ID必须大于0")
 
    code := e.INVALID_PARAMS
    var data interface {}
    if ! valid.HasErrors() {
        if models.ExistArticleByID(id) {
            data = models.GetArticle(id)
            code = e.SUCCESS
        } else {
            code = e.ERROR_NOT_EXIST_ARTICLE
        }
    } else {
        for _, err := range valid.Errors {
            log.Printf("err.key: %s, err.message: %s", err.Key, err.Message)
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : data,
    })
}
 
//获取多个文章
func GetArticles(c *gin.Context) {
    data := make(map[string]interface{})
    maps := make(map[string]interface{})
    valid := validation.Validation{}
 
    var state int = -1
    if arg := c.Query("state"); arg != "" {
        state = com.StrTo(arg).MustInt()
        maps["state"] = state
 
        valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
    }
 
    var tagId int = -1
    if arg := c.Query("tag_id"); arg != "" {
        tagId = com.StrTo(arg).MustInt()
        maps["tag_id"] = tagId
 
        valid.Min(tagId, 1, "tag_id").Message("标签ID必须大于0")
    }
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        code = e.SUCCESS
 
        data["lists"] = models.GetArticles(util.GetPage(c), setting.PageSize, maps)
        data["total"] = models.GetArticleTotal(maps)
 
    } else {
        for _, err := range valid.Errors {
            log.Printf("err.key: %s, err.message: %s", err.Key, err.Message)
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : data,
    })
}
 
//新增文章
func AddArticle(c *gin.Context) {
    tagId := com.StrTo(c.Query("tag_id")).MustInt()
    title := c.Query("title")
    desc := c.Query("desc")
    content := c.Query("content")
    createdBy := c.Query("created_by")
    state := com.StrTo(c.DefaultQuery("state", "0")).MustInt()
 
    valid := validation.Validation{}
    valid.Min(tagId, 1, "tag_id").Message("标签ID必须大于0")
    valid.Required(title, "title").Message("标题不能为空")
    valid.Required(desc, "desc").Message("简述不能为空")
    valid.Required(content, "content").Message("内容不能为空")
    valid.Required(createdBy, "created_by").Message("创建人不能为空")
    valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if models.ExistTagByID(tagId) {
            data := make(map[string]interface {})
            data["tag_id"] = tagId
            data["title"] = title
            data["desc"] = desc
            data["content"] = content
            data["created_by"] = createdBy
            data["state"] = state
 
            models.AddArticle(data)
            code = e.SUCCESS
        } else {
            code = e.ERROR_NOT_EXIST_TAG
        }
    } else {
        for _, err := range valid.Errors {
            log.Printf("err.key: %s, err.message: %s", err.Key, err.Message)
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : make(map[string]interface{}),
    })
}
 
//修改文章
func EditArticle(c *gin.Context) {
    valid := validation.Validation{}
 
    id := com.StrTo(c.Param("id")).MustInt()
    tagId := com.StrTo(c.Query("tag_id")).MustInt()
    title := c.Query("title")
    desc := c.Query("desc")
    content := c.Query("content")
    modifiedBy := c.Query("modified_by")
 
    var state int = -1
    if arg := c.Query("state"); arg != "" {
        state = com.StrTo(arg).MustInt()
        valid.Range(state, 0, 1, "state").Message("状态只允许0或1")
    }
 
    valid.Min(id, 1, "id").Message("ID必须大于0")
    valid.MaxSize(title, 100, "title").Message("标题最长为100字符")
    valid.MaxSize(desc, 255, "desc").Message("简述最长为255字符")
    valid.MaxSize(content, 65535, "content").Message("内容最长为65535字符")
    valid.Required(modifiedBy, "modified_by").Message("修改人不能为空")
    valid.MaxSize(modifiedBy, 100, "modified_by").Message("修改人最长为100字符")
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if models.ExistArticleByID(id) {
            if models.ExistTagByID(tagId) {
                data := make(map[string]interface {})
                if tagId > 0 {
                    data["tag_id"] = tagId
                }
                if title != "" {
                    data["title"] = title
                }
                if desc != "" {
                    data["desc"] = desc
                }
                if content != "" {
                    data["content"] = content
                }
 
                data["modified_by"] = modifiedBy
 
                models.EditArticle(id, data)
                code = e.SUCCESS
            } else {
                code = e.ERROR_NOT_EXIST_TAG
            }
        } else {
            code = e.ERROR_NOT_EXIST_ARTICLE
        }
    } else {
        for _, err := range valid.Errors {
            log.Printf("err.key: %s, err.message: %s", err.Key, err.Message)
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : make(map[string]string),
    })
}
 
//删除文章
func DeleteArticle(c *gin.Context) {
    id := com.StrTo(c.Param("id")).MustInt()
 
    valid := validation.Validation{}
    valid.Min(id, 1, "id").Message("ID必须大于0")
 
    code := e.INVALID_PARAMS
    if ! valid.HasErrors() {
        if models.ExistArticleByID(id) {
            models.DeleteArticle(id)
            code = e.SUCCESS
        } else {
            code = e.ERROR_NOT_EXIST_ARTICLE
        }
    } else {
        for _, err := range valid.Errors {
            log.Printf("err.key: %s, err.message: %s", err.Key, err.Message)
        }
    }
 
    c.JSON(http.StatusOK, gin.H{
        "code" : code,
        "msg" : e.GetMsg(code),
        "data" : make(map[string]string),
    })
}

 
[app]
PageSize = 10
JwtSecret = 23347$040412
 
RuntimeRootPath = runtime/
 
PrefixUrl = http://127.0.0.1:8000
ImageSavePath = upload/images/
ExportSavePath = export/
QrCodeSavePath = qrcode/
LogSavePath = logs/
FontSavePath = fonts/
 
# MB
ImageMaxSize = 5
ImageAllowExts = .jpg,.jpeg,.png
 
LogSaveName = log
LogFileExt = log
TimeFormat = 20060102
 
[server]
#debug or release
RunMode = debug
HttpPort = 8000
ReadTimeout = 60
WriteTimeout = 60
 
[database]
Type = mysql
User = root
Password = rootroot
Host = 192.168.1.5:3306
Name = go_logs
TablePrefix = blog_
 
[redis]
Host = 192.168.1.5:6379
Password =
MaxIdle = 30
MaxActive = 30
IdleTimeout = 200
 
 

package setting
 
import (
	"log"
	"time"
 
	"github.com/go-ini/ini"
)
 
// 1.  编写与配置项保持一致的结构体（App、Server、Database， Redis）
// 2. 使用 MapTo 将配置项映射到结构体上 具体结构体的类型是怎么样子的需要看你自己的使用场景而定
// 3. 对一些需特殊设置的配置项进行再赋值
 
type App struct {
	JwtSecret       string // 下面的一些字段 你现在可能是不需要的，我们先配置在这里，
    // 后面你会使用它的
	PageSize        int
	RuntimeRootPath string
 
	PrefixUrl      string
	ImageSavePath  string
	ImageMaxSize   int
	ImageAllowExts []string
	FontSavePath   string
 
	ExportSavePath string
	QrCodeSavePath string
	LogSavePath    string
	LogSaveName    string
	LogFileExt     string
	TimeFormat     string
}
 
//⚠️ 为啥使用指针 
// 在 MapTo 中 typ.Kind() == reflect.Ptr 约束了必须使用指针，
// 否则会返回 cannot map to non-pointer struct 的错误。这个是表面原因
 
// 更往内探究，可以认为是 field.Set 的原因，
// 当执行 val := reflect.ValueOf(v) ，函数通过传递 v 拷贝创建了 val，go中传递的是值的拷贝
// 但是 val 的改变并不能更改原始的 v，要想 val 的更改能作用到 v，则必须传递 v 的地址
 
var AppSetting = &App{}
 
type Server struct {
	RunMode      string
	HttpPort     int
	ReadTimeout  time.Duration
	WriteTimeout time.Duration
}
 
var ServerSetting = &Server{}
 
type Database struct {
	Type        string
	User        string
	Password    string
	Host        string
	Name        string
	TablePrefix string
}
 
var DatabaseSetting = &Database{}
 
type Redis struct {
	Host        string
	Password    string
	MaxIdle     int
	MaxActive   int
	IdleTimeout time.Duration
}
 
var RedisSetting = &Redis{}
 
// 开始执行 主要的文档依据就是 go-ini 这个包
func Setup() {
	Cfg, err := ini.Load("conf/app.ini")
	if err != nil {
		log.Fatalf("Fail to parse 'conf/app.ini': %v", err)
	}
 
	err = Cfg.Section("app").MapTo(AppSetting)
	if err != nil {
		log.Fatalf("Cfg.MapTo AppSetting err: %v", err)
	}
 
	AppSetting.ImageMaxSize = AppSetting.ImageMaxSize * 1024 * 1024
 
	err = Cfg.Section("server").MapTo(ServerSetting)
	if err != nil {
		log.Fatalf("Cfg.MapTo ServerSetting err: %v", err)
	}
 
	ServerSetting.ReadTimeout = ServerSetting.ReadTimeout * time.Second // 对于time类型的需要 * 一个量 完成类型转化
	ServerSetting.WriteTimeout = ServerSetting.WriteTimeout * time.Second
 
	err = Cfg.Section("database").MapTo(DatabaseSetting)
	if err != nil {
		log.Fatalf("Cfg.MapTo DatabaseSetting err: %v", err)
	}
 
	err = Cfg.Section("redis").MapTo(RedisSetting)
	if err != nil {
		log.Fatalf("Cfg.MapTo RedisSetting err: %v", err)
	}
	RedisSetting.IdleTimeout = RedisSetting.IdleTimeout * time.Second
}