GoWeb 开发者必读：掌握 GORM 实现高效数据库操作的技巧（附完整代码）

矫情吗；* 2024-03-31 17:56 39阅读 0赞

## 1、前言 ##

什么是web应用，Web应用程序简单流程如下图所示

![在这里插入图片描述][cd063f46b2ae4ab3b6c62c780aac29e2.png]  
通过上图我们发现，我们 GoWeb 实战项目还缺少最后关键的环节数据库。那么如何使用 GO 语言操作数据库并完成增删改查等操作是我们今天学习的目标。

[从零开始实现一个 GoWeb MVC 框架：让你更深入地理解 MVC 架构设计][GoWeb MVC _ MVC]

## 2、什么是ORM ##

对象关系映射（Object Relational Mapping，简称ORM）是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。

我们是面向对象的。当对象的信息发生变化的时候，我们就需要把对象的信息保存在关系数据库中。程序员会在自己的业务逻辑代码中夹杂很多 SQL 语句用来增加、读取、修改、删除相关数据，而这些代码通常都是重复的。

ORM 的出现充当了对象和数据库层次的桥梁作用。

## 3、MySQL ##

### 3.1、什么是MySQL ###

MySQL是一个关系型数据库管理系统，由瑞典MySQL AB 公司开发，属于 Oracle 旗下产品。MySQL 是最流行的关系型数据库管理系统之一，在 WEB 应用方面，MySQL是最好的 RDBMS (Relational Database Management System，关系数据库管理系统) 应用软件之一。

MySQL是一种关系型数据库管理系统，关系数据库将数据保存在不同的表中，而不是将所有数据放在一个大仓库内，这样就增加了速度并提高了灵活性。

MySQL所使用的 SQL 语言是用于访问数据库的最常用标准化语言。MySQL 软件采用了双授权政策，分为社区版和商业版，由于其体积小、速度快、总体拥有成本低，尤其是开放源码这一特点，一般中小型和大型网站的开发都选择 MySQL 作为网站数据库。

### 3.2、MySQL 安装 ###

#### 3.2.1 Docker 环境 ####

[Docker 环境 MySQL8 主从配置][Docker _ MySQL8]

#### 3.2.2 菜鸟教程 ####

[MySQL 菜鸟教程][MySQL]

### 3.3、创建数据库 ###

通过 Navicat Premium 快速创建数据库，数据库名示例：go\_gorm，字符集选择：utf8mb4，排序规则选择： utf8mb4\_general\_ci。最后点击确认即可

![在这里插入图片描述][7008754839f44d48bc13923ce9756149.png]

### 3.4、创建数据表 ###

创建一张系统用户表，用户完成我们后续的 CRUD 等操作，建表语句如下：

-- ----------------------------
    -- 系统用户
    -- ----------------------------
    DROP TABLE IF EXISTS `sys_user`;
    CREATE TABLE `sys_user`
    (
        `id`             bigint unsigned NOT NULL AUTO_INCREMENT COMMENT '主键 ID',
        `name`           varchar(10)  NOT NULL DEFAULT '' COMMENT '用户名',
        `account`        varchar(20)  NOT NULL DEFAULT '' COMMENT '账号',
        `password`       varchar(64)  NOT NULL DEFAULT '' COMMENT '密码',
        `password_salt`  varchar(64)  NOT NULL DEFAULT '' COMMENT '密码盐值',
        `mail_address`   varchar(64)  NOT NULL DEFAULT '' COMMENT '邮箱地址',
        `phone_number`   varchar(20)  NOT NULL DEFAULT '' COMMENT '手机号码',
        `age`            tinyint unsigned NOT NULL DEFAULT '0' COMMENT '用户年龄',
        `is_using`       tinyint unsigned NOT NULL DEFAULT '0' COMMENT '是否启用  1是 0否(默认0)',
        `is_delete`      tinyint unsigned NOT NULL DEFAULT '0' COMMENT '是否删除  1是 0否(默认0)',
        `create_time`    datetime     NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '创建时间',
        `update_time`    datetime     NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '修改时间',
        `remark`         varchar(100) NOT NULL DEFAULT '' COMMENT '描述',
        PRIMARY KEY (`id`)
    ) ENGINE=InnoDB AUTO_INCREMENT=1 DEFAULT CHARSET=utf8mb3 COMMENT='系统用户';

### 3.5、新增数据 ###

新增一条超级管理员数据。注意：当前用户密码使用明文存储存在安全隐患

INSERT INTO `sys_user` ( `name`, `account`, `password` ) VALUES ('超级管理员', 'admin', '123456')

## 4、编写代码 ##

此项目根据 《[GoWeb 项目实战：使用 Iris 框架构建一个安全可靠的 API 服务（附 JWT 认证实现）][GoWeb _ Iris _ API _ JWT]》源代码进阶，如果只想了解 CRUD 可以忽略

### 4.1、安装软件包 ###

# gorm 安装
    go get -u gorm.io/gorm
    
    # mysql 驱动
    go get -u gorm.io/driver/mysql

### 4.2、编写代码 ###

#### 4.2.1、加载 MySQL 数据库 ####

在 utils/db 目录新建文件 mysql.go，完整代码如下：

package db
    
    import (
    	"fmt"
    	"log"
    	"os"
    	"time"
    
    	"gorm.io/driver/mysql"
    	"gorm.io/gorm"
    	"gorm.io/gorm/logger"
    )
    
    // 全局变量
    var GormDb *gorm.DB
    
    func init() {
        
    	fmt.Println("开始加载 MySQL 数据库")
    	GormDb = InitMysql()
    }
    
    /*
    * <h2>初始化 MySQL 数据库</h2>
    **/
    func InitMysql() *gorm.DB {
        
    	// GORM 定义了这些日志级别：Silent、Error、Warn、Info
    	newLogger := logger.New(
    		log.New(os.Stdout, "\r\n", log.LstdFlags), // io writer（日志输出的目标，前缀和日志包含的内容——译者注）
    		logger.Config{
        
    			SlowThreshold:             time.Second, // 慢 SQL 阈值
    			LogLevel:                  logger.Info, // 日志级别
    			IgnoreRecordNotFoundError: false,       // 忽略ErrRecordNotFound（记录未找到）错误
    			Colorful:                  false,       // 禁用彩色打印
    		},
    	)
    
    	// MySQL 数据库地址和用户信息
    	dsn := "替换自己数据库用户名:替换自己数据库密码@tcp(数据库IP地址:数据库端口)/go_gorm?charset=utf8mb4&parseTime=True&loc=Local"
    
    	db, err := gorm.Open(mysql.New(mysql.Config{
        
    		DSN:                       dsn,   // DSN data source name
    		DefaultStringSize:         256,   // string 类型字段的默认长度
    		DisableDatetimePrecision:  true,  // 禁用 datetime 精度，MySQL 5.6 之前的数据库不支持
    		DontSupportRenameIndex:    true,  // 重命名索引时采用删除并新建的方式，MySQL 5.7 之前的数据库和 MariaDB 不支持重命名索引
    		DontSupportRenameColumn:   true,  // 用 `change` 重命名列，MySQL 8 之前的数据库和 MariaDB 不支持重命名列
    		SkipInitializeWithVersion: false, // 根据当前 MySQL 版本自动配置
    	}), &gorm.Config{
        Logger: newLogger})
    
    	if err != nil {
        
    		fmt.Println("加载数据库异常信息：", err)
    		return nil
    	}
    
    	// 获取通用数据库对象 sql.DB，然后使用其提供的功能
    	mysqlDB, err := db.DB()
    	if err != nil {
        
    		fmt.Println("获取通用数据库对象异常信息：", err)
    		return nil
    	}
    
    	// Ping
    	err = mysqlDB.Ping()
    	if err != nil {
        
    		fmt.Println("数据库连接异常信息：", err.Error())
    		return nil
    	}
    
    	fmt.Println("数据库连接成功", mysqlDB)
    
    	// SetMaxIdleConns 用于设置连接池中空闲连接的最大数量。
    	mysqlDB.SetMaxIdleConns(10)
    
    	// SetMaxOpenConns 设置打开数据库连接的最大数量。
    	mysqlDB.SetMaxOpenConns(100)
    
    	// SetConnMaxLifetime 设置了连接可复用的最大时间。
    	mysqlDB.SetConnMaxLifetime(time.Hour)
    
    	return db
    }

#### 4.2.2、业务异常自定义 ####

在 utils/constant 目录修改文件 errors.go，完整代码如下：

package constant
    
    import "errors"
    
    /**
     * <h1>业务异常自定义</h1>
     * Created by woniu
     */
    
    var (
    	ResErrAuthorizationIsNilErr = errors.New("1001_token 为空")
    	ResErrSysUserPasswordErr    = errors.New("2001_密码错误")
    	ResErrIdIsNil               = errors.New("2002_主键 ID 不能为空")
    	ResErrSysUserRepeat         = errors.New("2003_用户已存在")
    	ResErrSysUserIsNil          = errors.New("2004_用户不存在")
    )

#### 4.2.3、系统用户模型 ####

在 app/model 目录新建文件 sys\_user.go，完整代码如下：

package model
    
    import "time"
    
    // 系统用户信息
    type SysUser struct {
        
    	Id           int64     `gorm:"primaryKey"`           // 用户 ID
    	Name         string    `gorm:"column:name"`          // 用户姓名
    	Account      string    `gorm:"column:account"`       // 用户账号
    	Password     string    `gorm:"column:password"`      // 用户密码
    	PasswordSalt string    `gorm:"column:password_salt"` // 密码盐值
    	MailAddress  string    `gorm:"column:mail_address"`  // 邮箱地址
    	PhoneNumber  string    `gorm:"column:phone_number"`  // 手机号码
    	Age          int       `gorm:"column:age"`           // 用户年龄
    	IsUsing      int       `gorm:"column:is_using"`      // 是否启用  1是 0否(默认0)
    	IsDelete     int       `gorm:"column:is_delete"`     // 是否删除  1是 0否(默认0)
    	CreateTime   time.Time `gorm:"column:create_time"`   // 创建时间
    	UpdateTime   time.Time `gorm:"column:update_time"`   // 修改时间
    	Remark       string    `gorm:"column:remark"`        // 描述
    }
    
    // TableName 指定表名
    func (SysUser) TableName() string {
        
    	return "sys_user"
    }

#### 4.2.4、系统用户响应结构 ####

在 app/vo 目录修改文件 sys\_user\_vo.go，完整代码如下：

package vo
    
    // 系统用户信息
    type SysUserVo struct {
        
    	Id          int64  `json:"id"`          // 用户 ID
    	Name        string `json:"name"`        // 用户姓名
    	Account     string `json:"account"`     // 用户账号
    	MailAddress string `json:"mailAddress"` // 邮箱地址
    	PhoneNumber string `json:"phoneNumber"` // 手机号码
    	Age         int    `json:"age"`         // 用户年龄
    	IsUsing     int    `json:"isUsing"`     // 是否启用  1是 0否(默认0)
    	IsDelete    int    `json:"isDelete"`    // 是否删除  1是 0否(默认0)
    	CreateTime  string `json:"createTime"`  // 创建时间
    	UpdateTime  string `json:"updateTime"`  // 修改时间
    	Remark      string `json:"remark"`      // 描述
    	Token       string `json:"token"`       // token
    }

#### 4.2.5、分页数据响应结构 ####

注意：此结构体是分页核心  
在 app/vo 目录新建文件 page.go，完整代码如下：

package vo
    
    // 分页数据结构
    type Page struct {
        
    	Current int64       `json:"current"` // 当前页码
    	Size    int64       `json:"size"`    // 每页条数
    	Total   int64       `json:"total"`   // 总数据量
    	Pages   int64       `json:"pages"`   // 总分页数
    	Records interface{
        } `json:"records"` // 分页数据
    }
    
    /**
     * <h2>提供了一个构造方法</h2>
     * 需要传入当前页码和每页条数
     */
    func NewPage(current, size int64) *Page {
        
    	return &Page{
        Current: current, Size: size}
    }
    
    /**
     * <h2>设置总数据量</h2>
     */
    func (p *Page) SetTotal(t int64) {
        
    	p.Total = t
    
    	// 总分页数 = 总数据量 / 每页条数
    	s := p.GetTotal() / p.GetSize()
    
    	// 如果总数据量 / 每页条数有余数，则总分页数 + 1
    	if p.GetTotal()%p.GetSize() != 0 {
        
    		s = s + 1
    	}
    
    	p.Pages = s
    }
    
    /**
     * <h2>设置分页数据</h2>
     */
    func (page *Page) SetRecords(records interface{
        }) {
        
    	page.Records = records
    }
    
    /**
     * <h2>获取当前页码</h2>
     * 默认当前页码 1
     */
    func (p *Page) GetCurrent() int64 {
        
    	if p.Current < 1 {
        
    		p.Current = 1
    	}
    	return p.Current
    }
    
    /**
     * <h2>获取数据偏移量</h2>
     */
    func (p *Page) GetOffset() int64 {
        
    	if p.GetCurrent() > 0 {
        
    		return (p.GetCurrent() - 1) * p.GetSize()
    	}
    	return 0
    }
    
    /**
     * <h2>获取每页条数</h2>
     * 默认每页 10 条数据
     */
    func (p *Page) GetSize() int64 {
        
    	if p.Size < 1 {
        
    		p.Size = 10
    	}
    	return p.Size
    }
    
    /**
     * <h2>获取总数据量</h2>
     */
    func (p *Page) GetTotal() int64 {
        
    	return p.Total
    }
    
    /**
     * <h2>获取总分页数</h2>
     */
    func (p *Page) GetPages() int64 {
        
    	return p.Pages
    }
    
    /**
     * <h2>获取分页数据</h2>
     */
    func (page *Page) GetRecords() interface{
        } {
        
    	return page.Records
    }

#### 4.2.6、系统用户业务处理 ####

注意：此业务处理类本次项目进阶核心代码

*  用户登录校验由固定密码改为数据库动态校验
 *  系统用户增加数据
 *  系统用户修改数据
 *  系统用户删除数据
 *  系统用户查询数据
 *  系统用户查询数据列表

在 app/service 目录修改文件 sys\_user\_service.go，完整代码如下：

package service
    
    import (
    	"fmt"
    	"go-iris/app/dto"
    	"go-iris/app/model"
    	"go-iris/app/vo"
    	"go-iris/utils/constant"
    	"go-iris/utils/db"
    	"go-iris/utils/tool"
    )
    
    /**
     * <h1>系统用户业务处理</h1>
     * Created by woniu
     */
    var SysUser = new(sysUserService)
    
    type sysUserService struct{
        }
    
    /**
     * <h2>用户账号 + 用户密码登录</h2>
     */
    func (service *sysUserService) PasswordLogin(account string, password string) (*vo.SysUserVo, error) {
        
    	// 用户账号为空
    	if tool.IsEmpty(account) {
        
    		return nil, constant.ResErrSysUserIsNil
    	}
    
    	// 用户密码为空
    	if tool.IsEmpty(password) {
        
    		return nil, constant.ResErrSysUserPasswordErr
    	}
    
    	// 根据用户账号查询用户信息
    	sysUser := service.GetSysUserByAccount(account)
    
    	if sysUser == nil {
        
    		return nil, constant.ResErrSysUserIsNil
    	}
    
    	// 密码不匹配（暂时使用明文密码比对）
    	if password != sysUser.Password {
        
    		return nil, constant.ResErrSysUserPasswordErr
    	}
    
    	// 用户名 + 密码 校验正确，返回用户信息
    	return service.GetSysUserVo(sysUser), nil
    }
    
    /**
     * <h2>根据用户账号查询用户信息</h2>
     */
    func (service *sysUserService) GetSysUserByAccount(account string) *model.SysUser {
        
    	var sysUser = &model.SysUser{
        }
    	// 根据用户账号查询一条数据，主键 ID 排序
    	result := db.GormDb.Table(sysUser.TableName()).Where("account = ?", account).First(sysUser)
    	// 查询不到记录报错
    	if result.Error != nil {
        
    		fmt.Println("数据查询异常：", result.Error)
    		return nil
    	}
    	return sysUser
    }
    
    /**
     * <h2>新增系统用户</h2>
     */
    func (service *sysUserService) Save(sysUser model.SysUser) (*vo.SysUserVo, error) {
        
    
    	// 根据用户账号查询用户信息
    	sysUserOld := service.GetSysUserByAccount(sysUser.Account)
    	if sysUserOld != nil {
        
    		return nil, constant.ResErrSysUserRepeat
    	}
    
    	// 主键采用数据库自增
    	sysUser.Id = 0
    	// 创建时间
    	sysUser.CreateTime = tool.DataTimeNow()
    	// 修改时间
    	sysUser.UpdateTime = sysUser.CreateTime
    
    	// 创建记录
    	result := db.GormDb.Table(sysUser.TableName()).Create(&sysUser)
    	// 返回 error
    	if result.Error != nil {
        
    		fmt.Println("数据新增异常：", result.Error)
    		return nil, result.Error
    	}
    	fmt.Println("数据新增成功，主键ID：", sysUser.Id)
    	return service.GetSysUserVo(&sysUser), nil
    }
    
    /**
     * <h2>根据主键 ID 修改用户</h2>
     */
    func (service *sysUserService) UpdateById(sysUser model.SysUser) (*model.SysUser, error) {
        
    	if sysUser.Id < 1 {
        
    		return nil, constant.ResErrIdIsNil
    	}
    
    	// 如果修改用户账号，则需要判断账号是否重复
    	if tool.IsNotEmpty(sysUser.Account) {
        
    		// 根据用户账号查询用户信息
    		sysUserOld := service.GetSysUserByAccount(sysUser.Account)
    		// 如果用户账号存在并且ID不相等
    		if sysUserOld != nil && sysUserOld.Id != sysUser.Id {
        
    			return nil, constant.ResErrSysUserRepeat
    		}
    	}
    
    	// 修改时间
    	sysUser.UpdateTime = tool.DataTimeNow()
    
    	// Updates 方法支持 struct 和 map[string]interface{} 参数。
    	// 当使用 struct 更新时，默认情况下，GORM 只会更新非零值的字段
    	result := db.GormDb.Table(sysUser.TableName()).Model(&sysUser).Updates(&sysUser)
    	// 返回 error
    	if result.Error != nil {
        
    		fmt.Println("数据修改异常：", result.Error)
    		return nil, result.Error
    	}
    	return service.GetById(sysUser)
    }
    
    /**
     * <h2>根据主键 ID 查询用户</h2>
     */
    func (service *sysUserService) GetById(sysUser model.SysUser) (*model.SysUser, error) {
        
    	if sysUser.Id < 1 {
        
    		return nil, constant.ResErrIdIsNil
    	}
    	// 当目标对象有一个主要值时，将使用主键构建条件
    	result := db.GormDb.Table(sysUser.TableName()).First(&sysUser)
    	// 返回 error
    	if result.Error != nil {
        
    		fmt.Println("数据修改异常：", result.Error)
    		return nil, result.Error
    	}
    	return &sysUser, nil
    }
    
    /**
     * <h2>根据主键 ID 删除用户</h2>
     */
    func (service *sysUserService) RemoveById(sysUser model.SysUser) error {
        
    	if sysUser.Id < 1 {
        
    		return constant.ResErrIdIsNil
    	}
    	// 删除一条记录时，删除对象需要指定主键，否则会触发 批量 Delete
    	result := db.GormDb.Table(sysUser.TableName()).Delete(&sysUser)
    	// 返回 error
    	if result.Error != nil {
        
    		fmt.Println("数据删除异常：", result.Error)
    		return result.Error
    	}
    	return nil
    }
    
    /**
     * <h2>检索全部对象</h2>
     */
    func (service *sysUserService) List(sysUser model.SysUser) ([]*vo.SysUserVo, error) {
        
    	var sysUserList []model.SysUser
    	// 检索全部对象
    	result := db.GormDb.Table(sysUser.TableName()).Find(&sysUserList)
    	// 返回 error
    	if result.Error != nil {
        
    		fmt.Println("数据列表查询异常：", result.Error)
    		return nil, result.Error
    	}
    	return service.GetSysUserVoList(sysUserList), nil
    }
    
    /**
     * <h2>检索全部对象 - 分页查询</h2>
     */
    func (service *sysUserService) Page(current int64, size int64, sysUserDto dto.SysUserDto) (*vo.Page, error) {
        
    	page := vo.NewPage(current, size)
    
    	var sysUserList []model.SysUser
    
    	var sysUser model.SysUser
    	query := db.GormDb.Table(sysUser.TableName())
    	var count int64 // 统计总的记录数
    	query.Count(&count)
    
    	if count > 0 {
        
    		result := query.Limit(int(page.GetSize())).Offset(int(page.GetOffset())).Find(&sysUserList)
    		// 返回 error
    		if result.Error != nil {
        
    			fmt.Println("数据分页查询异常：", result.Error)
    			return nil, result.Error
    		}
    	}
    
    	page.SetTotal(count)
    	page.SetRecords(sysUserList)
    
    	fmt.Println(page.GetRecords())
    
    	return page, nil
    }
    
    /**
     * <h2>将 SysUser 集合 转换为 SysUserVo 集合</h2>
     */
    func (service *sysUserService) GetSysUserVoList(sysUserList []model.SysUser) []*vo.SysUserVo {
        
    	var sysUserVoList []*vo.SysUserVo
    
    	for i := range sysUserList {
        
    		// 将 SysUser 转换为 SysUserVo
    		vo := service.GetSysUserVo(&sysUserList[i])
    		sysUserVoList = append(sysUserVoList, vo)
    	}
    
    	return sysUserVoList
    }
    
    /**
     * <h2>将 SysUser 转换为 SysUserVo</h2>
     */
    func (service *sysUserService) GetSysUserVo(sysUser *model.SysUser) *vo.SysUserVo {
        
    	var sysUserVo = vo.SysUserVo{
        
    		Id:          sysUser.Id,
    		Name:        sysUser.Name,
    		Account:     sysUser.Account,
    		MailAddress: sysUser.MailAddress,
    		PhoneNumber: sysUser.PhoneNumber,
    		Age:         sysUser.Age,
    		IsUsing:     sysUser.IsUsing,
    		IsDelete:    sysUser.IsDelete,
    		CreateTime:  tool.DataTimeFormat(sysUser.CreateTime),
    		UpdateTime:  tool.DataTimeFormat(sysUser.UpdateTime),
    		Remark:      sysUser.Remark,
    	}
    
    	return &sysUserVo
    }

#### 4.2.7、系统用户控制器 ####

在 app/controller 目录修改文件 sys\_user\_controller.go，完整代码如下：

package controller
    
    import (
    	"fmt"
    	"go-iris/app/dto"
    	"go-iris/app/model"
    	"go-iris/app/service"
    	"go-iris/utils/common"
    	"go-iris/utils/tool"
    
    	"github.com/kataras/iris/v12"
    )
    
    /**
     * <h1>系统用户控制器</h1>
     * Created by woniu
     */
    var SysUser = new(SysUserController)
    
    type SysUserController struct{
        }
    
    /**
     * <h2>用户名密码登录</h2>
     */
    func (sc *SysUserController) PasswordLogin(ctx iris.Context) {
        
    
    	// 登录参数
    	var requestModel dto.LoginDto
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	// 用户登录，用户账号 + 用户密码登录
    	sysUser, err := service.SysUser.PasswordLogin(requestModel.Account, requestModel.Password)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 生成 JWT 的 Token
    	sysUser.Token = tool.SignedJwtTokenBySysUser(sysUser)
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(sysUser))
    }
    
    /**
     * <h2>新增用户</h2>
     */
    func (sc *SysUserController) Save(ctx iris.Context) {
        
    	// 参数
    	var requestModel model.SysUser
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	// 新增系统用户
    	_, err := service.SysUser.Save(requestModel)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(nil))
    }
    
    /**
     * <h2>根据主键 ID 修改用户</h2>
     */
    func (sc *SysUserController) UpdateById(ctx iris.Context) {
        
    	// 参数
    	var requestModel model.SysUser
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	// 根据主键 ID 修改用户
    	_, err := service.SysUser.UpdateById(requestModel)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(nil))
    }
    
    /**
     * <h2>根据主键 ID 查询用户</h2>
     */
    func (sc *SysUserController) GetById(ctx iris.Context) {
        
    	// 参数
    	var requestModel model.SysUser
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	// 根据主键 ID 查询用户
    	sysUser, err := service.SysUser.GetById(requestModel)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(sysUser))
    }
    
    /**
     * <h2>根据主键 ID 删除用户</h2>
     */
    func (sc *SysUserController) RemoveById(ctx iris.Context) {
        
    	// 参数
    	var requestModel model.SysUser
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	// 根据主键 ID 删除用户
    	err := service.SysUser.RemoveById(requestModel)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(nil))
    }
    
    /**
     * <h2>条件查询系统用户列表</h2>
     */
    func (sc *SysUserController) List(ctx iris.Context) {
        
    	// 参数
    	var requestModel model.SysUser
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	// 检索全部对象
    	sysUser, err := service.SysUser.List(requestModel)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(sysUser))
    }
    
    /**
     * <h2>条件查询系统用户列表</h2>
     */
    func (sc *SysUserController) Page(ctx iris.Context) {
        
    	// 参数
    	var requestModel dto.SysUserDto
    
    	// 参数绑定
    	if err := ctx.ReadForm(&requestModel); err != nil {
        
    		ctx.JSON(common.ResponseError(-1, "传参异常"))
    		return
    	}
    
    	fmt.Println("requestModel = ", requestModel)
    
    	// 检索全部对象 - 分页查询
    	page, err := service.SysUser.Page(requestModel.Current, requestModel.Size, requestModel)
    
    	if err != nil {
        
    		// 响应失败
    		ctx.JSON(common.ResponseErrorMessage(err.Error()))
    		return
    	}
    
    	// 响应成功
    	ctx.JSON(common.ResponseSuccess(page))
    }

#### 4.2.8、请求路由 ####

在 router 目录新建文件 router.go，完整代码如下：

package router
    
    import (
    
    	// 自己业务 controller 路径
    	"fmt"
    	"go-iris/app/controller"
    	"go-iris/utils/common"
    	"go-iris/utils/constant"
    	"go-iris/utils/tool"
    
    	"github.com/kataras/iris/v12"
    )
    
    /**
     * <h2>注册路由</h2>
     */
    func RegisterRouter(app *iris.Application) {
        
    
    	// 跨域解决方案
    	app.Use(Cors)
    	// 登录验证中间件
    	app.Use(CheckAuthorization)
    
    	// 系统用户
    	login := app.Party("/sysUser")
    	{
        
    		// 用户名 + 密码登录
    		login.Post("/passwordLogin", controller.SysUser.PasswordLogin)
    		// 新增用户
    		login.Post("/save", controller.SysUser.Save)
    		// 根据主键 ID 修改用户
    		login.Post("/updateById", controller.SysUser.UpdateById)
    		// 根据主键 ID 查询用户
    		login.Post("/getById", controller.SysUser.GetById)
    		// 根据主键 ID 删除用户
    		login.Post("/removeById", controller.SysUser.RemoveById)
    		// 条件查询系统用户列表
    		login.Post("/list", controller.SysUser.List)
    		// 条件查询系统用户列表 - 分页
    		login.Post("/page", controller.SysUser.Page)
    	}
    
    	// 通用异常
    	err := app.Party("/error")
    	{
        
    		err.Get("/responseError", controller.Error.ResponseError)
    		err.Get("/responseErrorCode", controller.Error.ResponseErrorCode)
    		err.Get("/responseErrorMessage", controller.Error.ResponseErrorMessage)
    	}
    }
    
    /**
     * <h2>跨域解决方案</h2>
     */
    func Cors(ctx iris.Context) {
        
    	ctx.Header("Access-Control-Allow-Origin", "*")
    	if ctx.Request().Method == "OPTIONS" {
        
    		ctx.Header("Access-Control-Allow-Methods", "GET,POST,PUT,DELETE,PATCH,OPTIONS")
    		ctx.Header("Access-Control-Allow-Headers", "Content-Type, Accept, Authorization")
    		ctx.StatusCode(204)
    		return
    	}
    	ctx.Next()
    }
    
    /**
     * <h2>登录验证中间件</h2>
     */
    func CheckAuthorization(ctx iris.Context) {
        
    	fmt.Println("登录验证中间件", ctx.Path())
    	// 放行设置
    	urlItem := []string{
        "/sysUser/passwordLogin", "/sysUser/login"}
    	if !tool.IsStringInArray(ctx.Path(), urlItem) {
        
    		// 从请求头中获取Token
    		token := ctx.GetHeader("Authorization")
    
    		// 请求头 Authorization 为空
    		if tool.IsEmpty(token) {
        
    			ctx.JSON(common.ResponseErrorMessage(constant.ResErrAuthorizationIsNilErr.Error()))
    			return
    		}
    
    		claims, err := tool.ParseWithClaims(token)
    		if err != nil {
        
    			fmt.Println("token 解析异常信息：", err)
    			ctx.JSON(common.ResponseErrorMessage(err.Error()))
    			return
    		}
    
    		// 打印消息
    		claims.ToString()
    	}
    	// 前置中间件
    	ctx.Application().Logger().Infof("Runs before %s", ctx.Path())
    	ctx.Next()
    }

相关代码已完成编写，最终项目结构及文件如下图

![在这里插入图片描述][eafc37a7b42845baa9594cc137735ea3.png]

## 5、启动并测试 ##

### 5.1、启动项目 ###

在 VS Code 终端输入以下命令并执行

# 启动项目
    go run main.go

有以下信息代表启动成功

Iris Version: 12.2.0-beta6
    
    Now listening on: http://localhost:8080
    Application started. Press CTRL+C to shut down.

### 5.2、测试接口 ###

#### 5.2.1、用户登录 ####

注意：需要确保系统用户表存在一条初始化数据，没有数据会提示用户不存在

![在这里插入图片描述][4c017c9a09534e69aeeff2ba0221357a.png]

account = admin 并且 password = 123456，响应成功

![在这里插入图片描述][5dc898b32cdc422fbd9ce139195951e5.png]

#### 5.2.2、新增数据 ####

注意：请求头添加 Authorization

![在这里插入图片描述][90170ce485574df49125208586f9aac2.png]

#### 5.2.3、主键 ID 修改 ####

注意：请求头添加 Authorization

![在这里插入图片描述][bf30bbe63a4242f19ef996e34d8b70de.png]

#### 5.2.4、主键 ID 查询 ####

注意：请求头添加 Authorization

![在这里插入图片描述][b543a267ce3f463ab7cba2d7bcd31d3d.png]

#### 5.2.5、查询数据列表 ####

注意：请求头添加 Authorization

![在这里插入图片描述][f6c2f61131e64dd78617df59bf827fb0.png]

响应结果数据示例如下：

{
        
        "code": 0,
        "message": "操作成功",
        "data": [
            {
        
                "id": 1,
                "name": "超级管理员",
                "account": "admin",
                "mailAddress": "",
                "phoneNumber": "",
                "age": 0,
                "isUsing": 0,
                "isDelete": 0,
                "createTime": "2022-12-12 17:54:39",
                "updateTime": "2022-12-12 17:54:39",
                "remark": "",
                "token": ""
            },
            {
        
                "id": 2,
                "name": "测试用户名称-修改后",
                "account": "test",
                "mailAddress": "xxx@163.com",
                "phoneNumber": "158XXXXXXXX",
                "age": 18,
                "isUsing": 0,
                "isDelete": 0,
                "createTime": "2022-12-12 17:59:59",
                "updateTime": "2022-12-12 18:15:35",
                "remark": "我是通过接口创建的-修改后",
                "token": ""
            }
        ]
    }

#### 5.2.6、分页查询 ####

注意：请求头添加 Authorization

![在这里插入图片描述][2230f7a9f3314ac996a504e1e1c71e70.png]

响应结果数据示例如下：

{
        
        "code": 0,
        "message": "操作成功",
        "data": {
        
            "current": 1,
            "size": 1,
            "total": 2,
            "pages": 2,
            "records": [
                {
        
                    "Id": 1,
                    "Name": "超级管理员",
                    "Account": "admin",
                    "Password": "123456",
                    "PasswordSalt": "",
                    "MailAddress": "",
                    "PhoneNumber": "",
                    "Age": 0,
                    "IsUsing": 0,
                    "IsDelete": 0,
                    "CreateTime": "2022-12-12T17:54:39+08:00",
                    "UpdateTime": "2022-12-12T17:54:39+08:00",
                    "Remark": ""
                }
            ]
        }
    }

#### 5.2.7、主键 ID 删除 ####

注意：请求头添加 Authorization

![在这里插入图片描述][d9061959256e490f9f5470e2c73e9bf4.png]

通过上述测试验证，项目达到预期目标，小伙伴自己赶紧动手试试吧。

## 6、每日一记 ##

GO 的 ORM框架有那些？哪个才是最优雅的Go ORM 框架?

### 6.1、GORM ###

Golang 的出色 ORM 库旨在对开发人员友好。

### 6.1.1、Github ###

[Github][]

### 6.1.2、文档 ###

[中文文档][Link 1]

### 6.1.3、安装 ###

# gorm 安装
    go get -u gorm.io/gorm
    
    # mysql 驱动
    go get -u gorm.io/driver/mysql

### 6.2、XORM ###

xorm 是一个简单而强大的 Go 语言 ORM 库. 通过它可以使数据库操作非常简便。

### 6.2.1、Github ###

[Github][Github 1]

### 6.2.2、文档 ###

[中文文档][Link 2]

### 6.2.3、安装 ###

# xorm 安装
    go get -u github.com/go-xorm/xorm
    
    # mysql 驱动
    go get -u github.com/go-sql-driver/mysql

### 6.3、Ent ###

ent 是一个简单而又功能强大的 Go 语言实体框架，ent 易于构建和维护应用程序与大数据模型。

### 6.3.1、Github ###

[Github][Github 2]

### 6.3.2、文档 ###

[中文文档][Link 3]

### 6.2.3、安装 ###

# ent 安装
    go get -u entgo.io/ent/cmd/ent@latest

### 6.4、其他 ###

还有其他一些ORM框架，例如：gorose、upper/db 等等。

### 6.5、如何选择？ ###

没有最好的只有比较合适的，自己根据实际需求按需选择即可。

本文教程到此结束，有问题欢迎大家讨论。

## 实践是检验真理的唯一标准，一键送三连关注不迷路。 ##

[cd063f46b2ae4ab3b6c62c780aac29e2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/c32e77ee4fb24530a3c4014adc52dea7.png
[GoWeb MVC _ MVC]: https://blog.csdn.net/u011374856/article/details/127982721
[Docker _ MySQL8]: https://blog.csdn.net/u011374856/article/details/105856982
[MySQL]: https://www.runoob.com/mysql/mysql-tutorial.html
[7008754839f44d48bc13923ce9756149.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8d508ba0d07e4a7d95faeafea74cee74.png
[GoWeb _ Iris _ API _ JWT]: https://blog.csdn.net/u011374856/article/details/128215690
[eafc37a7b42845baa9594cc137735ea3.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/8c2e63aa35dc43e5aeec356b154f6e0c.png
[4c017c9a09534e69aeeff2ba0221357a.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/0b79515b3d9c4377bdf1567f69886ea8.png
[5dc898b32cdc422fbd9ce139195951e5.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/69475b66e5704f30b68d0cb21308a4eb.png
[90170ce485574df49125208586f9aac2.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/70b7791e1853475b9025e7dfe3c7f404.png
[bf30bbe63a4242f19ef996e34d8b70de.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/5400efe40cd24fac9b07579b01d43076.png
[b543a267ce3f463ab7cba2d7bcd31d3d.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/cf066ccbc8124d0da5cf125ed00a0f8c.png
[f6c2f61131e64dd78617df59bf827fb0.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/743182c1a4e54804b33388ad9d048dfb.png
[2230f7a9f3314ac996a504e1e1c71e70.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/510c003bf54b4db1b5b816e2a129f668.png
[d9061959256e490f9f5470e2c73e9bf4.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/31/3bf343faafd74fe381918f8cca085fff.png
[Github]: https://github.com/go-gorm/gorm
[Link 1]: https://gorm.io/zh_CN
[Github 1]: https://github.com/go-xorm/xorm
[Link 2]: https://xorm.io/zh/docs
[Github 2]: https://github.com/ent/ent
[Link 3]: https://entgo.io/zh/docs/getting-started