好得很程序员自学网

<tfoot draggable='sEl'></tfoot>

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

安装驱动(如安装go-gorm/mysql则不需引入):

go  get  github测试数据/go-sql-driver/mysql

安装gorm:

github测试数据地址：

go  get  github测试数据/go-gorm/ gorm
go   get  github测试数据/go-gorm/mysql

官方地址：

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

go mod 依赖配置：

go mod tidy

根据需要创建数据库连接目录(dbtabases):

mysql.go连接文件：

 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)
    }
}

main.go文件：

 //  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  " )

2.数据表的增删改查实例：

创建一个测试表：

 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= ‘  测试表  ‘ ;

创建一个模型目录及对应控制器/模型文件(curd方法)：

模型test.go文件：

 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
}

控制器test.go文件：

 package controllers

import (
      "  gin_test/common  " 
     "  gin_test/models  " 
     "  github测试数据/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.go绑定：

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

数据测试列表：

Get: http://127.0.0.1:8088/test/list?page=1

数据测试添加：

Post: http://127.0.0.1:8088/test/create

数据测试更新：

Post: http://127.0.0.1:8088/test/update

数据测试删除：

Post: http://127.0.0.1:8088/test/update

数据表记录：

到此结束，这就是一个简单的curd使用。

 

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

标签：varchar   测试表   接收   mod   ted   结束   primary   idle   png   

查看更多关于Gin框架结合gorm实现mysql增删改查的详细内容...

声明：本文来自网络，不代表【好得很程序员自学网】立场，转载请注明出处：http://www.haodehen.cn/did116733
  阅读：39次

上一篇： 让MySql支持Emoji表情存储

下一篇：flink-sql解析canal-json实现实时同步