beego框架之orm的使用

　 最近想项目接触到了用go语言来操做数据库msyql，用到了beego的orm，beego ORM（Object Relational Mapping） 是一个强大的 Go 语言 ORM 框架。它的灵感主要来自 Django ORM 和 SQLAlchemy。功能仍是比较强大的。
目前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。

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   //最大链接数
}

usermanger.go

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

注意可使用如下方式进行切换数据库：

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.操做数据库

1. 对于要操做的数据库若是你知道它的主键，则你能够用orm对象的crud方法进行数据库的相关操做。

/**
 *经过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)       
      }   

1. 若是你不知道主键则能够经过orm的Querytable或者Raw执行原始的sql语句来操做数据库。

/**
根据某些字段来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
}                      

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

 /**
  * 分页结构体                           
 */                            
 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 则更适用于复杂的查询，例如查询中包含子查询和多重联结。使用方法以下:

// 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()
}