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里面就有设置。空闲数和连接数，依然按照之前的方式来调试设置。