作者：ChainDesk韩茹，ChainDesk区块链行业分析师， ChainDesk区块链工程师
ChainDesk官网：http://www.chaindesk.cn/?20181205aliyunmeiti

模型(Models)

一、Model介绍

beego ORM 是一个强大的 Go 语言 ORM 框架，orm模块主要是处理MVC中的M（models）。她的灵感主要来自Django ORM 和 SQLAlchemy。

对象关系映射（Object Relational Mapping，简称ORM）模式是一种为了解决面向对象与关系数据库存在的互不匹配的现象的技术。简单的说，ORM是通过使用描述对象和数据库之间映射的元数据，将程序中的对象自动持久化到关系数据库中。

已支持数据库驱动：

• MySQL : github. com/go-sq-driver/mysql
• PostgreSQL : github. com/lib/pq
• Sqlite3 : github. com/mattn/go-sqite3

模型(Models)
ORM特性:

• 支持Go的所有类型存储
• 轻松上手,采用简单的CRUD风格
• 自动Join关联表
• 跨数据库兼容查询
• 允许直接使用SQL查询/映射
• 严格完整的测试保证ORM的稳定与健壮

1.1 模型定义

复杂的模型定义不是必须的，此功能用作数据库数据转换和自动建表

默认的表名规则，使用驼峰转蛇形：

AuthUser -> auth_user
Auth_User -> auth__user
DB_AuthUser -> d_b__auth_user

除了开头的大写字母以外，遇到大写会增加 _，原名称中的下划线保留。

1.2 自定义表名

type User struct {
    Id int
    Name string
}

func (u *User) TableName() string {
    return "auth_user"
}

如果前缀设置为prefix_那么表名为：prefix_auth_user

1.3 忽略字段

设置 - 即可忽略 struct 中的字段

type User struct {
...
    Username string `orm:"column(username)"`
    AnyField string `orm:"-"`
...
}

结构体和表映射时，可以自动映射，也可以通过orm:column(列名)来指定。

二、安装

安装ORM：

打开终端，输入以下命令：

go get github.com/astaxie/beego/orm

安装成功后，可以查看gopath的src目录：

三、ORM的使用

ORM的使用非常简单，只有三步：

step1：注册（初始化信息）

step2：创建Model（构建struct实体）

step3：数据库操作

我们先通过终端进入gopath的src目录下，使用如下命令，创建一个beego项目：

bee new beegoORM

3.1 注册

3.1.1 注册数据库信息

3.1.1.1 RegisterDriver

三种默认数据库类型

// For version 1.6
orm.DRMySQL
orm.DRSqlite
orm.DRPostgres

// < 1.6
orm.DR_MySQL
orm.DR_Sqlite
orm.DR_Postgres

注册驱动的语法：

// 参数1   driverName
// 参数2   数据库类型
// 这个用来设置 driverName 对应的数据库类型
// mysql / sqlite3 / postgres 这三种是默认已经注册过的，所以可以无需设置
orm.RegisterDriver("mysql", orm.DRMySQL) 

3.1.1.2 RegisterDataBase

ORM 必须注册一个别名为 default 的数据库，作为默认使用。

ORM 使用 golang 自己的连接池。

// 参数1        数据库的别名，用来在 ORM 中切换数据库使用
// 参数2        driverName
// 参数3        对应的链接字符串
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8")

// 参数4(可选)  设置最大空闲连接
// 参数5(可选)  设置最大数据库连接 (go >= 1.2)
maxIdle := 30
maxConn := 30
orm.RegisterDataBase("default", "mysql", "root:root@/orm_test?charset=utf8", maxIdle, maxConn)

3.1.1.3 SetMaxIdleConns

根据数据库的别名，设置数据库的最大空闲连接。

orm.SetMaxIdleConns("default", 30)

3.1.1.4 SetMaxOpenConns

根据数据库的别名，设置数据库的最大数据库连接 (go >= 1.2)

orm.SetMaxOpenConns("default", 30)

3.1.1.5 时区设置

ORM 默认使用 time.Local 本地时区

• 作用于 ORM 自动创建的时间
• 从数据库中取回的时间转换成 ORM 本地时间

如果需要的话，你也可以进行更改

// 设置为 UTC 时间
orm.DefaultTimeLoc = time.UTC

ORM 在进行 RegisterDataBase 的同时，会获取数据库使用的时区，然后在 time.Time 类型存取时做相应转换，以匹配时间系统，从而保证时间不会出错。

注意:

• 鉴于 Sqlite3 的设计，存取默认都为 UTC 时间
• 使用 go-sql-driver 驱动时，请注意参数设置
  从某一版本开始，驱动默认使用 UTC 时间，而非本地时间，所以请指定时区参数或者全部以 UTC 时间存取

例如：root:root@/orm_test?charset=utf8&loc=Asia%2FShanghai
参见 loc / parseTime

3.1.2 注册模型

如果使用 orm.QuerySeter 进行高级查询的话，这个是必须的。

反之，如果只使用 Raw 查询和 map struct，是无需这一步的。您可以去查看 Raw SQL 查询

3.1.2.1 RegisterModel

将你定义的 Model 进行注册，最佳设计是有单独的 models.go 文件，在他的 init 函数中进行注册。

迷你版 models.go

package main

import "github.com/astaxie/beego/orm"

type User struct {
    Id   int
    Name string
}

func init(){
    orm.RegisterModel(new(User))
}

RegisterModel 也可以同时注册多个 model

orm.RegisterModel(new(User), new(Profile), new(Post))

详细的 struct 定义请查看文档 模型定义

3.1.2.2 RegisterModelWithPrefix

使用表名前缀

orm.RegisterModelWithPrefix("prefix_", new(User))

创建后的表名为 prefix_user

3.1.2.3 NewOrmWithDB

有时候需要自行管理连接池与数据库链接（比如：go 的链接池无法让两次查询使用同一个链接的）

但又想使用 ORM 的查询功能

var driverName, aliasName string
// driverName 是驱动的名称
// aliasName 是当前 db 的自定义别名
var db *sql.DB
...
o := orm.NewOrmWithDB(driverName, aliasName, db)

3.1.2.4 GetDB

从已注册的数据库返回 *sql.DB 对象，默认返回别名为 default 的数据库。

db, err := orm.GetDB()
if err != nil {
    fmt.Println("get default DataBase")
}

db, err := orm.GetDB("alias")
if err != nil {
    fmt.Println("get alias DataBase")
}

3.1.2.5 ResetModelCache

重置已经注册的模型 struct，一般用于编写测试用例

orm.ResetModelCache()

3.1.3 示例代码

新建一个Controller，新建go文件(testmodel.go)。

导入包

将你需要使用的driver假如import中：

import (
    _ "github.com/go-sql-driver/mysql"
    _ "github.com/lib/pq"
    _ "github. com/mattn/go-sqlite3"
）

我们可以在init()方法中进行注册：

/**
  初始化db，注册默认数据库，同时将实体模型也注册上去
 */
func init() {
    //注册驱动：如果是默认的三个可以不写
    orm.RegisterDriver("mysql", orm.DRMySQL) //可以省略不写

    //注册默认数据库，ORM 必须注册一个别名为default的数据库，作为默认使用。
    /*
    参数一：数据库别名
    参数二：驱动名称
    参数三：数据库连接字符串:username:password@tcp(127.0.0.1:3306)/databasename?charset=utf8
    参数四：设置数据库的最大空闲连接
    */
    orm.RegisterDataBase("default", "mysql", "root:hanru1314@tcp(127.0.0.1:3306)/mytest?charset=utf8", 30)
}

3.2 创建Model

3.2.1 自动建表

//自动建表
orm.RunSyncdb("default", false, true)

以下是官方文档的案例：

3.2.1.1 关系模型

# 外键始终在子表上

#一个用户对应一个简介；一个简介对应一个用户；
one2one:User(子表) -> Profile（主表）;one2one:Profile -> User 

#一个邮件对应一个用户；一个用户有多个邮件；
one2many:Post(子表) -> User（主表）;many2one:User -> Post 

#一个邮件对应多个标签；一个标签对应多个邮件；
many2many:Post(子表) -> Tag（主表）;many2many:Tag -> Post 

说明：

使用标签`orm:"column(id)`对属性进行标注，用于解析。
标注逻辑外键，自动建表时不会生成外键。
`orm:"rel(one)"` 表示one2one
`orm:"rel(fk)"`  表示one2many
`orm:"rel(m2m)"` 表示many2many
`orm:"reverse(one)"` `orm:"reverse(one)"`  标注反向关系

3.2.1.2 创建结构体

//-----------定义struct-------------

type User struct { // 对应user表
    Id      int
    Name    string
    Profile *Profile `orm:"rel(one)"`      // OneToOne relation
    Post    []*Post  `orm:"reverse(many)"` // 设置一对多的反向关系
}

type Profile struct {
    Id   int
    Age  int16
    User *User `orm:"reverse(one)"` // 设置一对一反向关系(可选)
}

type Post struct {
    Id    int
    Title string
    User  *User  `orm:"rel(fk)"` //设置一对多关系
    Tags  []*Tag `orm:"rel(m2m)"`
}

type Tag struct {
    Id    int
    Name  string
    Posts []*Post `orm:"reverse(many)"`
}

3.2.2 注册Model

在init()方法 中，添加注册model代码：

func init() {
    orm.RegisterDriver("mysql", orm.DRMySQL) //可以不加
    orm.RegisterDataBase("default", "mysql", "root:hanru1314@tcp(127.0.0.1:3306)/mytest?charset=utf8", 30)

    // 需要在init中注册定义的model
    orm.RegisterModel(new(User), new(Post), new(Profile), new(Tag)
}

3.2.3 示例代码：

修改router.go文件，注册路由：

func init() {
    beego.Router("/", &controllers.MainController{})
    beego.Router("/testcreatetable", &controllers.ModelController{},"get:CreateTable")
}

在testmodel.go中，添加对应路由的方法：

func (c *ModelController) CreateTable(){
    //自动建表
    orm.RunSyncdb("default", false, true)
    datainit()
}

我们先添加一个初始化信息的方法，关于CRUD的部分，后面会详细讲解：

func datainit() {
    o:=orm.NewOrm()
     //rel  : 自动生成外键为 表名_id
    sql1 := "insert into user (name,profile_id) values ('hanru',1),('ruby',2),('王二狗',3);"
    sql2 := "insert into profile (age) values (20),(19),(21);"
    sql3 := "insert into tag (name) values ('offical'),('beta'),('dev');"
    sql4 := "insert into post (title,user_id) values ('paper1',1),('paper2',1),('paper3',2),('paper4',3),('paper5',3);"
    // m2m 生成的 表名：子表_主表s  主键自增
    sql5 := "insert into post_tags (tag_id, post_id) values (1,1),(1,3),(2,2),(3,3),(2,4),(3,4),(3,5); "

    //使用Raw（）.Exec（）执行sql
    o.Raw(sql1).Exec()
    o.Raw(sql2).Exec()
    o.Raw(sql3).Exec()
    o.Raw(sql4).Exec()
    o.Raw(sql5).Exec()
}

启动项目后，打开浏览器输入：http://127.0.0.1:8080/testcreatetable执行，然后刷新数据库，我们发现已经创建好了5张数据表：

接下来我们查询一下表结构：

3.2.4 database生成规则

1.添加rel（one）、rel（fk）的属性会生成 表名_id的字段，rel(one)时生成字段key为unique

type User struct {
    Profile *Profile `orm:"rel(one)"`
}

type Profile struct {
    User *User `orm:"reverse(one)"`  //可以省略
}
---->
mysql> desc user;
+------------+--------------+------+-----+---------+----------------+
| Field      | Type         | Null | Key | Default | Extra          |
+------------+--------------+------+-----+---------+----------------+
| id         | int(11)      | NO   | PRI | NULL    | auto_increment |
| name       | varchar(255) | NO   |     |         |                |
| profile_id | int(11)      | NO   | UNI | NULL    |                |
+------------+--------------+------+-----+---------+----------------+

2.rel（m2m）、reverse（many）这一对字段 会生成关系对应表 子表_主表s 主键自增

type Post struct {
    Tags  []*Tag `orm:"rel(m2m)"` // m2m relation
}

type Tag struct {
    Posts []*Post `orm:"reverse(many)"`
}
---->
mysql> desc post_tags;
+---------+------------+------+-----+---------+----------------+
| Field   | Type       | Null | Key | Default | Extra          |
+---------+------------+------+-----+---------+----------------+
| id      | bigint(20) | NO   | PRI | NULL    | auto_increment |
| post_id | int(11)    | NO   |     | NULL    |                |
| tag_id  | int(11)    | NO   |     | NULL    |                |
+---------+------------+------+-----+---------+----------------+

接下来我们查询一下表中的数据：

1.user表：

2.profile表：

3.post表：

4.tag表：

5.post_tags表：

3.3 ORM 接口使用

使用 ORM 必然接触的 Ormer 接口，我们来熟悉一下

var o Ormer
o = orm.NewOrm() // 创建一个 Ormer
// NewOrm 的同时会执行 orm.BootStrap (整个 app 只执行一次)，用以验证模型之间的定义并缓存。

切换数据库，或者，进行事务处理，都会作用于这个 Ormer 对象，以及其进行的任何查询。

所以：需要 切换数据库 和 事务处理 的话，不要使用全局保存的 Ormer 对象。

• type Ormer interface {

  • Read(interface{}, …string) error
  • ReadOrCreate(interface{}, string, …string) (bool, int64, error)
  • Insert(interface{}) (int64, error)
  • InsertMulti(int, interface{}) (int64, error)
  • Update(interface{}, …string) (int64, error)
  • Delete(interface{}) (int64, error)
  • LoadRelated(interface{}, string, …interface{}) (int64, error)
  • QueryM2M(interface{}, string) QueryM2Mer
  • QueryTable(interface{}) QuerySeter
  • Using(string) error
  • Begin() error
  • Commit() error
  • Rollback() error
  • Raw(string, …interface{}) RawSeter
  • Driver() Driver
• }

3.3.1 QueryTable

传入表名，或者 Model 对象，返回一个 QuerySeter

o := orm.NewOrm()
var qs QuerySeter
qs = o.QueryTable("user")
// 如果表没有定义过，会立刻 panic

3.3.2 Using

切换为其他数据库

orm.RegisterDataBase("db1", "mysql", "root:root@/orm_db2?charset=utf8")
orm.RegisterDataBase("db2", "sqlite3", "data.db")

o1 := orm.NewOrm()
o1.Using("db1")

o2 := orm.NewOrm()
o2.Using("db2")

// 切换为其他数据库以后
// 这个 Ormer 对象的其下的 api 调用都将使用这个数据库

默认使用 default 数据库，无需调用 Using

3.3.3 Raw

使用 sql 语句直接进行操作

Raw 函数，返回一个 RawSeter 用以对设置的 sql 语句和参数进行操作

o := NewOrm()
var r RawSeter
r = o.Raw("UPDATE user SET name = ? WHERE name = ?", "testing", "slene")

3.3.4 Driver

返回当前 ORM 使用的 db 信息：

type Driver interface {
    Name() string
    Type() DriverType
}

示例代码：

orm.RegisterDataBase("db1", "mysql", "root:root@/orm_db2?charset=utf8")
orm.RegisterDataBase("db2", "sqlite3", "data.db")

o1 := orm.NewOrm()
o1.Using("db1")
dr := o1.Driver()
fmt.Println(dr.Name() == "db1") // true
fmt.Println(dr.Type() == orm.DRMySQL) // true

o2 := orm.NewOrm()
o2.Using("db2")
dr = o2.Driver()
fmt.Println(dr.Name() == "db2") // true
fmt.Println(dr.Type() == orm.DRSqlite) // true

关于数据库的具体操作，我们下一章节继续讲解。

ChainDesk，是一个学习方式 
chaindesk.cn，首创基于区块链的多相脑图分割模型学习社区
独创 专业 系统 高效是我们的代名词，学你想学，想你所想
，在这里，找到你的小伙伴，一起学习，一同成长