Gin篇：gorm 使用

89391311 • 2024年4月4日 pm2:00 • 代码分享 • 107 阅读

连接数据库

下面演示如果连接数据库，使用gorm.Open()方法可以初始化并返回一个gorm.DB结构体，这个结构体封装了GORM框架所有的数据库操作方法，下面是gorm.Open()方法的定义：

func Open(dialect string, args ...interface{}) (db *DB, err error)

示例代码：

package main
import "github.com/jinzhu/gorm"
import _ "github.com/jinzhu/gorm/dialects/mysql"//导入连接MySQL数据库的驱动包
//DSN
const DSN = "root:123456@tcp(localhost:3306)/test?charset=utf8&parseTime=True&loc=Local"
//指定驱动
const DRIVER = "mysql"
var db *gorm.DB
func init() {
    var err error
    db,err = gorm.Open(DRIVER,DSN)
    if err != nil{
        panic(err)
    }
}
func main(){
    defer db.Close()//退出前执行关闭
    //调用db执行具体的逻辑
}

在上面的例子中，我们在init方法中初始化gorm.DB结构体，这样在下面的例子可以直接使用变量db直接进行数据库操作。

基本操作

使用gorm.Open()函数返回一个gorm.DB结构体后，我们可以使用gorm.DB结构体提供的方法操作数据库，下面我们演示如何使用gorm.DB进行创建、查询、更新、删除等最基本的操作。

其实gorm.DB是在Go语言的database/sql库中的sql.DB结构体上再封装，因为gorm.DB提供许多和sql.DB一样的方法，如下所示：

func (s *DB) Exec(sql string, values ...interface{}) *DB
func (s *DB) Row() *sql.Row
func (s *DB) Rows() (*sql.Rows, error)
func (s *DB) Scan(dest interface{}) *DB

另外，使用gorm.DB结构体中的DB()方法，可以返回一个sql.DB对象，如下：

func (s *DB) DB() *sql.DB

下面演示的是使用gorm.DB结构体中一些更简便的方法进行数据库基本操作，不过，在演示之前，我们需要先定义一个模型，如下:

type User struct {
    Id       int   //对应数据表的自增id
    Username string
    Password string
    Email    string
    Phone    string
}

我们定义了一个名称为User的结构体，GROM支持将结构体按规则映射为某个数据表的一行，结构体的每个字段表示数据表的列，结构体的字段首字母必须是大写的。

创建

使用gorm.DB中的Create()方法，GORM会根据传给Create()方法的模型，向数据表插入一行。

func (s *DB) Create(value interface{}) *DB  //创建一行
func (s *DB) NewRecord(value interface{}) bool //根据自增id判断主键是否存在

func main() {
    defer db.Close()
    //具体的逻辑
    u := &User{Username: "test_one", Password: "testOne123456", Email: "test_one@163.com", Phone: "13711112222"}
    db.Create(u)
    if db.NewRecord(u){
        fmt.Println("写入失败")
    }else{
        fmt.Println("写入成功")
    }

查询

GROM框架在sql/database包的原生基础上封装了简便的方法，可以直接调用便将数据映射到对应的结构体模型中，用起来非常简单，如下面这几个方法：

//返回第一条
func (s *DB) First(out interface{}, where ...interface{}) *DB
//返回最后一条
func (s *DB) Last(out interface{}, where ...interface{}) *DB
//返回符合条件的内容
func (s *DB) Find(out interface{}, where ...interface{}) *DB
//返回Count(*)结果
func (s *DB) Count(value interface{}) *DB
复制代码

示例代码

//Find方法示例
func find() {
    var users = make([]*User, 0)
    db.Model(&User2{}).Find(&users)
    fmt.Println(users)
}
//First方法示例
func first()  {
    var user1,user2 User
    db.First(&user1)
    fmt.Println(user1)
    db.First(&user2,"id = ?",20)
    fmt.Println(user2)
}
//Last方法示例
func last()  {
    var user1,user2 User
    db.Last(&user1)
    fmt.Println(user1)
    db.First(&user2,"id = ?",19)
    fmt.Println(user2)
}
//Count方法示例
func count()  {
    var count int
    db.Model(&User{}).Count(&count)
    fmt.Println(count)
}

更新

更新数据可以使用gorm.DB的Save()或Update(),UpdateColumn(),UpdateColumns(),Updates()等方法，后面这四个方法需要与Model()方法一起使用。

func (s *DB) Save(value interface{}) *DB
func (s *DB) Model(value interface{}) *DB
//下面的方法需要与Model方法一起使用，通过Model方法指定更新数据的条件
func (s *DB) Update(attrs ...interface{}) *DB
func (s *DB) UpdateColumn(attrs ...interface{}) *DB
func (s *DB) UpdateColumns(values interface{}) *DB
func (s *DB) Updates(values interface{}, ignoreProtectedAttrs ...bool) *DB

代码示例

//Save()方法示例
func save(){
    u := &User{}
    db.First(u)
    u.Email = "test@163.com"
    db.Save(u)
    fmt.Println(u)
}
//Update方法示例
func update() {
    u := &User{}
    db.First(u)
    db.Model(u).Update("username", "hello")
}
//Updates方法示例
func updates() {
    u := &User{}
    db.First(u)
    db.Model(&u).Updates(map[string]interface{}{"username": "hello2"})
}

删除

使用gorm.DB的Delete()方法可以很简单地删除满足条件的记录，下面是Delete()方法的定义：

//value如果有主键id，则包含在判断条件内，通过where可以指定其他条件
func (s *DB) Delete(value interface{}, where ...interface{}) *DB

示例代码

func delete(){
    defer db.Close()
    u := &User{Id: 16}
    db.Delete(u)//根据id
    db.Delete(&User{},"username = ? ","test_one")//根据额外条件删除
}

综合使用

创建 main.go

1 2	`go` `get github.com/go-sql-driver/mysql` `go` `get github.com/jinzhu/gorm`

代码

package main
import (
    _ "github.com/go-sql-driver/mysql"//加载mysql
    "github.com/jinzhu/gorm"//gorm 扩展包
    "fmt"
)
//注意如果 定义成小写username 引用时 无法调用
type User struct {
    ID       int64  // 列名为 `id`
    Username string // 列名为 `username`
    Password string // 列名为 `password`
}
//设置表名
func (User) TableName() string {
    return "users"
}
func main() {
    db, err := gorm.Open("mysql", "数据库用户名:数据库密码@tcp(ip地址:端口号)/数据库名?     charset=utf8&parseTime=True&loc=Local&timeout=10ms")
     defer db.Close()
    if err != nil {
        fmt.Printf("mysql connect error %v", err)
    }
    //执行迁移文件 生成数据表：如果数据库表已经存在，可以不做这一步
    db.CreateTable(&User{})
    //添加数据
    user := User{Username: "root", Password: "root"}
    result := db.Create(&user)
    if result.Error != nil {
        fmt.Printf("insert row err %v", result.Error)
        return
    }
    fmt.Println(user.ID) //返回id
    //查询单条数据
    getUser := User{}
    //SELECT id, first FROM users WHERE id = 1 LIMIT 1;
    db.Select([]string{"id", "username"}).First(&getUser, 1)
    fmt.Println(getUser) //打印查询数据
    //修改数据
    user.Username = "update username"
    user.Password = "update password"
    db.Save(&user)
    //查询列表数据
    users := []User{}
    db.Find(&users)
    fmt.Println(&users)//获取所有数据
  //删除数据
    db.Delete(&user)
}

执行

1	`go` `run main.go`

gin+gorm+router 快速搭建 crud restful API 接口

├──api
│    ├── apis 
│    │    └── user.go
│    ├── database
│    │    └── mysql.go
│    ├── models
│    │    └── user.go
│    └── router
│         └──  router.go
└──main.go

apis/apis/user.go

package apis

import (
    "github.com/gin-gonic/gin"
    model "api/models"
    "net/http"
    "strconv"
)

//列表数据
func Users(c *gin.Context) {
    var user model.User
    user.Username = c.Request.FormValue("username")
    user.Password = c.Request.FormValue("password")
    result, err := user.Users()

    if err != nil {
        c.JSON(http.StatusOK, gin.H{
            "code":    -1,
            "message": "抱歉未找到相关信息",
        })
        return
    }

    c.JSON(http.StatusOK, gin.H{
        "code": 1,
        "data":   result,
    })
}

//添加数据
func Store(c *gin.Context) {
    var user model.User
    user.Username = c.Request.FormValue("username")
    user.Password = c.Request.FormValue("password")
    id, err := user.Insert()

    if err != nil {
        c.JSON(http.StatusOK, gin.H{
            "code":    -1,
            "message": "添加失败",
        })
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "code":  1,
        "message": "添加成功",
        "data":    id,
    })
}

//修改数据
func Update(c *gin.Context) {
    var user model.User
    id, err := strconv.ParseInt(c.Param("id"), 10, 64)
    user.Password = c.Request.FormValue("password")
    result, err := user.Update(id)
    if err != nil || result.ID == 0 {
        c.JSON(http.StatusOK, gin.H{
            "code":    -1,
            "message": "修改失败",
        })
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "code":  1,
        "message": "修改成功",
    })
}

//删除数据
func Destroy(c *gin.Context) {
    var user model.User
    id, err := strconv.ParseInt(c.Param("id"), 10, 64)
    result, err := user.Destroy(id)
    if err != nil || result.ID == 0 {
        c.JSON(http.StatusOK, gin.H{
            "code":    -1,
            "message": "删除失败",
        })
        return
    }
    c.JSON(http.StatusOK, gin.H{
        "code":  1,
        "message": "删除成功",
    })
}

database/mysql.go

package database
import (
    _ "github.com/go-sql-driver/mysql" //加载mysql
    "github.com/jinzhu/gorm"
    "fmt"
)
var Eloquent *gorm.DB
func init() {
    var err error
    Eloquent, err = gorm.Open("mysql", "root:root@tcp(127.0.0.1:3306)/test?charset=utf8&parseTime=True&loc=Local&timeout=10ms")
    if err != nil {
        fmt.Printf("mysql connect error %v", err)
    }
    if Eloquent.Error != nil {
        fmt.Printf("database error %v", Eloquent.Error)
    }
}

models/user.go

package models
import (
    orm "api/database"
)
type User struct {
    ID       int64  `json:"id"`       // 列名为 `id`
    Username string `json:"username"` // 列名为 `username`
    Password string `json:"password"` // 列名为 `password`
}
var Users []User
//添加
func (user User) Insert() (id int64, err error) {
    //添加数据
    result := orm.Eloquent.Create(&user)
    id =user.ID
    if result.Error != nil {
        err = result.Error
        return
    }
    return
}
//列表
func (user *User) Users() (users []User, err error) {
    if err = orm.Eloquent.Find(&users).Error; err != nil {
        return
    }
    return
}
//修改
func (user *User) Update(id int64) (updateUser User, err error) {
    if err = orm.Eloquent.Select([]string{"id", "username"}).First(&updateUser, id).Error; err != nil {
        return
    }
    //参数1:是要修改的数据
    //参数2:是修改的数据
    if err = orm.Eloquent.Model(&updateUser).Updates(&user).Error; err != nil {
        return
    }
    return
}
//删除数据
func (user *User) Destroy(id int64) (Result User, err error) {
    if err = orm.Eloquent.Select([]string{"id"}).First(&user, id).Error; err != nil {
        return
    }
    if err = orm.Eloquent.Delete(&user).Error; err != nil {
        return
    }
    Result = *user
    return
}

router/router.go

package router
import (
    "github.com/gin-gonic/gin"
    . "api/apis"
)
func InitRouter() *gin.Engine {
    router := gin.Default()
    router.GET("/users", Users)
    router.POST("/user", Store)
    router.PUT("/user/:id", Update)
    router.DELETE("/user/:id", Destroy)
    return router
}

main.go

package main
import (
    _ "api/database"
    "api/router"
    orm "api/database"
)
func main() {
    defer orm.Eloquent.Close()
    router := router.InitRouter()
    router.Run(":8000")
}

执行 go run main.go

访问地址

POST localhost:8006/user 添加
GET localhost:8006/users 列表
DELETE localhost:8006/user/id 删除
PUT localhost:8006/user/id 修改　

原文作者：yourself
转自链接：https://learnku.com/articles/23548/gingormrouter-quickly-build-crud-restful-api-interface

版权声明：
作者：89391311
链接：https://www.csev.cn/share/code/20240404153.html/
来源：测试分享
版权声明：本文欢迎任何形式转载，转载时完整保留本声明信息（包含原文链接、原文出处、原文作者、版权声明）即可。本文后续所有修改都会第一时间在原始地址更新。

THE END

根据我国《计算机软件保护条例》第十七条规定：“为了学习和研究软件内含的设计思想和原理，通过安装、显示、传输或者存储软件等方式使用软件的，可以不经软件著作权人许可，不向其支付报酬。本站资源仅供个人学习交流，请于下载后 24 小时内删除，不允许用于商业用途，否则法律问题自行承担。

golang gorm

二维码

打赏

比 Python 快 90,000 倍的 Mojo 官宣开源

< <上一篇

号称Golang最快的Web框架

下一篇>>

文章目录

关闭

搜索内容

Gin篇：gorm 使用

连接数据库

基本操作

创建

查询

更新

删除

综合使用

创建 main.go

代码

执行

gin+gorm+router 快速搭建 crud restful API 接口

下载扩展

建表语句

结构

apis/apis/user.go

database/mysql.go

models/user.go

router/router.go

main.go

执行 go run main.go

取消回复

共有 0 条评论

热门文章

标签云

近期文章