Go+Gin+GOrm+MySql实现基础的增删改查

一、概述

　　本节使用Gin+GOrm+MySql实现基础的增删改查。主要是做一下记录防止后面忘记了可以翻看博客查看

　　主要有两个.go文件

　　1.main.go用于注册gin路由及初始化gorm操作数据库

　　2.Result.go用于封装服务端返回给客户端的响应体

二、代码示例

　　1.main.go

// go_demo1 project main.go
package main

import (
    "fmt"

    "go_demo1/entity"

    "go_demo1/token"

    "go_demo1/response"

    "time"

    "errors"

    "strconv"

    "github.com/gin-gonic/gin"
    "gorm.io/driver/mysql"
    "gorm.io/gorm"
)


func main() {
    //连接数据库,并返回db对象用于操作数据表
    // db = connectMySql().Debug() //连接数据库并操作user表
    // userTable = db.Table("user") //使用user表

    //实例化路由注册器
    router := gin.Default()
    //设置请求路由
    router.POST("/user/login", loginHandler)                //登录
    router.POST("/user/register", registerHandler)          //注册
    router.GET("/user/info", getUserInfoHandler)            //获取用户信息
    router.GET("/user/getUserById/:id", getUserByIdHandler) //根据用户id获取用户信息
    router.GET("/user/users", getUsersHandler)              //获取用户列表（所有用户）
    router.POST("/user/update", updateUserHandler)          //更新用户信息
    router.POST("/user/delete", deleteUserHandler)          //删除用户
    //集和章节多表联查
    router.GET("/getECs", getECsHandler)
    //文件上传upload

    //设置服务端监听端口
    router.Run(":8888")
    fmt.Println("Hello World!")
}

// 连接数据库
func connectMySql() *gorm.DB {
    dsn := "root:123456@tcp(localhost:3306)/tony_cursor?charset=utf8&parseTime=true&loc=Local"
    db, err := gorm.Open(mysql.Open(dsn), &gorm.Config{}) //打开数据库连接
    if err != nil {
        panic("failed to connect database")
    }
    //把表和结构体连接起来，如果没有表就会创建一个，如果有此表也会在表中添加原本表中没有的列
    //如果不想使用自动迁移，可以使用db.Table("表明")来指定要操作的表
    // db.AutoMigrate(&entity.User{})

    return db
}

// 登录
func loginHandler(context *gin.Context) {
    var user entity.User
    err := context.ShouldBindJSON(&user)
    fmt.Println("登录参数：", user)
    if len(user.Phone) == 0 || len(user.Pwd) == 0 {
        response.ShowError(400, "用户名密码不能为空", context)
        return
    }
    if err != nil {
        response.ShowError(400, "参数异常:"+err.Error(), context)
        return
    }
    userTable := connectMySql().Table("user").Debug()

    var count int64
    err1 := userTable.Where("phone=?", user.Phone).Count(&count).Error
    fmt.Println("是否有记录：", count)
    if count <= 0 || err1 != nil {
        response.ShowError(200, "没有此用户", context)
        return
    }
    var users []entity.User
    //加上debug说明输出sql执行的操作（出于debug模式）
    err2 := userTable.Where("phone=? AND pwd=?", user.Phone, user.Pwd).Find(&users).Error
    fmt.Println(len(users))
    fmt.Println(users)
    // err2 := userTable.Where(&entity.User{Phone: user.Phone, Pwd: user.Pwd}).Find(&users).Error
    if len(users) <= 0 || err2 != nil {
        response.ShowError(200, "用户名或密码不正确", context)
        return
    }
    //生成token
    mToken, err3 := token.CreateToken(users[0])
    if err3 != nil {
        response.ShowError(200, "token生成失败", context)
        return
    }
    response.ShowSuccess(mToken, context)
}

// 注册
func registerHandler(context *gin.Context) {
    //获取参数
    var user entity.User
    err := context.ShouldBindJSON(&user)
    if err != nil {
        response.ShowError(400, "参数异常："+err.Error(), context)
        return
    }
    if len(user.Phone) == 0 || len(user.Pwd) == 0 {
        response.ShowError(400, "参数不能为空", context)
        return
    }
    userTable := connectMySql().Table("user").Debug()
    user.CreateTime = time.Now().Format("2006-01-02 15:04:05")
    user.UpdateTime = time.Now().Format("2006-01-02 15:04:05")
    err2 := userTable.Create(&user).Error
    if err2 != nil {
        response.ShowError(200, "创建用户失败", context)
        return
    }
    response.ShowSuccess("创建成功", context)
}

func checkToken(context *gin.Context) (int64, error) {
    //获取authorization header
    Authorization := context.GetHeader("Authorization")
    fmt.Println("Authorization:", Authorization)
    if Authorization == "" {
        return 0, errors.New("token为空")
    }
    //解析token
    mToken, claims, err := token.ParseToken(Authorization)
    fmt.Println("token:", mToken)
    fmt.Println("claims:", claims)
    if err != nil || !mToken.Valid { //解析错误或者token过期
        return 0, errors.New("token过期/错误")
    }
    return claims.Id, nil

}

// 获取用户信息
func getUserInfoHandler(context *gin.Context) {
    id, err := checkToken(context)
    if err != nil {
        response.ShowError(400, err.Error(), context)
        return
    }
    db := connectMySql().Table("user").Debug()
    var user entity.User
    err2 := db.Where("id=?", id).First(&user).Error
    if err2 != nil {
        response.ShowError(500, "查询失败", context)
        return
    }
    response.ShowSuccess(user, context)

}

// 根据用户id获取用户信息
func getUserByIdHandler(context *gin.Context) {
    id := context.Param("id")
    _, err := checkToken(context)
    if err != nil {
        response.ShowError(400, err.Error(), context)
        return
    }
    db := connectMySql().Table("user").Debug()
    var user entity.User
    err2 := db.Where("id=?", id).First(&user).Error
    if err2 != nil {
        response.ShowError(500, "查询失败", context)
        return
    }
    response.ShowSuccess(user, context)
}

// 分页
func getUsersWidthPagination(page, pageSize int) ([]entity.User, error) {
    //执行查询并获取结果
    var users []entity.User
    //设置分页参数
    db := connectMySql().Table("user").Debug()
    offset := (page - 1) * pageSize
    limit := pageSize
    //执行查询结果
    err := db.Where("deleted=?", 0).Offset(offset).Limit(limit).Find(&users).Error
    return users, err
}

// 获取用户列表
func getUsersHandler(context *gin.Context) {
    _, err := checkToken(context)
    if err != nil {
        response.ShowError(400, err.Error(), context)
        return
    }

    //用于分页
    page, _ := strconv.Atoi(context.Query("page"))
    pageSize, _ := strconv.Atoi(context.Query("pageSize"))

    users, err2 := getUsersWidthPagination(page, pageSize)
    if err2 != nil {
        response.ShowError(500, "查询失败", context)
        return
    }
    response.ShowSuccess(users, context)
}

// 更新用户信息
func updateUserHandler(context *gin.Context) {
    _, err := checkToken(context)
    if err != nil {
        response.ShowError(400, err.Error(), context)
        return
    }
    db := connectMySql().Table("user").Debug()
    var user entity.User
    err2 := context.ShouldBindJSON(&user)
    if err2 != nil {
        response.ShowError(400, "参数异常", context)
        return
    }
    if len(user.Name) == 0 {
        response.ShowError(500, "用户名不能为空", context)
        return
    }
    err3 := db.Where("id=?", user.Id).Update("name", user.Name).Error
    if err3 != nil {
        response.ShowError(500, "更新失败", context)
        return
    }
    response.ShowSuccess("更新成功", context)

}

// 删除用户
func deleteUserHandler(context *gin.Context) {
    _, err := checkToken(context)
    if err != nil {
        response.ShowError(400, err.Error(), context)
        return
    }
    db := connectMySql().Table("user").Debug()
    var user entity.User
    err2 := context.ShouldBindJSON(&user)
    if err2 != nil {
        response.ShowError(400, "参数异常", context)
        return
    }
    if user.Id <= 0 {
        response.ShowError(400, "被删除的用户id不能为空", context)
        return
    }
    err3 := db.Where("id=?", user.Id).Update("deleted", 1).Error
    if err3 != nil {
        response.ShowError(500, "逻辑删除失败", context)
        return
    }
    response.ShowSuccess("逻辑删除成功", context)
}

　　2.Result.go

package response

import (
    "github.com/gin-gonic/gin"
)

// 正常返回
func ShowSuccess(data interface{}, context *gin.Context) {
    context.JSON(200, gin.H{"code": 200, "data": data, "message": "操作成功"})
}

// 异常返回
func ShowError(code int, message string, context *gin.Context) {
    context.JSON(code, gin.H{"code": code, "data": "", "message": message})
}