深入理解 Beego ORM：原理与示例

Beego ORM 说明

官方文档——快速开始
Beego ORM（对象关系映射）是 Beego 框架中的一个模块，用于将应用程序的数据模型与数据库表之间建立映射关系，使开发人员能够通过 Go 语言代码来进行数据库操作，而不必直接编写 SQL 查询语句。

Beego ORM 的一些基本原理和特点

1. 定义数据模型：type User struct {}

开发人员需要定义数据模型，通常是 Go 语言的结构体，每个字段表示数据库表的一个列。在结构体中使用标签来指定字段与数据库表的映射关系，包括列名、数据类型等。

type User struct {
	ID           int       `orm:"column(id);auto"`
	UserAccount  string    `orm:"column(userAccount);unique"` //为单个字段增加 unique键
	UserRole     string    `orm:"column(userRole);default(user)"`
	UserName     string    `orm:"column(userName);null"`
	UserAvatar   string    `orm:"column(userAvatar);null"`
	Gender       int8      `orm:"column(gender);null"`
	UserPassword string    `orm:"column(userPassword)"`
	CreateTime   time.Time `orm:"column(createTime);auto_now_add;type(datetime)"` //auto_now_add 第一次保存时才设置时间
	UpdateTime   time.Time `orm:"column(updateTime);auto_now;type(datetime)"`     //auto_now 每次model保存时都会对时间自动更新
	IsDelete     int32     `orm:"column(isDelete)"`
	Test         string    `orm:"-"` //- 即可忽略模型中的字段
}
// 设置引擎为 INNODB
func (u *User) TableEngine() string {
	return "INNODB"
}

2. 注册模型：orm.RegisterModel(new(User))

开发人员需要将定义的数据模型注册到 ORM 中，以便 ORM 知道要操作哪些数据表以及数据表的结构。

orm.RegisterModel(new(User))

3. 注册数据库连接：orm.RegisterDataBase("default", "mysql", "user:pwd@tcp(mysql)/dbname?charset=utf8&parseTime=true")

开发人员需要配置数据库连接信息，包括数据库类型、连接字符串等。ORM 使用这些信息来连接数据库。

orm.RegisterDataBase("default", "mysql", "user:pwd@tcp(mysql)/dbname?charset=utf8&parseTime=true")

4. 数据库表结构同步：orm.RunSyncdb("default", false, true)

在应用程序启动时，ORM 可以自动检查数据库表结构与数据模型的定义是否一致，如果不一致，可以选择自动更新数据库表结构，以便与数据模型保持一致。

err := orm.RunSyncdb("default", false, true)
if err != nil {
	fmt.Println("数据库表结构同步操作失败 err=", err.Error())
}

5. 创建 ORM 对象：o = orm.NewOrm()

o = orm.NewOrm()

6. 数据库操作：o.Insert(XXX)

开发人员可以使用 ORM 提供的方法来执行数据库操作，包括插入、查询、更新和删除等操作。ORM 将这些操作转化为相应的 SQL 查询语句，并执行数据库操作。

func Add() int64 {
	// 创建了一个新的 User 模型对象，准备插入到数据库中。
	user := new(User)
	user.UserAccount = "xiaoxiong"

	// 执行数据库插入操作，将 user 对象插入到数据库中。num 变量表示插入的记录数，err 变量表示操作中的任何错误。
	num, err := O.Insert(user)
	if err != nil {
		fmt.Println("数据库插入操作失败[o.Insert(user)] err=", err.Error())
	}
	fmt.Println("数据库插入操作成功[o.Insert(user) succeed] num=", num)
	return num
}

func GetById(id int64) (*User, error) {
	qs := O.QueryTable(new(User))

	var userInfo User
	err := qs.Filter("id", id).Filter("isDelete", 0).One(&userInfo) //注意这里不能是 var userInfo *User，否则报错
	if err == orm.ErrMultiRows {
		fmt.Printf("user 表中存在 id=[%d] 的多条记录, qs.One err=[%v] \n", id, err.Error())
		return nil, err
	}
	if err == orm.ErrNoRows {
		fmt.Printf("user 表没有找到 id=[%d] 的记录, qs.One err=[%v] \n", id, err.Error())
		return nil, err
	}
	return &userInfo, nil
}

6. 事务支持：

ORM 提供了事务支持，开发人员可以使用事务来确保一系列数据库操作要么全部成功，要么全部失败，以保持数据的一致性。

官方文档——事务

7. 定义过滤器和钩子：orm.AddGlobalFilterChain(builder.FilterChain)

ORM 允许开发人员定义过滤器和钩子函数，以在数据操作前后执行特定的逻辑。这些过滤器和钩子可以用于实现验证、默认值设置等功能。

builder := bean.NewDefaultValueFilterChainBuilder(nil, true, true)
orm.AddGlobalFilterChain(builder.FilterChain)

8. 建立不同表之间的映射关系：

ORM 可以建立不同表之间的映射关系，包括一对一、一对多、多对一、多对多等关系，以便更容易进行复杂的数据查询和操作。

官方文档——关联表查询

9. 缓存支持：

一些 ORM 框架提供了缓存支持，可以缓存数据库查询结果，以提高查询性能。

总结

ORM 的原理是将数据模型与数据库表之间建立映射关系，并提供一组方法来执行数据库操作，以简化开发人员与数据库交互的过程，减少手动编写 SQL 查询语句的工作。
ORM 通过将对象操作映射到底层数据库操作，提高了开发效率，降低了数据库操作的复杂性。不同的编程语言和框架都有自己的 ORM 实现，但基本原理类似。

示例代码

源码地址： GitHub

package main

import (
	"fmt"
	_ "simple-orm-bee/routers"
	"time"

	"github.com/beego/beego/v2/client/orm"
	"github.com/beego/beego/v2/client/orm/filter/bean"
	beego "github.com/beego/beego/v2/server/web"
	_ "github.com/go-sql-driver/mysql"
)

type User struct {
	//orm 为字段设置 DB 列的名称
	ID           int       `orm:"column(id);auto"`            //auto显示指定一个字段为自增主键，该字段必须是 int, int32, int64, uint, uint32, 或者 uint64
	UserAccount  string    `orm:"column(userAccount);unique"` //为单个字段增加 unique键
	AccessKey    string    `orm:"column(accessKey);index"`    //为单个字段增加索引
	SecretKey    string    `orm:"column(secretKey)"`
	UserRole     string    `orm:"column(userRole);default(admin)"`
	UserName     string    `orm:"column(userName);null"` //null代表ALLOW NULL
	UserAvatar   string    `orm:"column(userAvatar);null"`
	Gender       int8      `orm:"column(gender);null"`
	UserPassword string    `orm:"column(userPassword)"`
	CreateTime   time.Time `orm:"column(createTime);auto_now_add;type(datetime)"` //auto_now_add 第一次保存时才设置时间
	UpdateTime   time.Time `orm:"column(updateTime);auto_now;type(datetime)"`     //auto_now 每次model保存时都会对时间自动更新
	IsDelete     int32     `orm:"column(isDelete)"`
	Test         string    `orm:"-"` //- 即可忽略模型中的字段
}

// 设置引擎为 INNODB
func (u *User) TableEngine() string {
	return "INNODB"
}

// 自定义表名
func (u *User) TableName() string {
	return "user"
}

var O orm.Ormer

func init() {
	// 注册 ORM 模型。new(User) 创建了一个新的 User 模型对象并注册到 ORM 中。这样 ORM 知道了要操作哪个数据表和数据表的结构。
	orm.RegisterModel(new(User))

	// 注册默认的数据库连接。告诉 ORM 使用 MySQL 数据库，数据库连接字符串为 "root:xxx"，并且指定了连接别名为 "default"。这个连接别名会在后续的数据库操作中使用。
	orm.RegisterDataBase("default", "mysql", "root:@tcp(127.0.0.1:3306)/xapi?charset=utf8")

	// 创建一个 ORM 对象 o，用于执行数据库操作。
	O = orm.NewOrm()
}
func main() {
	// 执行数据库表结构同步操作。告诉 ORM 在默认数据库连接上执行同步操作，第二个参数 false 表示不强制删除已存在的表，第三个参数 true 表示打印同步操作的日志。这通常在应用程序启动时执行，以确保数据库表结构与 ORM 模型定义一致。
	err := orm.RunSyncdb("default", false, true)
	if err != nil {
		fmt.Println("数据库表结构同步操作失败[orm.RunSyncdb] err=", err.Error())
	}

	// 创建一个默认值过滤器链构建器。默认值过滤器用于在插入数据时为字段设置默认值。这里创建了一个新的构建器，第二个参数 true 表示启用默认值过滤器，第三个参数 true 表示打印过滤器日志。
	builder := bean.NewDefaultValueFilterChainBuilder(nil, true, true)
	// 将默认值过滤器链添加到全局过滤器链中，以便在插入数据时应用默认值过滤器。
	orm.AddGlobalFilterChain(builder.FilterChain)

	id := Add()

	userinfo, err := GetById(id)
	if err == nil {
		fmt.Println("userinfo=", userinfo)
	}

	beego.Run()
}

func GetById(id int64) (*User, error) {
	qs := O.QueryTable(new(User))

	var userInfo User
	err := qs.Filter("id", id).Filter("isDelete", 0).One(&userInfo) //注意这里不能是 var userInfo *User，否则报错
	if err == orm.ErrMultiRows {
		fmt.Printf("user 表中存在 id=[%d] 的多条记录, qs.One err=[%v] \n", id, err.Error())
		return nil, err
	}
	if err == orm.ErrNoRows {
		fmt.Printf("user 表没有找到 id=[%d] 的记录, qs.One err=[%v] \n", id, err.Error())
		return nil, err
	}
	return &userInfo, nil
}

func ListByIds(ids []int64) ([]*User, error) {
	qs := O.QueryTable(new(User))

	var users []*User
	qs = qs.Filter("id__in", ids).Filter("isDelete", 0)
	_, err := qs.All(&users) //这里可以是 var users []*User 或者 var users []User
	if err != nil {
		fmt.Printf("User ListByIds qs.All error: %v \n", err.Error())
		return users, err
	}
	return users, nil
}

func Add() int64 {
	// 创建了一个新的 User 模型对象，准备插入到数据库中。
	user := new(User)
	user.UserAccount = "xiaoxiong"

	// 执行数据库插入操作，将 user 对象插入到数据库中。num 变量表示插入的记录数，err 变量表示操作中的任何错误。
	num, err := O.Insert(user)
	if err != nil {
		fmt.Println("数据库插入操作失败[o.Insert(user)] err=", err.Error())
	}
	fmt.Println("数据库插入操作成功[o.Insert(user) succeed] num=", num)
	return num
}