新學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()
    }
}