Beego Controllercontroller 逻辑控制器介绍Controller中数据参数处理获取参数
Beego Controllercontroller 逻辑控制器介绍Controller中数据参数处理获取参数
controller 逻辑
controller就是处理具体的逻辑的，router将请求分发到指定的controlller，controller处理请求，然后返回。 首先我们还是从源码分析入手：
package controllers
import (
"github.com/astaxie/beego"
)
type MainController struct {
beego.Controller
}
func (this *MainController) Get() {
this.Data["Website"] = "beego.me"
this.Data["Email"] = "astaxie@gmail.com"
this.TplName = "index.tpl"
}上面的代码显示首先我们声明了一个控制器 MainController，这个控制器里面内嵌了 beego.Controller，这就是 Go 的嵌入方式，也就是 MainController 自动拥有了所有 beego.Controller 的方法。
而 beego.Controller 拥有很多方法，其中包括 Init、Prepare、Post、Get、Delete、Head 等方法。我们可以通过重写的方式来实现这些方法，而我们上面的代码就是重写了 Get 方法。
beego 是一个 RESTful 的框架，请求默认是执行对应 req.Method 的方法。例如浏览器的是 GET 请求，那么默认就会执行 MainController 下的 Get 方法。这样上面的 Get 方法就会被执行到，就进入了具体的逻辑处理。
里面的代码是需要执行的逻辑，这里只是简单的输出数据，我们可以通过各种方式获取数据，然后赋值到 this.Data 中，这是一个用来存储输出数据的 map，可以赋值任意类型的值，这里我们只是简单举例输出两个字符串。
最后一个就是需要去渲染的模板，this.TplName 就是需要渲染的模板，这里指定了 index.tpl，如果用户不设置该参数，那么默认会去到模板目录的 Controller/<方法名>.tpl 查找，例如上面的方法会去 maincontroller/get.tpl (文件、文件夹必须小写)。
用户设置了模板之后系统会自动的调用 Render 函数（这个函数是在 beego.Controller 中实现的），所以无需用户自己来调用渲染。
当然也可以不使用模版，直接用 this.Ctx.WriteString 输出字符串，如：
func (this *MainController) Get() {
this.Ctx.WriteString("hello")
}下面详细介绍controller:
控制器介绍
基于 beego 的 Controller 设计，只需要匿名组合 beego.Controller 就可以了，如下所示：
type xxxController struct {
beego.Controller
}我们来看一下beego.Controller的源码
type Controller struct {
// context data
Ctx *context.Context
Data map[interface{}]interface{}
// route controller info
controllerName string
actionName string
methodMapping map[string]func() //method:routertree
gotofunc string
AppController interface{}
// template data
TplName string
ViewPath string
Layout string
LayoutSections map[string]string // the key is the section name and the value is the template name
TplPrefix string
TplExt string
EnableRender bool
// xsrf data
_xsrfToken string
XSRFExpire int
EnableXSRF bool
// session
CruSession session.Store
}
// ControllerInterface is an interface to uniform all controller handler.
type ControllerInterface interface {
Init(ct *context.Context, controllerName, actionName string, app interface{})
Prepare()
Get()
Post()
Delete()
Put()
Head()
Patch()
Options()
Finish()
Render() error
XSRFToken() string
CheckXSRFCookie() bool
HandlerFunc(fn string) bool
URLMapping()
}beego.Controller 实现了接口 beego.ControllerInterface，beego.ControllerInterface 定义了如下函数：
- Init(ct *context.Context, childName string, app interface{}) 这个函数主要初始化了 Context、相应的 Controller 名称，模板名，初始化模板参数的容器 Data，app 即为当前执行的 Controller 的 reflecttype，这个 app 可以用来执行子类的方法。
- Prepare() 这个函数主要是为了用户扩展用的，这个函数会在下面定义的这些 Method 方法之前执行，用户可以重写这个函数实现类似用户验证之类。
- Get() 如果用户请求的 HTTP Method 是 GET，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Get 请求。
- Post() 如果用户请求的 HTTP Method 是 POST，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Post 请求。
- Delete() 如果用户请求的 HTTP Method 是 DELETE，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Delete 请求。
- Put() 如果用户请求的 HTTP Method 是 PUT，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Put 请求.
- Head() 如果用户请求的 HTTP Method 是 HEAD，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Head 请求。
- Patch() 如果用户请求的 HTTP Method 是 PATCH，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Patch 请求.
- Options() 如果用户请求的HTTP Method是OPTIONS，那么就执行该函数，默认是 405，用户继承的子 struct 中可以实现了该方法以处理 Options 请求。
- Finish() 这个函数是在执行完相应的 HTTP Method 方法之后执行的，默认是空，用户可以在子 struct 中重写这个函数，执行例如数据库关闭，清理数据之类的工作。
- Render() error 这个函数主要用来实现渲染模板，如果 beego.AutoRender 为 true 的情况下才会执行。
所以通过子 struct 的方法重写，用户就可以实现自己的逻辑，接下来我们看一个实际的例子：
type AddController struct {
beego.Controller
}
func (this *AddController) Prepare() {
}
func (this *AddController) Get() {
this.Data["content"] = "value"
this.Layout = "admin/layout.html"
this.TplName = "admin/add.tpl"
}
func (this *AddController) Post() {
pkgname := this.GetString("pkgname")
content := this.GetString("content")
pk := models.GetCruPkg(pkgname)
if pk.Id == 0 {
var pp models.PkgEntity
pp.Pid = 0
pp.Pathname = pkgname
pp.Intro = pkgname
models.InsertPkg(pp)
pk = models.GetCruPkg(pkgname)
}
var at models.Article
at.Pkgid = pk.Id
at.Content = content
models.InsertArticle(at)
this.Ctx.Redirect(302, "/admin/index")
}从上面的例子可以看出来，通过重写方法可以实现对应 method 的逻辑，实现 RESTful 结构的逻辑处理。
Controller中数据参数处理
获取参数
我们经常需要获取用户传递的数据，包括 Get、POST 等方式的请求，beego 里面会自动解析这些数据，你可以通过如下方式获取数据：
- GetString(key string) string
- GetStrings(key string) []string
- GetInt(key string) (int64, error)
- GetBool(key string) (bool, error)
- GetFloat(key string) (float64, error)
使用例子如下：
func (c *InputController) Get() {
id := c.GetString("id")
//c.GetStrings() 数组
//c.Input().Get()
c.Ctx.WriteString("id:" + id)
}如果你需要的数据可能是其他类型的，例如是 int 类型而不是 int64，那么你需要这样处理：
func (this *MainController) Post() {
id := this.Input().Get("id")
intid, err := strconv.Atoi(id)
}更多其他的 request 的信息，用户可以通过 this.Ctx.Request 获取信息，关于该对象的属性和方法参考手册 Request。
直接解析到 struct
如果要把表单里的内容赋值到一个 struct 里，除了用上面的方法一个一个获取再赋值外，beego 提供了通过另外一个更便捷的方式，就是通过 struct 的字段名或 tag 与表单字段对应直接解析到 struct。
定义 struct：
type User struct {
Username string
Password string
}表单：
func (c *InputController) Get() {
name := c.GetSession("name")
if name != "" {}
c.Ctx.WriteString(`<html><form action="http://127.0.0.1:8080/input" method="post">
<input type="text" name="Username"/>
<input type="password" name="Password"/>
<input type="submit" value="提交"/>
</form></html>`)
}Controller 里解析：
func (c *InputController) Post() {
u := User{}
if err := c.ParseForm(&u); err != nil {
}
c.Ctx.WriteString("Username:" + u.Username + "password:" + u.Password)
}注意：
- StructTag form 的定义和 renderform方法 共用一个标签
- 定义 struct 时，字段名后如果有 form 这个 tag，则会以把 form 表单里的 name 和 tag 的名称一样的字段赋值给这个字段，否则就会把 form 表单里与字段名一样的表单内容赋值给这个字段。如上面例子中，会把表单中的 username 和 age 分别赋值给 user 里的 Name 和 Age 字段，而 Email 里的内容则会赋给 Email 这个字段。
- 调用 Controller ParseForm 这个方法的时候，传入的参数必须为一个 struct 的指针，否则对 struct 的赋值不会成功并返回
xx must be a struct pointer的错误。 - 如果要忽略一个字段，有两种办法，一是：字段名小写开头，二是：
form标签的值设置为-
获取 Request Body 里的内容
在 API 的开发中，我们经常会用到 JSON 或 XML 来作为数据交互的格式，如何在 beego 中获取 Request Body 里的 JSON 或 XML 的数据呢？
- 在配置文件里设置
copyrequestbody = true - 在 Controller 中
func (this *ObjectController) Post() {
var ob models.Object
var err error
if err = json.Unmarshal(this.Ctx.Input.RequestBody, &ob); err == nil {
objectid := models.AddOne(ob)
this.Data["json"] = "{\"ObjectId\":\"" + objectid + "\"}"
} else {
this.Data["json"] = err.Error()
}
this.ServeJSON()
}文件上传
在 beego 中你可以很容易的处理文件上传，就是别忘记在你的 form 表单中增加这个属性 enctype="multipart/form-data"，否则你的浏览器不会传输你的上传文件。
文件上传之后一般是放在系统的内存里面，如果文件的 size 大于设置的缓存内存大小，那么就放在临时文件中，默认的缓存内存是 64M，你可以通过如下来调整这个缓存内存大小:
beego.MaxMemory = 1<<22或者在配置文件中通过如下设置：
maxmemory = 1<<22Beego 提供了两个很方便的方法来处理文件上传：
- GetFile(key string) (multipart.File, *multipart.FileHeader, error)
该方法主要用于用户读取表单中的文件名
the_file，然后返回相应的信息，用户根据这些变量来处理文件上传：过滤、保存文件等。 - SaveToFile(fromfile, tofile string) error 该方法是在 GetFile 的基础上实现了快速保存的功能 fromfile 是提交时候的 html 表单中的 name
<form enctype="multipart/form-data" method="post">
<input type="file" name="uploadname" />
<input type="submit">
</form>保存的代码例子如下：
func (c *FormController) Post() {
f, h, err := c.GetFile("uploadname")
if err != nil {
log.Fatal("getfile err ", err)
}
defer f.Close()
c.SaveToFile("uploadname", "static/upload/" + h.Filename) // 保存位置在 static/upload, 没有文件夹要先创建
}数据绑定
支持从用户请求中直接数据 bind 到指定的对象,例如请求地址如下
?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=astaxie
var id int
this.Ctx.Input.Bind(&id, "id") //id ==123
var isok bool
this.Ctx.Input.Bind(&isok, "isok") //isok ==true
var ft float64
this.Ctx.Input.Bind(&ft, "ft") //ft ==1.2
ol := make([]int, 0, 2)
this.Ctx.Input.Bind(&ol, "ol") //ol ==[1 2]
ul := make([]string, 0, 2)
this.Ctx.Input.Bind(&ul, "ul") //ul ==[str array]
user struct{Name}
this.Ctx.Input.Bind(&user, "user") //user =={Name:"astaxie"}