beego框架学习(三) -orm的使用

我的未来我决定 提交于 2019-11-28 08:23:14

 

2
3
4
5
6
7
8
9
10
11
目前beego-orm支持的数据有:
- MySQL:https://github.com/go-sql-driver/mysql
- PostgreSQL:https://github.com/lib/pq
- Sqlite3:https://github.com/mattn/go-sqlite
beego-orm的相关特性
- 支持 Go 的所有类型存储
- 轻松上手,采用简单的 CRUD 风格
- 自动 Join 关联表
- 跨数据库兼容查询
- 允许直接使用 SQL 查询/映射
- 严格完整的测试保证 ORM 的稳定与健壮

  


orm的使用 
- 导入orm的依赖:go get github.com/astaxie/beego/orm. 
- 使用的步骤: 
1.往orm注册默认数据库(包括数据库的连接的一些设置参数),往orm注册model。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
def.go
/**
*实体定义
*/
type User struct {
Id int `json:"id" pk:"auto" orm:"column(id)"`
Username string `json:"username" orm:"column(username)"`
Password string `json:"password" orm:"column(password)"`
Sex string `json:"sex" orm:"column(sex)"`
Tel string `json:"tel" orm:"column(tel)"`
}
/**
*数据相关配置
*/
type DBConfig struct {
Host string
Port string
Database string
Username string
Password string
MaxIdleConns int //最大空闲连接
MaxOpenConns int //最大连接数
}

  

1
usermanger.go
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
package service
import (
"github.com/astaxie/beego/orm"
"fmt"
log "github.com/Sirupsen/logrus"
"github.com/go-sql-driver/mysql"
)
/**
*CreatedBy:Hanyajun
*Time:2017 2017/10/28 14:34
*Project:Go_study
*Discription:使用orm操作mysql
*/
type UserManager struct {
DBConf *DBConfig
}
/*
* usermanger构造器
*/
func NewUserManager(dbConf *DBConfig) *UserManager {
mgr := &UserManager{
DBConf: dbConf,
}
mgr.initDB()//初始化orm
return mgr
}
/**
初始化db,注册默认数据库,同时将实体模型也注册上去
*/
func (mgr *UserManager) initDB() {
orm.RegisterDriver("mysql", orm.DRMySQL)
   ds :=fmt.Sprintf("%s:%s@tcp(%s:%s)/%s?        charset=utf8", mgr.DBConf.Username, mgr.DBConf.Password, mgr.DBConf.Host, mgr.DBConf.Port, mgr.DBConf.Database)
log.Infof("datasource=[%s]", ds)
  err := orm.RegisterDataBase("default""mysql", ds,   mgr.DBConf.MaxIdleConns, mgr.DBConf.MaxOpenConns)
if err != nil {
panic(err)
}
orm.RegisterModel(new(User))
}

  

注意可以使用以下方式进行切换数据库:

1
2
3
4
5
6
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")

  

2.操作数据库

对于要操作的数据库如果你知道它的主键,则你可以用orm对象的crud方法进行数据库的相关操作。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
/**
*通过orm对象来进行数据库的操作,这种情况是必须要知道主键
*/
func (mgr *UserManager) OpreateUserWithOrmObjct(id int) () {
orm.Debug = true
o := orm.NewOrm()
var users = new(User)//注意使用new来创建变量,否则就会报错
users.Id = id
fmt.Print("******开始读取数据库*******")
o.Read(users)
fmt.Print(users)
fmt.Print("******开始更新数据库*******")
users.Username = "123"
o.Update(users)
o.Read(users)
fmt.Printf("更新后的数据库为%v", users)
o.Delete(users)
}

  

如果你不知道主键则可以通过orm的Querytable或者Raw执行原始的sql语句来操作数据库。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
/**
根据某些字段来read 1:采用queryTable方法来查询 2:采用Raw执行sql语句
*/
func (mgr *UserManager) GetUsersByIdWithQueryTable(id string) (*[]User, error) {
orm.Debug = true
o := orm.NewOrm()
user := new([]User)
_, err := o.QueryTable("user").Filter("Id", id).All(user)
//err := o.QueryTable("user").Filter("id",key).One(user)
//err:=o.Raw("select * from user where Id = ?",id).QueryRow(user)//使用sql语句进行查询
if err != nil {
fmt.Println(err)
return nil, err
}
return user, nil
}

  

3. 分页查询,可以使用limt方法来进行分页(注意limt后面的参数,第一个表示的是分页大小,第二个是指的偏移量,如同sql的offset)。

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
/**
* 分页结构体
*/
type Page struct {
PageNo int
PageSize int
TotalPage int
TotalCount int
FirstPage bool
LastPage bool
List interface{}
}
func PageUtil(count int, pageNo int, pageSize int, list interface{}) Page {
tp := count / pageSize
if count % pageSize > 0 {
tp = count / pageSize + 1
}
return Page{
PageNo: pageNo,
PageSize: pageSize,
TotalPage: tp,
TotalCount: count,
FirstPage: pageNo == 1,
LastPage: pageNo == tp,
List: list
}
}
func (mgr *UserManager) getUsrsWithPage(ps int, pageSize int) (page Page ) {
o := orm.NewOrm()
user:=new([]User)
o.QueryTable("user").Limit(pageSize,(ps-1)*pageSize).All(user)
TotalCount,_:=o.QueryTable("user").Count()
page.TotalCount=int(TotalCount)
page.PageSize=pageSize
page.List=user
fmt.Println(user)
return page
}

  

除了以上方法操作数据库, QueryBuilder 提供了一个简便,流畅的 SQL 查询构造器。在不影响代码可读性的前提下用来快速的建立 SQL 语句,QueryBuilder 在功能上与 ORM 重合, 但是各有利弊。ORM 更适用于简单的 CRUD 操作,而 QueryBuilder 则更适用于复杂的查询,例如查询中包含子查询和多重联结。使用方法如下:

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
// User 包装了下面的查询结果
type User struct {
Name string
Age int
}
var users []User
// 获取 QueryBuilder 对象. 需要指定数据库驱动参数。
// 第二个返回值是错误对象,在这里略过
qb, _ := orm.NewQueryBuilder("mysql")
// 构建查询对象
qb.Select("user.name",
"profile.age").
From("user").
InnerJoin("profile").On("user.id_user = profile.fk_user").
Where("age > ?").
OrderBy("name").Desc().
Limit(10).Offset(0)
// 导出 SQL 语句
sql := qb.String()
// 执行 SQL 语句
o := orm.NewOrm()
o.Raw(sql, 20).QueryRows(&users)
 
当然数据库操作必然离不开事物,orm支持简单的orm事物操作:
o := NewOrm()
err := o.Begin()
// 事务处理过程
...
...
// 此过程中的所有使用 o Ormer 对象的查询都在事务处理范围内
if SomeError {
err = o.Rollback()
else {
err = o.Commit()
}

  

易学教程内所有资源均来自网络或用户发布的内容,如有违反法律规定的内容欢迎反馈
该文章没有解决你所遇到的问题?点击提问,说说你的问题,让更多的人一起探讨吧!