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