新学golang，呕心沥血小几天，转载请务必附上本文连接。

可能有些地方写的不是很好，请在评论区指教一二～

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    _ "github.com/go-sql-driver/mysql"
    "github.com/jinzhu/gorm"
    "github.com/sirupsen/logrus"
    "net/http"
    "os"
    "strconv"
    "time"
)

//对应的实体类
type AppConf struct {
    Id      int    `gorm:"type:bigint(20);column:id;primary_key;AUTO_INCREMENT"`
    App_Id   int    `gorm:"type:bigint(20);column:app_id;not null"`
    Key     string `gorm:"type:varchar(255);column:key;not null"`
    Content string `gorm:"type:varchar(1500);column:content;not null"`
    Ctime   int    `gorm:"type:bigint(20);column:ctime;not null"`
    Utime   int    `gorm:"type:bigint(20);column:utime;not null"`
}

//声明全局数据库连接变量
var db *gorm.DB
var log = logrus.New()
func main() {
    defer db.Close()
    engine := gin.Default()
    engine.Use(LoggerToFile())
    routerGroup := engine.Group("/test")

    //查询所有数据
    routerGroup.GET("/appConfs", ListAll)

    //增加数据
    routerGroup.POST("/appConfs", Add)

    //删除数据
    routerGroup.DELETE("/appConfs/:id", Delete)

    //更新数据
    routerGroup.PATCH("/appConfs/:id", Update)
    engine.Run(":9999")

}

//初始化，创建连接
func init() {
    //连接mysql
    db, _ = gorm.Open("mysql", "root:123456(127.0.0.1:3306)/test?charset=utf8mb4&parseTime=True&loc=Local")
    LoggerToFile()
    //单对单
    db.SingularTable(true)
    //设置数据库连接池
    db.DB().SetMaxIdleConns(5)
    db.DB().SetMaxOpenConns(10)
}

//查询所有用户信息
func ListAll(context *gin.Context) {
    var (
        //定义数据表条数
        count int
        //为count传参
        appConfCount[] AppConf
    )

    //获取指定表的数据总条数
    err := db.Model(&appConfCount).Count(&count)
    if err != nil {
        context.JSON(http.StatusOK,gin.H{
            "code":401,
            "status":"error",
            "message":"空表 ！",
            "data":"null",
        })
    }
    //创建一个长度为0，容量为count的切片，使其避免扩容。    当时没用gorm，需要存到集合里，才会有扩容。下述不会
    var appConfs = make([]AppConf, 0, count)

    //查询数据表 app_conf
    rowsAffected:= db.Model(&AppConf{}).Find(&appConfs).RowsAffected
    if rowsAffected > 0 {

        context.JSON(http.StatusOK,gin.H{
            "code":200,
            "status":"success",
            "data":appConfs,
        })
    }else {
        context.JSON(http.StatusOK,gin.H{
            "code":401,
            "status":"error",
            "message":"空表 ！",
            "data":"null",
        })
    }
}

//新增数据
func Add(context *gin.Context) {
    var appConf AppConf

    //绑定结构体
    context.Bind(&appConf)

    fmt.Println(appConf)
    //若id一样，则添加失败
    rowsAffected := db.Model(&AppConf{}).Create(&appConf).RowsAffected
    if rowsAffected > 0 {
        context.JSON(http.StatusOK,gin.H{
            "code":200,
            "status":"success",
            "message":"添加成功 ！",
        })
    }else {
        context.JSON(http.StatusOK, gin.H{
            "code":401,
            "status":"error",
            "message": "添加失败",
        })
    }
}

//根据id删除数据
func Delete(context *gin.Context) {
    id := context.Param("id")
    //sting装int
    s,_ := strconv.Atoi(id)
    rowsAffected := db.Model(&AppConf{}).Where(&AppConf{Id: s}).Delete(&AppConf{}).RowsAffected

    //fmt.Println(rowsAffected)
    if rowsAffected > 0 {
        context.JSON(http.StatusOK,gin.H{
            "code":200,
            "status":"success",
            "message":"删除成功",
        })
    } else {
        context.JSON(http.StatusOK,gin.H{
            "code":401,
            "status":"error",
            "message":"删除失败",
        })
    }
}

//根据id修改信息
func Update(context *gin.Context) {
    var appConf AppConf
    id := context.Param("id")
    s,_ := strconv.Atoi(id)
    //绑定结构体
    context.Bind(&appConf)
    rowsAffected := db.Model(&AppConf{}).Where(&AppConf{Id: s}).Update(&appConf).RowsAffected
    if rowsAffected > 0 {
        context.JSON(http.StatusOK,gin.H{
            "code":200,
            "status":"success",
            "message":"更新成功",
        })
    } else {
        context.JSON(http.StatusOK,gin.H{
            "code":401,
            "status":"error",
            "message":"更新失败",
        })
    }
}


func LoggerToFile() gin.HandlerFunc {

    fileName := "./logger.log"
    //写入文件
    src, err := os.OpenFile(fileName, os.O_APPEND|os.O_WRONLY, os.ModeAppend)
    if err != nil {
        fmt.Println("err", err)
    }

    //实例化
    logger := logrus.New()

    //设置输出
    logger.Out = src

    //设置日志级别
    logger.SetLevel(logrus.DebugLevel)

    //处理日期格式

    logger.SetFormatter(&logrus.TextFormatter{
        TimestampFormat:"2006-01-01 15:04:05",
    })

    //设置日志格式
logger.SetFormatter(&logrus.JSONFormatter{})

    return func(c *gin.Context) {
        // 开始时间
        startTime := time.Now()
        // 处理请求
        c.Next()
        // 结束时间
        endTime := time.Now()
        // 执行时间
        latencyTime := endTime.Sub(startTime)
        latencyTime2 := float32(latencyTime) / float32(1000000)
        // 请求方式
        reqMethod := c.Request.Method
        // 请求路由
        reqUri := c.Request.RequestURI
        // 状态码
        statusCode := c.Writer.Status()
        // 请求IP
        clientIP := c.Request.Host
        // 日志格式
        logger.WithFields(logrus.Fields{
            "status_code"  : statusCode,
            "latency_time" : latencyTime2,
            "client_ip"    : clientIP,
            "req_method"   : reqMethod,
            "req_uri"      : reqUri,
        }).Info()
    }
}