• 深入理解 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"
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17

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

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

    orm.RegisterModel(new(User))

    • 1

    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")

    • 1

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

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

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

    • 1
    • 2
    • 3
    • 4

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

    o = orm.NewOrm()

    • 1

    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
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29

    6. 事务支持：

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

    官方文档——事务

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

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

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

    • 1
    • 2

    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
}

    • 1
    • 2
    • 3
    • 4
    • 5
    • 6
    • 7
    • 8
    • 9
    • 10
    • 11
    • 12
    • 13
    • 14
    • 15
    • 16
    • 17
    • 18
    • 19
    • 20
    • 21
    • 22
    • 23
    • 24
    • 25
    • 26
    • 27
    • 28
    • 29
    • 30
    • 31
    • 32
    • 33
    • 34
    • 35
    • 36
    • 37
    • 38
    • 39
    • 40
    • 41
    • 42
    • 43
    • 44
    • 45
    • 46
    • 47
    • 48
    • 49
    • 50
    • 51
    • 52
    • 53
    • 54
    • 55
    • 56
    • 57
    • 58
    • 59
    • 60
    • 61
    • 62
    • 63
    • 64
    • 65
    • 66
    • 67
    • 68
    • 69
    • 70
    • 71
    • 72
    • 73
    • 74
    • 75
    • 76
    • 77
    • 78
    • 79
    • 80
    • 81
    • 82
    • 83
    • 84
    • 85
    • 86
    • 87
    • 88
    • 89
    • 90
    • 91
    • 92
    • 93
    • 94
    • 95
    • 96
    • 97
    • 98
    • 99
    • 100
    • 101
    • 102
    • 103
    • 104
    • 105
    • 106
    • 107
    • 108
    • 109
    • 110
    • 111
    • 112
    • 113
    • 114
    • 115
    • 116
  • 相关阅读:
    mysql 8.0.28 查询语句执行顺序实测结果
    专栏 | 解析“全闪对象存储”（二）
    学习响应式布局
    部署Kafka
    基于 vue-element-template 框架添加 tagsview
    对于Biotin-LC-NHS Estercas:72040-63-2与伯氨基 (-NH2) 反应的作用有哪些？
    己知一棵有 2011 个结点的树，其叶结点个数为 116，该树对应的二叉树无右孩子的结点个数是
    MVP 聚技站｜.NET C# 系列（六）：调试 C# 控制台应用程序
    爬楼梯（小数据方式+大数据方式）
    香港回归20余年，图扑数字孪生港珠澳大桥，超震撼
  • 原文地址：https://blog.csdn.net/trinityleo5/article/details/133385516