go项目中操作数据库使用gorm和gen对比，附查询案例代码

最新推荐文章于 2026-05-21 09:57:12 发布
原创 最新推荐文章于 2026-05-21 09:57:12 发布 · 1.4k 阅读 · 17 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
标签
#golang #数据库 #开发语言 #后端

文章目录

gorm和gen的区别

在上一篇文章《go-zero自动生成repository文件和测试用例》中，通过自定义的模板生成了go项目中常见的数据库操作方法，那么这里面其实存在一个细节问题，就是查询数据的时候应该使用gorm还是gen呢？

实际上，Gen是gorm里面的一个工具，或者说是在gorm的基础上做了更进一步的封装。GORM 和 GORM Gen 都是 Go 语言中用于数据库操作的工具，它们在功能和使用方式上存在一些区别。

  • GORM 是一个强大且广泛使用的 Go 语言 ORM（对象关系映射）库，它为开发者提供了丰富的数据库操作功能，如创建、读取、更新和删除（CRUD）操作，支持多种数据库类型，像 MySQL、PostgreSQL 等。GORM 以链式调用的方式构建查询，具有较高的灵活性，开发者可以根据具体需求动态构建复杂的查询语句。然而，这种灵活性也带来了一定的学习成本，特别是在处理复杂查询时，代码可能会变得冗长且难以维护。
  • GORM Gen 则是基于 GORM 开发的代码生成工具，它通过生成预定义的查询方法，减少了手动编写数据库操作代码的工作量。GORM Gen 会根据数据库表结构自动生成对应的模型和查询方法，使得代码更加简洁、规范。开发者只需调用这些生成的方法，就可以完成常见的数据库操作，提高了开发效率。但 GORM Gen 的灵活性相对较低，对于一些特殊的查询需求，可能需要手动编写额外的代码。
  • 总的来说，GORM 适合需要高度灵活性和对数据库操作有深入控制的场景，而 GORM Gen 则更适合快速开发和代码规范统一的项目。

gorm官网：https://gorm.io/

gen的用法：https://gorm.io/gen/

使用案例

接下来，我通过一个常见的查询场景来分析应该使用哪种方式。

比如，有一个用户信息表的结构如下：

CREATE TABLE `user` (
  `id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
  `uuid` varchar(255) NOT NULL DEFAULT '' COMMENT 'uuid',
  `user_id` bigint(20) unsigned NOT NULL COMMENT '用户编号',
  `user_name` varchar(255) NOT NULL DEFAULT '' COMMENT '用户名',
  `password` varchar(255) NOT NULL DEFAULT '' COMMENT '密码',
  `name` varchar(255) NOT NULL DEFAULT '' COMMENT '用户姓名',
  `age` tinyint(4) unsigned NOT NULL DEFAULT '0' COMMENT '用户年龄',
  `email` varchar(255) NOT NULL DEFAULT '' COMMENT '用户邮箱',
  `address` varchar(255) NOT NULL DEFAULT '' COMMENT '地址',
  `status` tinyint(1) NOT NULL DEFAULT '1' COMMENT '状态:1审核中,2正常,3禁用,4封号',
  `extra` text COMMENT '扩展数据',
  `create_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP COMMENT '添加时间',
  `update_time` datetime NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP COMMENT '更新时间',
  `is_deleted` tinyint(1) unsigned NOT NULL DEFAULT '0' COMMENT '是否删除:0未删除,1已删除',
  PRIMARY KEY (`id`) USING BTREE,
  KEY `key_user_id` (`user_id`) USING BTREE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COMMENT='用户信息表';

业务场景是，如要根据如下规则对用户信息的列表查询：

1、精确匹配(=): id、user_id、status、email;
2、模糊匹配(like): user_name、name、address;
3、大小匹配(>=和=<，可以兼容between and): age、create_time、update_time;
4、in/not in/ != 查询:id、user_id、user_name;
5、其它复杂查询

在 gozero/internal/svc/service_context.go中定义数据库相关的上下文：

package svc

import (
	"context"
	"go-demo-2025/gozero/internal/config"
	"go-demo-2025/gozero/internal/model/dao/query"
	"gorm.io/driver/mysql"
	"gorm.io/gorm"
)

type ServiceContext struct {
	Config config.Config
	DB     *gorm.DB     //gorm的db对象
	Model  *query.Query //gorm的gen的query对象
}

func NewServiceContext(c config.Config) *ServiceContext {
	db, _ := gorm.Open(mysql.Open(c.Mysql.DataSource), &gorm.Config{
		Logger: newLogger,
		NamingStrategy: schema.NamingStrategy{
			TablePrefix:   "",   // 表名前缀
			SingularTable: true, // 使用单数表名，启用该选项，会区分 user 和 users 表为两个不同的数据表
		},
	})

	return &ServiceContext{
		Config: c,
		DB:     db,
		Model:  query.Use(db),
	}
}

查询方法对比

1、使用gorm查询

先从基础的gorm查询开始，不适用Gen的情况下。查询方法代码如下：

func (r *UserRepo) GetUserList1(queryEqualConditions map[string]interface{}, queryMoreConditions map[string]interface{}, page, pageSize int) (list []*model.User, count int64, err error) {
	m := r.svcCtx.DB.Model(&model.User{})
	querys := m.WithContext(r.ctx).Debug()

	//基础查询条件
	queryEqualConditions["is_deleted"] = 0
	querys = querys.Where(queryEqualConditions)

	//更多查询条件
	if len(queryMoreConditions) > 0 {
		if queryMoreConditions["ids"] != nil {
			querys = querys.Where("id in ?", queryMoreConditions["ids"].([]int64))
		}
		if queryMoreConditions["user_name"] != "" {
			querys = querys.Where("user_name like ?", "%"+queryMoreConditions["user_name"].(string)+"%")
		}
		if queryMoreConditions["name"] != "" {
			querys = querys.Where("name like?", "%"+queryMoreConditions["name"].(string)+"%")
		}
		if queryMoreConditions["address"] != "" {
			querys = querys.Where("address like?", "%"+queryMoreConditions["address"].(string)+"%")
		}
		if queryMoreConditions["age_min"] != 0 {
			querys = querys.Where("age >=?", queryMoreConditions["age_min"].(int64))
		}
		if queryMoreConditions["age_max"] != 0 {
			querys = querys.Where("age <=?", queryMoreConditions["age_max"].(int64))
		}
		if queryMoreConditions["create_time_start"] != "" {
			// 将字符串类型的时间转换为 time.Time 类型
			createTimeStart, err := time.Parse("2006-01-02 15:04:05", queryMoreConditions["create_time_start"].(string))
			if err == nil {
				querys = querys.Where("create_time >=?", createTimeStart)
			}
		}
		if queryMoreConditions["create_time_end"] != "" {
			// 将字符串类型的时间转换为 time.Time 类型
			createTimeEnd, err := time.Parse("2006-01-02 15:04:05", queryMoreConditions["create_time_end"].(string))
			if err == nil {
				querys = querys.Where("create_time <=?", createTimeEnd)
			}
		}
	}

	querys.Limit(pageSize).Offset(page).Find(&list)
	querys.Count(&count)
	return list, count, nil
}

测试用例代码：

func TestGetUserListDemo1(t *testing.T) {
	reqData := BuildRequestMockData()

	//构造等于的查询条件
	condsEq := make(map[string]interface{})
	if reqData.UserId != 0 {
		condsEq["user_id"] = reqData.UserId
	}
	if reqData.Status != 0 {
		condsEq["status"] = reqData.Status
	}
	if reqData.Email != "" {
		condsEq["email"] = reqData.Email
	}

	//构造其他查询条件
	condsMore := make(map[string]interface{})
	if len(reqData.Ids) > 0 {
		condsMore["ids"] = reqData.Ids //in
	}
	if reqData.UserName != "" { //like
		condsMore["user_name"] = reqData.UserName
	}
	if reqData.Name != "" { //like
		condsMore["name"] = reqData.Name
	}
	if reqData.Address != "" { //like
		condsMore["address"] = reqData.Address
	}
	if reqData.AgeMin != 0 { //>=
		condsMore["age_min"] = reqData.AgeMin
	}
	if reqData.AgeMax != 0 { //<=
		condsMore["age_max"] = reqData.AgeMax
	}
	if reqData.CreateTimeStart != "" { //>=
		condsMore["create_time_start"] = reqData.CreateTimeStart
	}
	if reqData.CreateTimeEnd != "" { //<=
		condsMore["create_time_end"] = reqData.CreateTimeEnd
	}

	//执行查询
	ts := utils.NewTestCtx()
	repo := mysql.NewUserRepo(ts.Ctx, ts.SvcCtx)
	list, count, err := repo.GetUserList1(condsEq, condsMore, 1, 20)
	t.Log("list: ", utils.EchoJson(list))
	t.Log("count: ", count)
	t.Log("error: ", err)
	assert.NoError(t, err)
}

运行结果：

image-20250411132656639

生成的SQL语句：

SELECT * FROM `user` WHERE (`email` = 'test@125.com' AND `is_deleted` = 0 AND `status` = 1) AND id in (1,2,3) AND user_name like '%zhangsan%' AND name like'%张三%' AND address like'%beijing%' AND age >=10 AND age <=50 AND create_time >='2024-01-01 08:00:00' AND create_time <='2024-01-02 07:59:59' LIMIT 20 OFFSET 1

上面的写法中，针对相等查询封装到了一个map中，针对非等查询，在repo中又一次逐一判断，有点繁琐，可以优化如下：

2、使用gorm查询优化

封装一个 ApplyQueryConditions 函数用于处理非等于查询条件：

// Condition 结构体用于存储操作符和值
type Condition struct {
	Field    string      // 字段名
	Operator string      // 操作符
	Value    interface{} // 值
}

// ApplyQueryConditions 函数用于处理非等于查询条件
func ApplyQueryConditions(query *gorm.DB, conditions []Condition) *gorm.DB {
	for _, cond := range conditions {
		switch cond.Operator {
		case "=":
			query = query.Where(fmt.Sprintf("%s = ?", cond.Field), cond.Value)
		case "!=":
			query = query.Where(fmt.Sprintf("%s !=?", cond.Field), cond.Value)
		case "like":
			query = query.Where(fmt.Sprintf("%s LIKE ?", cond.Field), "%"+cond.Value.(string)+"%")
		case "in":
			query = query.Where(fmt.Sprintf("%s IN ?", cond.Field), cond.Value)
		case ">":
			query = query.Where(fmt.Sprintf("%s > ?", cond.Field), cond.Value)
		case "<":
			query = query.Where(fmt.Sprintf("%s < ?", cond.Field), cond.Value)
		case ">=":
			query = query.Where(fmt.Sprintf("%s >= ?", cond.Field), cond.Value)
		case "<=":
			query = query.Where(fmt.Sprintf("%s <= ?", cond.Field), cond.Value)
		default:
			// 可以根据需要添加更多操作符
		}
	}
	return query
}

然后，查询方法优化如下：

func (r *UserRepo) GetUserList2(queryEqualConditions map[string]interface{}, queryMoreConditions []Condition, page, pageSize int) (list []*model.User, count int64, err error) {
	m := r.svcCtx.DB.Model(&model.User{})
	querys := m.WithContext(r.ctx).Debug()

	//基础查询条件
	queryEqualConditions["is_deleted"] = 0
	querys = querys.Where(queryEqualConditions)

	//更多查询条件
	if len(queryMoreConditions) > 0 {
		querys = ApplyQueryConditions(querys, queryMoreConditions)
	}

	querys.Limit(pageSize).Offset(page).Find(&list)
	querys.Count(&count)
	return list, count, nil
}

测试用例：

func TestGetUserListDemo2(t *testing.T) {
	reqData := BuildRequestMockData()

	//构造等于的查询条件
	condsEq := make(map[string]interface{})
	if reqData.UserId != 0 {
		condsEq["user_id"] = reqData.UserId
	}
	if reqData.Status != 0 {
		condsEq["status"] = reqData.Status
	}
	if reqData.Email != "" {
		condsEq["email"] = reqData.Email
	}

	//构造其他查询条件
	condsMore := make([]mysql.Condition, 0)
	if len(reqData.Ids) > 0 {
		condsMore = append(condsMore, mysql.Condition{"id", "in", reqData.Ids})
	}
	if reqData.UserName != "" {
		condsMore = append(condsMore, mysql.Condition{"user_name", "like", reqData.UserName})
	}
	if reqData.Name != "" {
		condsMore = append(condsMore, mysql.Condition{"name", "like", reqData.Name})
	}
	if reqData.Address != "" {
		condsMore = append(condsMore, mysql.Condition{"address", "like", reqData.Address})
	}
	if reqData.AgeMin != 0 {
		condsMore = append(condsMore, mysql.Condition{"age", ">=", reqData.AgeMin})
	}
	if reqData.AgeMax != 0 {
		condsMore = append(condsMore, mysql.Condition{"age", "<=", reqData.AgeMax})
	}
	if reqData.CreateTimeStart != "" {
		createTimeStart, err := time.Parse("2006-01-02 15:04:05", reqData.CreateTimeStart)
		if err == nil {
			condsMore = append(condsMore, mysql.Condition{"create_time", ">=", createTimeStart})
		}
	}
	if reqData.CreateTimeEnd != "" {
		createTimeEnd, err := time.Parse("2006-01-02 15:04:05", reqData.CreateTimeEnd)
		if err == nil {
			condsMore = append(condsMore, mysql.Condition{"create_time", "<=", createTimeEnd})
		}
	}

	//执行查询
	ts := utils.NewTestCtx()
	repo := mysql.NewUserRepo(ts.Ctx, ts.SvcCtx)
	list, count, err := repo.GetUserList2(condsEq, condsMore, 1, 20)
	t.Log("list: ", utils.EchoJson(list))
	t.Log("count: ", count)
	t.Log("error: ", err)
	assert.NoError(t, err)
}

运行结果和上面的是一样的：

SELECT * FROM `user` WHERE (`email` = 'test@125.com' AND `is_deleted` = 0 AND `status` = 1) AND id IN (1,2,3) AND user_name LIKE '%zhangsan%' AND name LIKE '%张三%' AND address LIKE '%beijing%' AND age >= 10 AND age <= 50 AND create_time >= '2024-01-01 08:00:00' AND create_time <= '2024-01-02 07:59:59' LIMIT 20 OFFSET 1

其实，这样封装后，也可以把等于的查询和其他查询放到一起了：

if reqData.UserId != 0 {
  condsMore = append(condsMore, mysql.Condition{"user_id", "=", reqData.UserId})
}
if reqData.Status != 0 {
  condsMore = append(condsMore, mysql.Condition{"status", "=", reqData.Status})
}
if reqData.Email != "" {
  condsMore = append(condsMore, mysql.Condition{"email", "=", reqData.Email})
}

以上写法是使用map的形式，优点是可以封装成统一的查询方法，缺点是如果写错了数据表的字段名，在编译阶段是不会报错的，只有运行的时候才会发现字段名不存在，报错Error 1054 (42S22): Unknown column 'idx' in 'where clause'。因此，可以改为使用结构体来查询。

3、使用gorm结构体查询

使用结构体查询的时候，只需要把之前定义的map改为对应的数据表的model的结构体即可。测试用例这样写：

func TestGetUserListByGormDemo3(t *testing.T) {
	reqData := BuildRequestMockData()

	//构造等于的查询条件
	condsEq := &model.User{} //User表的Model的结构体
	if reqData.Status != 0 {
		condsEq.Status = reqData.Status
	}
	if reqData.Email != "" {
		condsEq.Email = reqData.Email
	}

	//构造其他查询条件(暂未找到如何替换为结构体的方式)
	condsMore := make([]mysql.Condition, 0)
	if len(reqData.Ids) > 0 {
		condsMore = append(condsMore, mysql.Condition{"id", "in", reqData.Ids})
	}

	//执行查询
	ts := utils.NewTestCtx()
	repo := mysql.NewUserRepo(ts.Ctx, ts.SvcCtx)
	list, count, err := repo.GetUserListByGorm3(condsEq, condsMore, 1, 20)
}

通过上面的写法，可以确定condsEq.Status 一定是一个存在的字段。在查询方法中，传递的参数类型也改为queryEqualConditions *model.User：

func (r *UserRepo) GetUserListByGorm3(queryEqualConditions *model.User, queryMoreConditions []Condition, page, pageSize int) (list []*model.User, count int64, err error) {
	m := r.svcCtx.DB.Model(&model.User{})
	querys := m.WithContext(r.ctx).Debug()

	//基础查询条件
	queryEqualConditions.IsDeleted = 1
	querys = querys.Where(queryEqualConditions)

	//更多查询条件
	if len(queryMoreConditions) > 0 {
		querys = ApplyQueryConditions(querys, queryMoreConditions)
	}

	querys.Limit(pageSize).Offset(page).Find(&list)
	querys.Count(&count)
	return list, count, nil
}

image-20250411144606219

SELECT * FROM `user` WHERE (`user`.`email` = 'test@125.com' AND `user`.`status` = 1 AND `user`.`is_deleted` = 1) AND 0 IN (1,2,3) LIMIT 20 OFFSET 1

但是，这样写会存在以下几个问题：

  • 对于非等于的查询，目前我还没找到怎么使用结构体赋值，但依然可以使用上面的map对于非等条件的赋值；
  • 如果给Model结构体的某个字段赋值为0或者空字符串，查询语句会忽略此字段，因为Model结构体的初始值对于int类型就是0，对于string类型就是空字符串。在map中不存在这个问题。 验证如下：我把上面的Status写死为0，把Email写死为空字符串：
//构造等于的查询条件
condsEq := &model.User{}
if reqData.Status != 0 {
  condsEq.Status = 0 //reqData.Status
}
if reqData.Email != "" {
  condsEq.Email = "" //reqData.Email
}

查询的语句就会忽略这两个字段：

image-20250411144958496

SELECT * FROM `user` WHERE `user`.`is_deleted` = 1 AND id IN (1,2,3) LIMIT 20 OFFSET 1

对于上面的问题，有个间接的办法就是：

  • 对于int类型，尽量避免使用0，对于状态“是”和“否”，不使用1和0，而使用1和2。
  • 对于string类型，可以自定义一个业务上用不到的字符串，例如“my_empty_str”。

以上，就是使用gorm查询的方法传值的差异和对比。关于gorm的更多查询方法参考：https://gorm.io/zh_CN/docs/query.html

接下来，使用Gen的方式来试试查询语句怎么写。

4、使用Gen查询

查询方法的代码如下：

func (r *UserRepo) GetUserListByGen1(queryEqualConditions map[string]interface{}, queryMoreConditions map[string]interface{}, page, pageSize int) (list []*model.User, count int64, err error) {
	m := r.svcCtx.Model.User
	querys := m.WithContext(r.ctx).Debug().Where(m.IsDeleted.Eq(0))

	//基础查询条件
	querys = querys.Where(field.Attrs(queryEqualConditions))

	//更多查询条件
	if len(queryMoreConditions) > 0 {
		if queryMoreConditions["ids"] != nil {
			querys = querys.Where(m.ID.In(queryMoreConditions["ids"].([]int64)...))
		}
		if queryMoreConditions["user_name"] != "" {
			querys = querys.Where(m.UserName.Like("%" + queryMoreConditions["user_name"].(string) + "%"))
		}
		if queryMoreConditions["age_min"] != 0 {
			querys = querys.Where(m.Age.Gte(queryMoreConditions["age_min"].(int64)))
		}
		if queryMoreConditions["age_max"] != 0 {
			querys = querys.Where(m.Age.Lte(queryMoreConditions["age_max"].(int64)))
		}
	}

	offset := (page - 1) * pageSize
	limit := pageSize
	res, count, err := querys.Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		logx.WithContext(r.ctx).Errorf("Failed to get list: %v", err)
		return nil, 0, err
	}
	return res, count, nil
}

测试用例的代码写法：

func TestGetUserListByGenDemo1(t *testing.T) {
	reqData := BuildRequestMockData()

	//构造等于的查询条件
	condsEq := make(map[string]interface{})
	if reqData.UserId != 0 {
		condsEq["user_id"] = reqData.UserId
	}
	if reqData.Status != 0 {
		condsEq["status"] = reqData.Status
	}
	if reqData.Email != "" {
		condsEq["email"] = reqData.Email
	}

	//构造其他查询条件
	condsMore := make(map[string]interface{})
	if len(reqData.Ids) > 0 {
		condsMore["ids"] = reqData.Ids //in
	}
	if reqData.UserName != "" { //like
		condsMore["user_name"] = reqData.UserName
	}
	if reqData.AgeMin != 0 { //>=
		condsMore["age_min"] = reqData.AgeMin
	}
	if reqData.AgeMax != 0 { //<=
		condsMore["age_max"] = reqData.AgeMax
	}

	//执行查询
	ts := utils.NewTestCtx()
	repo := mysql.NewUserRepo(ts.Ctx, ts.SvcCtx)
	list, count, err := repo.GetUserListByGen1(condsEq, condsMore, 1, 20)
	t.Log("list: ", utils.EchoJson(list))
	t.Log("count: ", count)
	t.Log("error: ", err)
	assert.NoError(t, err)
}

执行后的语句和上面没有区别：

image-20250414141345007

SELECT * FROM `user` WHERE `user`.`is_deleted` = 0 AND (`email` = 'test@125.com' AND `status` = 1) AND `user`.`id` IN (1,2,3) AND `user`.`user_name` LIKE '%zhangsan%' AND `user`.`age` >= 10 AND `user`.`age` <= 50 ORDER BY `user`.`id` DESC LIMIT 20

和上面使用gorm查询，最大的区别：

  • 把m := r.svcCtx.DB.Model(&model.User{}) 换成了 m := r.svcCtx.Model.User
  • 把querys = querys.Where(queryEqualConditions) 换成了 querys = querys.Where(field.Attrs(queryEqualConditions))
  • 这里的 querys.Order(m.ID.Desc()).FindByPage(offset, limit) 方法直接返回的就是三个参数：res, count, err

你可以查看Gen生成的源代码了解其更多方法：

image-20250414141622251

上面使用Gen的查询条件依然是封装了map，我仍然希望能够通过结构体属性来访问查询条件，这样如果我的字段名写错了，就可以在编译阶段报错。因此，继续优化为下面的写法。

5、使用Gen查询优化

由于在Gen的查询方法中，对于非等查询不太好封装成统一的方法，因此，我决定在repo层直接接收调用方（比如：logic层或测试用例处）传递来的req变量，然后针对每一类查询条件逐一处理。这样看起来代码也比较工整。

先从go-zero的api文件开始，定义需要查询用户列表的条件的结构体：

type UserListRequest {
	UserId   int64  `json:"user_id,optional"` // 用户id,eq查询
	Status   int64  `json:"status,optional"` // 用户状态,eq查询
	Email    string `json:"email,optional"` // 邮箱,eq查询
	Ids      string `json:"ids,optional"` // 多个id用逗号分隔,in查询
	UserName string `json:"user_name,optional"` // 用户名,like查询
	AgeMin   int64  `json:"age_min,optional"` // 年龄,>=
	AgeMax   int64  `json:"age_max,optional"` // 年龄,<=
	Page     int64  `json:"page,optional,default=1"`
	PageSize int64  `json:"page_size,optional,default=10"`
}

然后，在 gozero/internal/logic/admin/user_list_logic.go 中，把请求参数 req *types.UserListRequest 直接传递到repo层：

func (l *UserListLogic) UserList(req *types.UserListRequest) (resp []*types.UserListResponse, err error) {
	//根据前端传来的参数req查询用户数据列表
	userModelList, count, err := l.userRepo.GetUserListByGen2(req)
	if err != nil {
		return nil, err
	}

	//定义返回的结构体
	userListResp := make([]*types.UserListResponse, 0)
	//如果查询到的结果为空,直接返回预定义的空数据
	if count == 0 {
		return userListResp, nil
	}

	//二次处理userModelList,转换为前端需要的结构体
	// todo...
	fmt.Println(userModelList)

	return userListResp, nil
}

在repo层，需要根据前端传来的req请求参数，封装出一个公用的查询条件，这样可以给其他查询列表和总数之类的方法复用。代码路径：gozero/internal/repo/mysql/user_repo.go

// 构建查询用户数据的条件
func (r *UserRepo) BuildQueryUserListCondition(req *types.UserListRequest) (query.IUserDo, error) {
	m := r.svcCtx.Model.User
	querys := m.WithContext(r.ctx).Debug().Where(m.IsDeleted.Eq(0))
	if req.UserId > 0 {
		querys = querys.Where(m.ID.Eq(req.UserId)) //eq查询
	}
	if req.Status > 0 {
		querys = querys.Where(m.Status.Eq(req.Status)) //eq查询
	}
	if req.Email != "" {
		querys = querys.Where(m.Email.Eq(req.Email)) //eq查询
	}
	if req.Ids != "" {
		idsSlice := utils.CommaSeparatedStringToInt64Slice(req.Ids)
		if len(idsSlice) > 0 {
			querys = querys.Where(m.ID.In(idsSlice...)) //in查询
		}
	}
	if req.UserName != "" {
		querys = querys.Where(m.UserName.Like("%" + req.UserName + "%")) //like查询
	}
	if req.AgeMin > 0 {
		querys = querys.Where(m.Age.Gte(req.AgeMin)) //>=查询
	}
	if req.AgeMax > 0 {
		querys = querys.Where(m.Age.Lte(req.AgeMax)) //<=查询
	}

	return querys, nil
}

然后，在查询方法里面调用上面的查询条件，以及后续的查询逻辑：

func (r *UserRepo) GetUserListByGen2(req *types.UserListRequest) (list []*model.User, count int64, err error) {
	m := r.svcCtx.Model.User
	querys, err := r.BuildQueryUserListCondition(req)
	if err != nil {
		return nil, 0, err
	}

	limit := int(req.PageSize)
	offset := (int(req.Page) - 1) * limit
	res, count, err := querys.Order(m.ID.Desc()).FindByPage(offset, limit)
	if err != nil && !errors.Is(err, gorm.ErrRecordNotFound) {
		logx.WithContext(r.ctx).Errorf("Failed to get list: %v", err)
		return nil, 0, err
	}
	return res, count, nil
}

接下来，启动服务，用一个全都满足的条件查询试一下：

image-20250414152301005

打印的SQL语句如下：

SELECT * FROM `user` WHERE `user`.`is_deleted` = 0 AND `user`.`user_id` = 1001004 AND `user`.`status` = 2 AND `user`.`email` = 'nieqingchun@test.com' AND `user`.`id` IN (3,4,5) AND `user`.`user_name` LIKE '%nie%' AND `user`.`age` >= 15 AND `user`.`age` <= 30 ORDER BY `user`.`id` DESC LIMIT 10

在测试用例中的测试效果：

func TestGetUserListByGenDemo2(t *testing.T) {
	reqData := &types.UserListRequest{
		UserId:   1001004,
		Status:   2,
		Email:    "nieqingchun@test.com",
		Ids:      "3,4,5",
		UserName: "nie",
		AgeMin:   15,
		AgeMax:   30,
		Page:     1,
		PageSize: 10,
	}

	//执行查询
	ts := utils.NewTestCtx()
	repo := mysql.NewUserRepo(ts.Ctx, ts.SvcCtx)
	list, count, err := repo.GetUserListByGen2(reqData)
	t.Log("list: ", utils.EchoJson(list))
	t.Log("count: ", count)
	t.Log("error: ", err)
	assert.NoError(t, err)
}

image-20250414152916426

综上对比，建议使用这样的方式，因为BuildQueryUserListCondition() 这里封装的查询条件可以给其他方法复用，而且，所有的查询条件的字段都是通过结构体的形式处理的，避免了map中字段写错编译也不报错的情况。

实际项目中使用gorm-gen来生成实体类
水痕
06-16 3278
官网地址，正常的写法是先写数据模型,然后由数据模型自动同步生成到数据库中,但是这样的工作量会比较大,对于写后端的人来说都熟悉。2、使用上面的方式在项目中写出的代码大概是如此，这样如果数据库字段改了,程序是无法识别出来，不能很好的规避错误。语句,正常来说都是先自己手动创建表,利用工具将表字段同步到项目实体类中，刚好可以满足这个需求，写出的代码更好的维护，比如下面的代码。的文件,这个地方是连接数据库的，先运行上面的文件才会生成。5、可以正常使用内置封装好的方法了，3、在项目的根目录下创建一个。
无恒实验室联合GORM推出安全好用的ORM框架-GEN
m0_67392182的博客
04-07 1519
自定 SQL 的安全性是所有 ORM 最难解决的问题，GEN 使用模板注释的方法完美解决了这个问题，只需要将 SQL 注释到 interface 的方法上。SQL 支持简单的 where 查询和完整 SQL 查询，条件用Where()语法包住。Raw SQL 用sql()包住，也可省略直接写。占位符gen.T用于返回数据的结构体，会根据生成结构体或者数据库表结构自动生成gen.M表示,用于返回数据用于执行 SQL 进行更新或删除时候,用于返回影响行数@@table。
为什么选择Minimal：GitHub Pages最简洁主题的深度解析与快速入门指南
最新发布
gitblog_00982的博客
05-21 414
Minimal主题是GitHub Pages平台上最受欢迎、最简洁的Jekyll主题之一，专为技术博客、项目文档和个人网站设计。这个开源主题以其极简主义设计哲学和出色的用户体验而闻名，让开发者能够快速搭建专业美观的静态网站。无论你是GitHub Pages新手还是经验丰富的用户，Minimal主题都能提供完美的平衡——功能齐全却又不会过度复杂。在本文中，我们将深入探讨为什么Minimal主题成为G
2024年Go最全无恒实验室联合GORM推出安全好用的ORM框架-GEN(2)，你花了多久弄明白架构设计
2401_84931693的博客
05-11 1461
自定 SQL 的安全性是所有 ORM 最难解决的问题，GEN 使用模板注释的方法完美解决了这个问题，只需要将 SQL 注释到 interface 的方法上。SQL 支持简单的 where 查询和完整 SQL 查询，条件用Where()语法包住。Raw SQL 用sql()包住，也可省略直接写。占位符gen.T用于返回数据的结构体，会根据生成结构体或者数据库表结构自动生成gen.M表示,用于返回数据用于执行 SQL 进行更新或删除时候,用于返回影响行数@@table。
GORM-GEN快速上手
qq_51438138的博客
02-25 5392
GORM-GEN快速上手
GORM 基础 -- Gen
chinusyan的专栏
03-27 4533
GORM 基础 -- Gen
Golang-GEN 自动生成 GORM 模型结构体文件及使用示例
Ch3nnn的博客
05-29 5675
GEN 是一个基于 GORM 的安全 ORM 框架, 由字节跳动无恒实验室与 GORM 作者联合研发，主要功能说白了就是帮助生成数据表对应的模型文件和更安全方便地执行SQL。
GEN 自动生成 GORM 模型结构体文件及使用示例
Jeffid的博客
09-16 5442
GEN 自动生成 GORM 模型结构体文件及使用示例 帮助生成数据表对应的模型文件和更安全方便地执行SQL
Gorm + Gen自动生成数据库结构体
qq_49723651的博客
11-11 9028
使用gorm操作数据库的时候，需要自己来创建用于映射数据表的结构体，比较繁琐。运行上面的测试文件之后，生成了两个文件夹，其中model文件夹下面是数据表对应的结构体，query文件夹下面则是生成的查询函数。函数就可以生成对应的model，当然不仅仅会生成结构体，还可以生成一些用于查询的API，如果不需要，删除即可。这个工具不仅仅可以用来生成数据表对应的模型文件，还提供了更加安全以及方便的API。
【开发神器】一键生成代码，让开发更高效！
qqxhb 资源共享
06-18 1033
GORM GEN 是 GORM 框架提供的一个命令行工具，它可以根据数据库表的结构自动生成对应的 Go 语言结构体，并且自动添加必要的标签和方法，如表名、主键、索引、查询等。但是，总体来说，GORM GEN 是一款非常实用的开发工具，可以让开发更高效，让你的项目更成功！某公司的开发团队在使用 GORM GEN后，开发效率提高了 50%，同时代码的可读性和可维护性也得到了大幅度提升。不仅如此，GORM GEN还可以避免手写大量的重复代码，提高代码的可读性和可维护性，同时也可以减少开发人员的出错率。
gorm的自动化工具gen_已设置图床
qq_42901723的博客
11-09 940
假设数据库结构如这里使用gen-tool。
gorm 教程三 gen自动代码生成工具
个人博客，记录了本人学习的各种有趣的技术。
10-07 2364
ID int32// 生成的“user”结构的表名方法// 自定义生成的所有结构的表名方法// 为生成的所有结构设置默认 DIY 表名方法。
零基础上手更安全更友好GORM原作者操刀的GORM GEN
qqxhb 资源共享
11-29 9427
GORM/GEN，持续更新欢迎吐槽Star！！！ 基于 GORM, 更安全更友好的ORM工具。 自动生成CRUD和DIY方法 自动根据表结构生成model 完全兼容GORM 更安全、更友好 多种生成代码模式
【GORM（7）】GORM拓展知识：浅挖Gen框架，Gen框架的CRUD操作；自定义SQL
拔高、提升、创新！
11-23 1136
Gen是一个基于GORM的安全ORM框架，其主要通过代码生成方式实现GORM代码封装。使用Gen框架能够自动生成Model结构体和类型安全的CRUD代码，极大提升CRUD效率。 看看Gorm与Gen的关系，类似于Java中的mybatis和mybatis-plus的关系 Gen拥有了代码生成功能，SQL自动生成功能…
gorm 教程三 gen代码生成框架
个人博客，记录了本人学习的各种有趣的技术。
10-15 683
gorm gen gorm 例子 Gen 支持所有GORM Driver从数据库生成结构, 使用示例: ```go package main import "gorm.io/gen" func main() { g := gen.NewGenerator(gen.Config{ // 设置输出路径 OutPath: "../query", Mode: gen....
GORM GEN 生成代码如何自定义方法和表名
ldxxxxll的博客
12-20 1543
相信你在日常使用gorm gen开发的过程中也有这种场景：通过gen的g.GenerateModel(“users”)等方式，从数据库或者sql文件生成了对应的gorm model，已经满足了基本的使用；某些时候希望model上能有一些通用的方法，比如IsEmpty()，判断model是否为空；如果生成之后在修改model，添加自定义方法，下次生成的时候会被覆盖，因此gen提供了WithMethodOption，允许你在生成代码的时候就添加自定义方法，具体使用如下：写一个通用方法的模版。
GORM Gen还是太全面了
m0_57836225的博客
04-19 1238
/ user 用户表userDo userDo // 内嵌GORM生成的基础操作结构体// 以下是数据库表字段的Go语言映射ALL field.Asterisk // 代表所有字段（*）ID field.Int64 // 用户ID（对应数据库id列）Username field.String // 用户名（对应username列）// ...其他字段...fieldMap map[string]field.Expr // 字段名映射表（用于通过字符串动态获取字段表达式）核心设计。
GORM Gen 使用全攻略：提升 Go 数据库开发效率
m0_57836225的博客
04-05 1819
GORM Gen 提供了丰富的配置选项，让我们可以根据项目需求进行定制。OutPath: "./dal/query", // 查询代码输出目录ModelPkgPath: "./dal/model", // 模型代码输出目录// 字段可空性配置})设为true时，生成的模型字段会根据数据库表结构中的可空性进行标记；和则会为模型字段添加索引标签和类型标签，方便在 GORM 操作中使用。如果只需生成特定表的代码，可以使用方法指定表名。// 生成特定表。
golang gorm 查询和多条件拼接和多库查询实践
qq_32421489的博客
06-28 2028
golang gorm 查询和多条件拼接和多库查询实践
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

码农兴哥

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值