Go实战项目-Beego的orm的基本使用

beego的使用三部曲:
1、在controllers里面创建控制器
2、在module里面创建数据模型
3、在router设置路由控制
对于beego的orm使用有很多种方式,我们主要采用过滤器的方式来实现。因为前面说过,严禁使用原生的sql语句。

单表查询

依然三部曲:
1、创建模型
2、注册模型
3、使用模型获取数据

//注意表和列的命名规则
type CLogin struct {
    Id             int       `orm:"column(id)" json:"id"`
    LoginId        string    `orm:"column(LoginId)" json:"LoginId"`
    Pwd            string    `orm:"column(Pwd)" json:"Pwd"`
    FullName       string    `orm:"column(FullName)" json:"FullName"`
    DepartmentId   int       `orm:"column(DepartmentId)" json:"DepartmentId"`
    DepartmentName string    `orm:"column(DepartmentName)" json:"DepartmentName"`
    RoleId         int       `orm:"column(role_id)" json:"role_id"`
    Deleted        int       `orm:"column(deleted)" json:"deleted"`
    Telephone      string    `orm:"column(telephone)" json:"telephone"`
    IdCard         string    `orm:"column(id_card)" json:"id_card"`
    JobCard        string    `orm:"column(job_card)" json:"job_card"`
    EnterpriseId   int64     `orm:"column(enterpriseId)" json:"enterpriseId"`
    UpdateTime     time.Time `orm:"type(datetime);column(update_time)" json:"update_time"` //date  这些tag可以通过反射来自己实现
    //CRole          *CRoles `orm:"rel(one)" json:"role"`
}

站在这里就有int,string,date格式的表述,其他类型,都是一次类推,特殊类型的,可以用type指定,如orm:”type(datetime);column(update_time)

单表查询的一种方式,仅仅作为演示:

    o := orm.NewOrm()
    user = CLogin{LoginId: loginId}
    err = o.Read(&user, "LoginId")
    //多条件不能这么写,这样获取不到数据
    //user = CLogin{LoginId: loginId, Pwd: md5Pwd}

注意,这种方式只能匹配第一参数,后面添加了也不会识别,不知道是不是我使用的问题还是怎么回事,咱的重点也不在这,由于此项目没有外键,无法进行模型关联查询,所以只能舍弃这种方式的研究,采用过滤器的方式。当然,还有build的方式来实现,可以参考官网自己实现。

//采用过滤器QuerySeter实现
err = o.QueryTable(“c_login”).Filter(“LoginId”,loginId).Filter(“pwd”,pwd).One(&user)
不定项条件查询:

//不定项多条件查询
querySet := o.QueryTable("c_login")
querySet = querySet.Filter("LoginId", loginId)
if pwd != "123456" {
    querySet = querySet.Filter("pwd", pwd)
}
err = querySet.One(&user)

注意,不能采用链式直连的方式,如果去掉多次赋值的话,前面的条件都不会生效,因为在他是采用值复制的方式传递的,并非采用引用传递的。

多表查询

前面有说到,建立模型可以直接正在做到关联查询,前提是必须要有外键的存在,前人制造的表结构,我们也不好意思评价,这恰恰可以给我们成长提供机会。所以,我采用的是raw,采用占位符的方式,否则就需要建立外键和对应的外键id,否则会报错提是找不到外键id。

//获取角色权限
func GetRoleSession(roleId int) ([]orm.Params, error) {
    var (
        err  error
        maps []orm.Params
    )
    o := orm.NewOrm()
    _, err = o.Raw("select p.id,p.url,p.name, p.code,1 as checked from c_role_power as r join c_power as p on r.pid = p.id where r.rid=?", roleId).Values(&maps)
    return maps, err
}

其他操作

querySeter的其他操作,可以仿照查询的条件添加方式进行操作。可以hi姐实现。比如:

//更新c_login表
func LoginUpdate(id int, pwd string) error {
    o := orm.NewOrm()
    querySetter := o.QueryTable("c_login")
    querySetter = querySetter.Filter("id", id)
    params := make(map[string]interface{})
    params["id"] = id
    params["Pwd"] = utils.Md5(pwd)
    params["update_time"] = time.Now().Format("2006-01-02 15:04:05")
    fmt.Println("params", params)
    _, err := querySetter.Update(params)
    return err
}

Update(values Params) (int64, error)
Delete() (int64, error)
PrepareInsert() (Inserter, error)
Exist() bool :判断表书否存在,这个对于私有化部署,代码添加新表做升级处理方便直接的多。

别忘了,还有注册结构模型

    orm.RegisterModel(new(CLogin), new(CRoles))
    //orm.RegisterModelWithPrefix("c_", new(Roles))

除了直接注册表名规范之外,还有前缀的方式添加, 这样结构体的名字就不会这么的恶心了。

orm的连接池和库切换

这个多库的比较麻烦,必须要注册数据库,并且要设置别名,后续的使用也是必须使用别名来调用数据库才能生效。直接贴上工具类:

//Use "callout" db "default" as alias name if you not set.
func GetOrm(dbName ...string) (orm.Ormer, error) {
    var (
        alias      string
        tempDbName string
        err        error
    )
    if len(dbName) > 0 {
        tempDbName = dbName[0]
    } else {
        tempDbName = "callout"
    }
    o := orm.NewOrm()
    if tempDbName == "callout" {
        alias = "default"
    } else if tempDbName == "default" {
        alias = "default"
    } else if !strings.HasPrefix(tempDbName, "co") {
        alias = "co" + tempDbName
    } else {
        alias = "default"
    }

    logs.Info("alias: ", alias)
    err = o.Using(alias) //这里使用的是数据库的别名,不是直接连接数据库
    logs.Info("using alias err: ", err)
    if err != nil { //代表没有这个别名的数据库,需要注册
        registerDatabases(alias)
        err = o.Using(alias)
        logs.Info("using alias against err: ", err)
    }
    return o, err
}

//初始化设置数据库,注册一个默认的数据库,并设置最大连接数和最大空闲数
func InitBeeGoOrm() {
    defaultDB := beego.AppConfig.String("defaultDB") //app.conf文件配置
    err := orm.RegisterDriver("mysql", orm.DRMySQL)
    if err != nil {
        fmt.Println("RegisterDriver err: ", err)
    }
    // 参数1        数据库的别名,用来在 ORM 中切换数据库使用
    // 参数2        driverName
    // 参数3        对应的链接字符串
    // 参数4(可选)  设置最大空闲连接
    // 参数5(可选)  设置最大数据库连接 (go >= 1.2)
    err = orm.RegisterDataBase("default", "mysql", defaultDB, 50, 100) //暂时写死,可以写成动态的
    if err != nil {
        fmt.Println("RegisterDataBase err: ", err)
    }
}

//注册数据库
func registerDatabases(dbName string) {
    mySqlUser := beego.AppConfig.String("mySqlUser")
    mySqlPwd := beego.AppConfig.String("mySqlPwd")
    mySqlAddress := beego.AppConfig.String("mySqlAddress")
    fmt.Println("RegisterDataBase: ", mySqlUser, mySqlPwd, mySqlAddress)
    defaultDB := fmt.Sprintf("%s:%s@(%s)/%s?timeout=30s&charset=utf8mb4&collation=utf8mb4_general_ci", mySqlUser, mySqlPwd, mySqlAddress, dbName)
    fmt.Println("RegisterDataBase defaultDB: ", defaultDB)
    err := orm.RegisterDataBase(dbName, "mysql", defaultDB, 50, 100)
    if err != nil {
        fmt.Println("RegisterDataBase err: ", err)
    }
}

多库之间的别名,我采用的是数据库名作为别名,这样方便注册和使用。但是,默认的是数据库只能是default,这个有点耍流氓了。但是,不影响我们封装起来,只是一个判断的问题。后续的使用也方便,只需要把o, err = utils.GetOrm(strEnterprise)替换掉o := orm.NewOrm()就可以了直接使用了。至于池的概念,那就是使用框架自身的,在函数InitBeeGoOrm里面就有设置。空闲数和连接数,依然按照之前的方式来调试设置。

本作品采用《CC 协议》,转载必须注明作者和本文链接
生命有限,随心而活,写代码不香吗?
棋布
讨论数量: 0
(= ̄ω ̄=)··· 暂无内容!

讨论应以学习和精进为目的。请勿发布不友善或者负能量的内容,与人为善,比聪明更重要!