Gin框架结合gorm实现mysql增删改查

go get github.com/go-sql-driver/mysql

go get github.com/go-gorm/gorm
go get github.com/go-gorm/mysql

go get gorm.io/gorm
go get gorm.io/gorm

go mod tidy

package databases

import (
    "fmt"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)

var Eloquent *gorm.DB

func init() {
    var err error
    //用户名:密码@tcp(数据库ip或域名:端口)/数据库名称?charset=数据库编码&parseTime=True&loc=Local
    dsn := "root:root@tcp(127.0.0.1:3306)/gin_test?charset=utf8&parseTime=True&loc=Local"
    Eloquent, err = gorm.Open(mysql.Open(dsn), &gorm.Config{})
    if err != nil {
        fmt.Printf("mysql connect error %v", err)
    }
    if Eloquent.Error != nil {
        fmt.Printf("database error %v", Eloquent.Error)
    }
}

//SetMaxIdleConns 是设置空闲时的最大连接数
//SetMaxOpenConns 设置与数据库的最大打开连接数
//SetConnMaxLifetime 每一个连接的生命周期等信息
sqlDB, err := orm.Eloquent.DB()
if err != nil {
    panic(err)
}
sqlDB.SetMaxIdleConns(5)
sqlDB.SetMaxOpenConns(10)
sqlDB.SetConnMaxLifetime(-1)
//延时调用函数
defer sqlDB.Close()
//注册路由
router := routers.RegisterRoutes()

// 绑定端口是8088
router.Run(":8088")

CREATE TABLE `tb_test` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT ‘主键id‘,
  `name` varchar(255) NOT NULL DEFAULT ‘‘ COMMENT ‘名称‘,
  `create_time` datetime NOT NULL COMMENT ‘创建时间‘,
  `update_time` timestamp NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT ‘更新时间‘,
  PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT=‘测试表‘;

package models

import (
    orm "gin_test/databases"
)

type TbTest struct {
    Id         int64  `gorm:"column:id;primary_key;auto_increment"`
    Name       string `gorm:"column:name;type:varchar(255);size(64);not null"`
    CreateTime string `gorm:"column:create_time;not null"`
    UpdateTime string `gorm:"column:update_time;not null"`
}

func (t *TbTest) TableName() string {
    return "tb_test"
}

func ListTest(datas []TbTest, page int) ([]TbTest, int64, error) {
    var pageSize = 2
    db := orm.Eloquent
    offset := (page - 1) * pageSize
    result := db.Order("id desc").Offset(offset).Limit(pageSize).Find(&datas)
    return datas, result.RowsAffected, result.Error
}

func CreateTest(data TbTest) (int64, error) {
    db := orm.Eloquent
    result := db.Create(&data)
    return data.Id, result.Error
}

func FindTest(id int64) (TbTest, error) {
    var model TbTest
    db := orm.Eloquent
    result := db.First(&model, id)
    return model, result.Error
}

func UpdateTest(data TbTest, id int64) (int64, error) {
    var model TbTest
    db := orm.Eloquent
    row := db.First(&model, id)
    if row.Error == nil {
        result := db.Model(&model).Updates(&data)
        return model.Id, result.Error
    }
    return 0, row.Error
}

func DeleteTest(id int64) (int64, error) {
    var model TbTest
    db := orm.Eloquent
    result := db.Delete(&model, id)
    return result.RowsAffected, result.Error
}

package controllers

import (
    "gin_test/common"
    "gin_test/models"
    "github.com/gin-gonic/gin"
    "net/http"
    "strconv"
)

// 定义接收数据的结构体
type TestData struct {
    // binding:"required"修饰的字段，若接收为空值，则报错，是必须字段
    Id   int64  `form:"id" json:"id" uri:"id" xml:"id"`
    Name string `form:"name" json:"name" uri:"name" xml:"name"`
}

func ListTest(c *gin.Context) {
    page, _ := strconv.Atoi(c.Query("page"))
    if page == 0 {
        page = 1
    }
    var list []models.TbTest
    res, rows, err := models.ListTest(list, page)
    if err != nil {
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "list": res, "pageTotal": rows})
    return
}

func CreateTest(c *gin.Context) {
    // 声明接收的变量
    var data TestData
    // 将request的body中的数据，自动按照json格式解析到结构体
    if err := c.ShouldBindJSON(&data); err != nil {
        // 返回错误信息
        // gin.H封装了生成json数据的工具
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    var model models.TbTest
    var time = common.GetTimeForm(common.GetTimestamp())
    model.Name = data.Name
    model.CreateTime = time
    model.UpdateTime = time
    if _, err := models.CreateTest(model); err != nil {
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "添加成功"})
    return
}

func UpdateTest(c *gin.Context) {
    // 声明接收的变量
    var data TestData
    // 将request的body中的数据，自动按照json格式解析到结构体
    if err := c.ShouldBindJSON(&data); err != nil {
        // 返回错误信息
        // gin.H封装了生成json数据的工具
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    var model models.TbTest
    res, err := models.FindTest(data.Id)
    if err != nil {
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    model.Name = data.Name
    if _, err := models.UpdateTest(model, res.Id); err != nil {
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "更新成功"})
    return
}

func DeleteTest(c *gin.Context) {
    // 声明接收的变量
    var data TestData
    // 将request的body中的数据，自动按照json格式解析到结构体
    if err := c.ShouldBindJSON(&data); err != nil {
        // 返回错误信息
        // gin.H封装了生成json数据的工具
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    if _, err := models.DeleteTest(data.Id); err != nil {
        c.JSON(http.StatusMovedPermanently, gin.H{"code:": 1, "msg: ": err.Error()})
        return
    }
    c.JSON(http.StatusOK, gin.H{"code": 0, "msg": "删除成功"})
    return
}

//测试-数据表增删改查
router.GET("/test/list", controllers.ListTest)
router.POST("/test/create", controllers.CreateTest)
router.POST("/test/update", controllers.UpdateTest)
router.POST("/test/delete", controllers.DeleteTest)