Gorm_快速入门

快速入门

gorm地址：https://github.com/go-gorm/gorm

对开发者友好的gorm库，目前使用最广的go orm库之一

1. 准备工作

数据库以目前使用最多的mysql为例。

//安装MySQL驱动
go get -u gorm.io/driver/mysql
//安装gorm包
go get -u gorm.io/gorm
//安装gin
go get -u github.com/gin-gonic/gin

涉及到的数据库sql：

CREATE TABLE `users` (
  `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT '自增ID',
  `username` varchar(30) NOT NULL COMMENT '账号',
  `password` varchar(100) NOT NULL COMMENT '密码',
  `createtime` bigint(20) NOT NULL DEFAULT 0 COMMENT '创建时间',
   PRIMARY KEY (`id`)
  ) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4

新建model目录，在model目录下新建一个文件user.go

//定义User模型，绑定users表，ORM库操作数据库，需要定义一个struct类型和MYSQL表进行绑定或者叫映射，struct字段和MYSQL表字段一一对应
package model

type User struct {
	ID int64 // 主键
	//通过在字段后面的标签说明，定义golang字段和表字段的关系
	//例如 `gorm:"column:username"` 标签说明含义是: Mysql表的列名（字段名)为username
	Username string `gorm:"column:username"`
	Password string `gorm:"column:password"`
	//创建时间，时间戳
	CreateTime int64 `gorm:"column:createtime"`
}

func (u User) Table() string {
	return "users"
}

新建目录global，在该目录上新建文件global.go

package global

import "gorm.io/gorm"

var DB *gorm.DB

新建目录inition，在该目录下新建初始化文件init.go

package inition

import (
	"GinStudy/helloworld/global"
	"fmt"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
	"gorm.io/gorm/logger"
)

func InitDB() {
	//配置MySQL连接参数
	username := "root"    //账号
	password := "123456"  //密码
	host := "127.0.0.1"   //数据库地址，可以是Ip或者域名
	port := 3306          //数据库端口
	Dbname := "gin_study" //数据库名
	dsn := fmt.Sprintf("%s:%s@tcp(%s:%d)/%s?charset=utf8&parseTime=True&loc=Local", username, password, host, port, Dbname)
	db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{
		Logger: logger.Default.LogMode(logger.Info),
	})
	if err != nil {
		panic("连接数据库失败, error=" + err.Error())
	}
	global.DB = db
}

2.插入数据

新建servcie目录，在该目录下新建user.go

package service

import (
	"GinStudy/helloworld/global"
	"GinStudy/helloworld/model"
)

type UserService struct {
}

func (u UserService) SaveUser(user model.User) error {
	err := global.DB.Create(&user).Error
	return err
}

在inition该目录下建立router.go

package inition

import (
	"GinStudy/helloworld/router"
	"github.com/gin-gonic/gin"
)

func RegisterRouter(r *gin.Engine) {
	r.GET("/user/save", router.SaveUser)
}

新建router目录，在该目录下建立user.go

package router

import (
	"GinStudy/helloworld/model"
	"GinStudy/helloworld/service"
	"github.com/gin-gonic/gin"
	"net/http"
	"time"
)

func SaveUser(c *gin.Context) {
	err := service.UserService{}.SaveUser(model.User{
		Username:   "zhangsan2",
		Password:   "123456",
		CreateTime: time.Now().UnixMilli(),
	})
	if err != nil {
		c.JSON(202, gin.H{
			"message": "添加失败",
		})
	} else {
		c.JSON(http.StatusOK, gin.H{
			"message": "添加用户成功",
		})
	}
}

在main.go编写如下内容

package main

import (
	"GinStudy/helloworld/inition"
	"github.com/gin-gonic/gin"
)

func main() {
	r := gin.Default()
	inition.InitDB()
	inition.RegisterRouter(r)
	r.Run()
}

运行main.go，然后在浏览器或POSTMAN上运行

http://localhost:8080/user/save

可看到

{"message":"添加用户成功"}

3.查询

在 service/user.go增加如下内容

func (u UserService) GetUserById(id int) (user model.User, err error) {
	err = global.DB.Model(&model.User{}).Where("id=?", id).Find(&user).Error
	return user, err
}

在router/user.go增加如下内容

func GetUserInfo(c *gin.Context) {
	userInfo, err := service.UserService{}.GetUserById(1)
	if err != nil {
		c.JSON(202, gin.H{
			"data":    userInfo,
			"message": "查询失败",
		})
	} else {
		c.JSON(http.StatusOK, gin.H{
			"data":    userInfo,
			"message": "添加用户成功",
		})
	}
}

在inition/router.go增加如下内容

r.GET("/user/userInfo", router.GetUserInfo)

最后启动main.go，在浏览器上运行 http://localhost:8080/user/userInfo，最终得到如下结果

{"data":{"ID":1,"Username":"zhangsan","Password":"123456","CreateTime":1715762629632},"message":"添加用户成功"}

4.更新

在 service/user.go增加如下内容

func (u UserService) UpdateUser(id int) (err error) {
	err = global.DB.Model(&model.User{}).Where("id=?", id).Update("username", "lisi").Error
	return err
}

在router/user.go增加如下内容

func UpdateUserInfo(c *gin.Context) {
	err := service.UserService{}.UpdateUser(1)
	if err != nil {
		c.JSON(202, gin.H{
			"message": "更新失败",
		})
	} else {
		c.JSON(http.StatusOK, gin.H{
			"message": "更新成功",
		})
	}
}

在inition/router.go增加如下内容

r.GET("/user/updateUserInfo", router.UpdateUserInfo)

最后启动main.go，在浏览器上运行 http://localhost:8080/user/updateUserInfo，最终得到如下结果

{"message":"更新成功"}

5.删除

在 service/user.go增加如下内容

func (u UserService)DeleteById(id int64)(err error) {
	err = global.DB.Model(&model.User{}).Where("id=?", id).Delete(&model.User{})
	return err
}

在router/user.go增加如下内容

func DeleteUser(c *gin.Context) {
	err := service.UserService{}.DeleteById(1)
	if err != nil {
		c.JSON(202, gin.H{
			"message": "删除失败",
		})
	} else {
		c.JSON(http.StatusOK, gin.H{
			"message": "删除成功",
		})
	}
}

在inition/router.go增加如下内容

	r.GET("/user/delUser", router.DeleteUser)

最后启动main.go，在浏览器上运行 http://localhost:8080/user/delUser，最终得到如下结果

{"message":"删除成功"}