今天主要来简单学习一下beego，一个比较流行的go框架。前段时间学习了go语言的基础，対go算是有了一个简单了解，但是实际开发中肯定会少不了各种框架得使用，所以我这次选择了一个比较流行得框架——beego，来做为go语言框架入门，beego官网。这里简单先说一下自己得感觉，首先beego是一个一体式的框架，也就是说，它包含了所有项目中常用的所有模块，不像java，不同得部分可能需要不同得框架（当然spring boot现在也能算是一个一体式）。
今天主要学习得就是beego得MVC架构，它主要包括三个部分：model、controller、view。记得当时学习go和数据库交互的时候就说过，go自己和数据库交互其实感觉不太方便，今天看看beego的ORM是不是会带来惊喜。开始学习和写代码之前，先做好准备工作，即安装beego和bee工具，安装过程很简单，这里就不再叙述了，然后创建一个beego项目，项目结构如下图：
项目结构.png
根据项目结构就可以很直观的得看出来这是一个典型的MVC架构，main函数是整个应用得入口，routers主要是进行路由注册，即将用户请求得URL和相应得controller进行映射，models下面主要是beego得ORM模块，另外数据模型，即所谓得struct我也是放在这个目录下的。controller这个都比较熟悉了，就不说了。conf下主要是项目配置文件。static下面是项目得静态文件。views下面是项目得模板，当然我使用的还是html，没有使用模板。
开始之前还是先了解下项目得执行过程，下面这张图就是从beego官网上，关于go的执行过程，这张图非常直观的，main函数执行前会先完成它引入包的init函数，依次类推。最终等main函数自己得init函数执行完之后再执行main函数，当然也不是必须通过init方法，也可以自己定义一个方法，然后显性的调用也是可以的。
go执行过程.png
一、项目配置
beego目前也是支持多种格式的配置文件，比如xml、yml、json等，但是但是默认采用了 INI 格式解析。另外就是可以支持多个配置文件引入，比如这个项目我将数据库相关的配置单独的作为一个配置文件，然后默认配置文件中引入数据库配置文件就行了，比如:
appname=helloGo
httpport=9090
runmode=dev
# 视图的路径
# viewspath="views/user"
viewspath="views"
# 引入的其他配置文件
include "database.conf"
# 接收json参数
copyrequestbody=true
有一点不太方便的就是没有提示，不像spring boot可以提示，这个的话只能自己去查看常用的配置文档，当然也可以通过代码的方式指定相关的配置，选择代码还是配置文件就看自己的喜好或者习惯了。另外还可以指定不同运行环境下的配置，比如测试
二、路由映射
首先说一下就是beego项目的启动我感觉和spring boot项目启动非常的类似，main函数里面实际调用的是app的Run方法，这里先不往下深究了，暂时知道就可以了。首先我在main函数引入router这个包，这个包上面说了主要是路由的映射，即将用户请求的URL和相应的controller进行映射。根据go执行的过程图可以知道它会一级一级的把需要的所有包的init函数都执行一遍，或者用spring的思想就是会完成所有依赖的注入（不知道这么理解有没有问题，但是我觉得思路应该都是相通的）。所以可以在router的init函数里面完成URL和controller的映射，代码如下：
func init() {
/*固定路由*/
beego.Router("/", &controllers.MainController{})
beego.Router("/user",&controllers.UserController{})
beego.BConfig.EnableGzip = true
beego.BConfig.RouterCaseSensitive = true
beego.BConfig.MaxMemory = 1 << 26
beego.BConfig.WebConfig.AutoRender = true
beego.BConfig.CopyRequestBody = true
/*设置模板取值方式*/
//beego.BConfig.WebConfig.TemplateLeft = "${"
//beego.BConfig.WebConfig.TemplateRight = "}"
/*页面文件路径*/
//beego.BConfig.WebConfig.ViewsPath="views/user"
/*注解路由*/
beego.Include(&controllers.UserController{})
beego.Include(&controllers.CommonController{})
beego.Include(&controllers.FileController{})
beego.Include(&controllers.LoginController{})
/*同时注册多个路由*/
beego.Include(&controllers.UserController{},&controllers.CommonController{},&controllers.FileController{})
//beego.ErrorController(&controllers.ErrorController{})
}
init函数里面有固定路由即每一个固定的URL都会对应一个controller或者通过正则路由，即满足一定格式的URL对应一个controller，因为我已经习惯了spring注解的方式，所以我比较喜欢的还是注解形式的路由方式。注解路由通过一个调用beego的Include函数将一个或者多个handler注册到应用中。另外beego也支持restful形式的路由，有兴趣的可以看下官方文档。另外就是init函数里面有一些设置，这些设置都是可以写到配置文件内的，这个我觉得不用特别的在意，还是看个人习惯。
注册好路由后还需要的就是将URL和对应的handler进行映射，所以每个controller都有一个URLMapping方法，代码如下：
type UserController struct {
beego.Controller
}
//配置注解路由
func (u *UserController) URLMapping() {
u.Mapping("QueryById",u.QueryById)
u.Mapping("QueryList",u.QueryList)
u.Mapping("Register",u.Register)
u.Mapping("SaveUser",u.SaveUser)
u.Mapping("UserJSON",u.UserJSON)
}
在beego项目中每一个controller结构都包含了一个beego.Controller，可以理解为自定义的controller继承了beego.Controller，而beego.Controller封装了很多我们所需要的信息，看下它的结构就明白了，建议还是看下源码。
其实这个方法主要就是将方法名称和对应的方法或者所谓的handler进行映射，而真正的路由是在相应的方法或者handler上的。比较熟悉springMVC应该都知道，在进行URL映射的时候，通常我们会在类上使用一个@requestMapping注解，然后方法上也会加上相应的@requestMapping，二者拼接在一起就完成整个的URL。beego的稍微有点区别，而且注解的形式也不太一样，下面就贴一个根据id查找用户的handler，这个URL上会附上请求的参数值，看下下面的代码：
// @router /user/get/:id [get]
func (u *UserController) QueryById() {
strId := u.Ctx.Input.Param(":id")
logs.Info(">>>> query user by userId start <<<<")
id,err := strconv.Atoi(strId)
user := models.QueryUserById(id)
checkError(err)
u.Data["User"] = user
bytes,err := json.Marshal(user)
u.Ctx.ResponseWriter.Write(bytes)
//u.TplName = "user/user.html"
}
// @router /user/get/:id [get]就是一个完整的注解路由，请求的URL是/user/get/:id，请求类型是GET请求。和springMVC确实不太一样，相对来讲beego的要更简洁一点（go语言相比java就简洁不少），但是go语言并不支持注解，这种路由形式准确的说应该叫注释，但是实际的作用确实和java的注解效果是相同的。当然我个人还是很喜欢使用这种方式的，虽然和springMVC不太一样，但是相差并不大，还是很好理解的。只要明白了用户请求、路由、映射、处理器等之间的关系，基本就没问题了，无非是具体怎么实现的问题。关于其他形式的路由方式这里就不过多介绍了，不过还是应该了解一下，毕竟具体使用哪种并不是自己能决定的。
三、models设计
这部分我主要说一下beego的ORM部分，前面学习go的时候没有使用任何的ORM框架，所有对数据库的CRUD都需要自己手写SQL，然后对结果进行处理，非常的不方便。
models可以像routers一样，在main函数引入models的包，然后在其init函数获取数据连接等等，但是自己定义一个函数，然后在项目的main函数，显性调用。像这样：
func main() {
// 数据库初始化
models.Init()
// 过滤器
//beego.InsertFilter("/*",beego.BeforeExec,controllers.UserFilter)
// 错误handler
beego.ErrorController(&controllers.ErrorController{})
beego.Run()
}
这里我自己定义了一个Init函数，并在main函数里面调用，当然也可以自己重写main的init函数，并在init函数内完调用（我觉得应该是可以的，但是按理放到init函数内更好）。接下来看看在models的Init函数内做了什么
func Init() {
logs.Info(">>>> database init start <<<<")
// 数据库驱动
orm.RegisterDriver("postgres",orm.DRPostgres)
// 注册数据库
username := beego.AppConfig.String("username")
password := beego.AppConfig.String("password")
url := beego.AppConfig.String("url")
dbname := beego.AppConfig.String("dbname")
datasource := "postgres://" + username + ":" + password + "@" + url + "/" + dbname + "?sslmode=disable"
orm.RegisterDataBase("default","postgres",datasource)
// 最大连接和空闲连接
orm.SetMaxOpenConns("default",30)
orm.SetMaxIdleConns("default",10)
// 注册model
orm.RegisterModel(new(User))
}
首先是注册数据库驱动，我使用的依然是postgresql，此外beego的ORM还支持mysql、oracle、sqlite和TiDB。应该说对关系型数据库这方面的支持稍微差了一点，比如就没有sql server。其次就是注册数据库，beego的ORM必须注册一个默认名称为default的数据库。数据源所需参数如：数据库名称、密码以及URL等信息都是写在数据库配置文件内的，而获取配置文件的配置参数，是通过使用 beego.AppConfig加参数类型，如string bool int float等来获取。然后就是配置数据库连接池，最大连接、最大空闲连接等。最后注册model，当然是可以注册多个数据模型的，这一步我觉得其实还是很重要的，我的感觉就是将数据库表和对应的结构做一个映射关系，可以根据定义的结构创建数据库表，以及表与表之间的关联关系（什么一对一、一对多等等），另外如果要使用orm.QuerySeter 进行高级查询的话，这一步是必须的。感觉有点像hibernate，我自己是不太喜欢这种方式，当然这种难度感觉也会高一些，因为hibernate当时学的就挺晕的。下面这些代码是官方文档定义结构的一些例子：
type User struct {
Id int
Name string
Profile *Profile `orm:"rel(one)"` // OneToOne relation
Post []*Post `orm:"reverse(many)"` // 设置一对多的反向关系
}
type Profile struct {
Id int
Age int16
User *User `orm:"reverse(one)"` // 设置一对一反向关系(可选)
}
type Post struct {
Id int
Title string
User *User `orm:"rel(fk)"` //设置一对多关系
Tags []*Tag `orm:"rel(m2m)"`
}
type Tag struct {
Id int
Name string
Posts []*Post `orm:"reverse(many)"`
}
当然上面只是一部分，此外还可以设置主键、自增长等等，这里说一下 orm:"reverse(one)"这种表达方式，我看到网上有人把这种形式称为go的注解，我也不知道对或者不对，知道它是一种表达形式即可，除了orm之外我知道的还有form和json，这两个下面会说到，关于orm其实心里挺排斥的，感觉有点复杂了，但是我觉得还是很有必要了解一下的。总的来说beego的ORM功能上确实十分强大，支持的查询方式也很多，比如对象的CRUD，还有高级查询、原生的SQL查询还有构造查询。具体怎么使用就看自己了，当然我还是更喜欢自己来写SQL，但是还是要看具体场景。这次学习项目中会用到对象的CRUD也会使用到高级查询。这部分内容其实比较多，我自己并没有怎么去学习，可能还是受mybatis的影响吧，感觉自己写sql更方便，但是我觉得这部分还是应该多了解一下的。
关于views也即视图模板这部分，自己感觉会使用就好，和其他视图模板应该只是语法上的差别，而且现在基本都是前后端分离的开发模式，后端提供接口就好，但是掌握这部分也不算多，这部分就略过了。
四、项目
1、数据模型定义
接下来就是项目的开发，我还是从最简单的开始，什么登录、注册、查询之类，一是这些相对最简单适合入门，二是这次的内容还是蛮多的，只是自己选择性的忽略了一些。项目还是单库单表（ORM是支持多个数据库的），先从设计结构，即数据模型开始，这里会用到form和json这两种形式的注解（网上有人是这么叫的），看下面的代码：
type User struct {
Id int `form:"-" table:"user" json:"id"`
UserName string `form:"username" column:"username" json:"userName"`
Age int `form:"age" json:"age"`
Sex string `form:"sex" json:"sex"`
Mobile string `form:"mobile" json:"mobile"`
Password string `json:"password"`
Email string `form:"email" json:"email"`
}
form表示的是使用这个结构体接受前端form表单时对应的名称，"-"表示忽略这一项的值；table表示的这个结构体对应的数据库表的名称；column表示的是这个属性在数据库表中对应列的名称；json表示的是将这个结构体或者对象转成json对象后对应的key的名称，因为结构体里面如果属性对外可见，那么属性名称首字母必须大写，这样转成json后key的首字母也是大写，所以为了美观需要转换一下，当然换个key的名称也是可以。
然后再定义一个作为json响应结果的结构体。我建议是将数据库中有对应表的数据模型都进行注册，数据模型最好单独新建go文件，并在其init函数进行注册，因为我就一个数据模型，所以我放到models的Init函数中了。
2、编写相关handler
这个controller无非就是一些跳转页面、注册登陆之类的逻辑，以及数据库的CRUD，代码如下：
type LoginController struct {
beego.Controller
}
func (c *LoginController) URLMapping() {
c.Mapping("/login",c.Login)
c.Mapping("/register",c.Register)
c.Mapping("/register/do",c.DoRegister)
c.Mapping("/login/do",c.DoLogin)
}
// @router /login [get]
func (c *LoginController) Login() {
logs.Info(">>>> forward to login page start <<<<")
c.TplName = "login.html"
}
// @router /register [get]
func (c *LoginController) Register() {
logs.Info(">>>> forward to Register page start <<<<")
c.TplName = "register.html"
}
// @router /register/do [post]
func (c *LoginController) DoRegister() {
var user models.User
var result models.Result
err := json.Unmarshal(c.Ctx.Input.RequestBody,&user)
checkError(err)
userName := user.UserName
password := user.Password
email := user.Email
logs.Info(">>>> user register information username=" + userName + ",email=" + email + ",password=" + password + " <<<<")
pass,err := regexp.MatchString(`[a-zA-Z0-9]{8,16}`,password)
checkError(err)
if !pass {
result.Code = 404
result.Success = false
result.Message = "密码格式错误"
}
em,err := regexp.MatchString(`^[a-zA-Z0-9_-]+@[a-zA-Z0-9_-]+(\.[a-zA-Z0-9_-]+)+$`,email)
checkError(err)
if !em {
result.Code = 404
result.Success = false
result.Message = "邮箱格式错误"
}
// 对密码加密
user.Password = passwordEncode(password)
id,e := orm.NewOrm().Insert(&user)
if e != nil {
result.Code = 404
result.Success = false
result.Message = "系统异常"
logs.Error(e)
} else {
logs.Info(">>>> user register success,user id = " + strconv.FormatInt(id,10) + " <<<<")
result.Code = 200
result.Success = true
result.Message = "注册成功"
}
bytes,err := json.Marshal(&result)
c.Ctx.ResponseWriter.Write(bytes)
}
func passwordEncode(password string) string {
h := md5.New()
h.Write([]byte(password))
return hex.EncodeToString(h.Sum(nil))
}
// @router /login/do [post]
func (c *LoginController) DoLogin() {
logs.Info(">>>> user do login start <<<<")
var user models.User
// 表单映射成struct
err := json.Unmarshal(c.Ctx.Input.RequestBody,&user)
logs.Error(err)
user.Password = passwordEncode(user.Password)
right := models.QueryByNamePwd(user.UserName,user.Password)
var r models.Result
if right {
// 用户名和密码正确
r.Code = 200
r.Success = true
r.Message = "success"
} else {
r.Code = 404
r.Success = false
r.Message = "用户或密码错误"
}
bytes,err := json.Marshal(&r)
c.Ctx.ResponseWriter.Write(bytes)
}
另一个用户操作相关的controller
type UserController struct {
beego.Controller
}
//配置注解路由
func (u *UserController) URLMapping() {
u.Mapping("QueryById",u.QueryById)
u.Mapping("QueryList",u.QueryList)
u.Mapping("Register",u.Register)
u.Mapping("SaveUser",u.SaveUser)
u.Mapping("UserJSON",u.UserJSON)
}
// @router /user [get]
func (c *UserController) Register() {
logs.Info(">>>> forward to register page start <<<<")
c.TplName = "user/form.html"
}
// @router /user/get/:id [get]
func (u *UserController) QueryById() {
strId := u.Ctx.Input.Param(":id")
logs.Info(">>>> query user by userId start <<<<")
id,err := strconv.Atoi(strId)
user := models.QueryUserById(id)
checkError(err)
u.Data["User"] = user
bytes,err := json.Marshal(user)
u.Ctx.ResponseWriter.Write(bytes)
//u.TplName = "user/user.html"
}
// @router /user/list [get]
func (u *UserController) QueryList() {
logs.Info(">>>> query user list start <<<<")
// 数据库查询所有用户
users := models.QueryUserList()
//bytes,err := json.Marshal(users)
//checkError(err)
//u.Ctx.ResponseWriter.Write(bytes)
u.Data["List"] = users
u.TplName = "user/list.html"
}
// @router /user/save [post]
func (u *UserController) SaveUser() {
logs.Info(">>>> save register information start <<<<")
// 获取表单数据
//form := u.Ctx.Request.PostForm
//username := form.Get("username")
//age := form.Get("age")
//sex := form.Get("sex")
//mobile := form.Get("mobile")
// 表单转struct
var user models.User
err := u.ParseForm(&user)
checkError(err)
// 校验...
// 写入数据库，返回id值
id := models.InsertUser(&user)
println(id)
//var r orm.RawSeter
//insert := "insert into t_user (username,age,sex,mobile) values(?,?,?,?)"
//r = o.Raw(insert,username,age,sex,mobile)
//_,err := r.Exec()
//checkError(err)
u.Ctx.Redirect(302,"/success")
}
/*接收requestBody参数*/
// @router /json/save [post]
func (u *UserController) UserJSON() {
logs.Info(">>>> save user json information start <<<<")
// requestBody数据
var user models.User
err := json.Unmarshal(u.Ctx.Input.RequestBody,&user)
checkError(err)
// 数据库处理
id := models.InsertUser(&user)
println("insert user id=" + strconv.FormatInt(id,10))
u.Ctx.Redirect(302,"/success")
}
func checkError(e error) {
if e != nil {
log.Fatal(e)
}
}
这个controller有些地方可能实现方式略有不同，还有一点就是这个controller里面对数据库是我在models里面写的，使用的是ORM的高级查询，代码如下：
func QueryUserById(id int) *User {
var user User
orm := orm.NewOrm()
orm.QueryTable("user").Filter("id",id).One(&user,"username","age","sex","mobile")
logs.Info(">>>> query user by user id from database <<<<")
return &user
}
func QueryUserList() []*User {
var list []*User
orm := orm.NewOrm()
orm.QueryTable("user").All(&list,"username","age","sex","mobile")
return list
}
func InsertUser(u *User) int64 {
o := orm.NewOrm()
id,err := o.Insert(u)
if err!= nil {
log.Fatal(err)
}
return id
}
func QueryByNamePwd(username, password string) bool {
var user User
orm := orm.NewOrm()
err := orm.QueryTable("user").Filter("username",username).Filter("password",password).One(&user,"username","age","sex","mobile","email")
logs.Info(">>>> query user by user id from database <<<<")
var result bool
if err!=nil {
logs.Error(err)
result = false
} else {
result = true
}
return result
}
orm.QueryTable("user").Filter("id",id)....
第一个参数表示查询表的名称，filter是过滤条件，可以看成是SQL中的where条件，里面的参数就是对应的列名和值，One表示只有一个结果，All表示所有，里面一个是struct结构体接受查询的值，而后面的"username","age","sex","mobile"表示查询的列。我自己的感觉是简单的查询还好，复杂的话我宁愿写SQL。当然它的功能不止这些，还有一些模糊的查询比如startwith、contains等等，可以参考文档。另外还有构造查询感觉和写SQL没什么却别了，也可以了解一下。
另外就是错误处理器，beego 默认支持 401、403、404、500、503 这几种错误的处理。一般我们都会自定义错误的处理页面，我在main函数注册了一个处理错误的controller，但是只自定义了404和500两种
type ErrorController struct {
beego.Controller
}
func (c *ErrorController) URLMapping() {
c.Mapping("Error404",c.Error404)
c.Mapping("Error500",c.Error500)
}
func (c *ErrorController) Error404() {
logs.Info(">>>> forward to 404 error page <<<<")
c.Data["Content"] = "抱歉，查找的内容不存在"
c.TplName = "error/404.html"
}
func (c *ErrorController) Error500() {
logs.Info(">>>> forward to 500 error page <<<<")
c.Data["Content"] = "抱歉，系统错误，努力解决中"
c.TplName = "error/500.html"
}
这个里面方法名称好像是不可以变的，自己后面有时间再测试一下吧，另外就是自己其实在main函数还定义了一个过滤器，但是时间关系，自己还没有认真的去看，感觉和springMVC的拦截器有相似之处，都有在路由之前还是之后处理的逻辑，关于这部分内容下次再继续的研究吧！beego模块确实比较多，功能上看非常的全，而且还有缓存、日志等模块，使用beego可以说能解决项目中所需要的大部分问题，所以我说它是一个体式的框架，功能全而且强大。
这次项目的代码已经上传到我的github，最近自己也有使用beego做一个个人小网站的想法。关于文章中有什么疑问或者错误之处希望大家批评指正，谢谢！2018年的最后一天完成2018年的最后一篇文章，感觉还是有点感慨。祝大家2019实现所有的flag.........祝大家新年快乐！！
最后：自己在微信开了一个个人号：
超超学堂，都是自己之前写过的一些文章，另外关注还有Java免费自学资料，欢迎大家关注。
二维码.jpg
网友评论