beego的控制器Controller篇 — 数据处理

1 请求数据处理

1.1 获取参数

通过如下方式获取数据：

• GetString(key string) string
• GetStrings(key string) []string
• GetInt(key string) (int64, error)
• GetBool(key string) (bool, error)
• GetFloat(key string) (float64, error)

例如：

func (this *MainController) Post() {
    jsoninfo := this.GetString("jsoninfo")
    if jsoninfo == "" {
        this.Ctx.WriteString("jsoninfo is empty")
        return
    }
}

如果需要的数据是其他类型的，例如是 int 类型而不是 int64，那么你需要这样处理：

func (this *MainController) Post() {
    id := this.Input().Get("id")
    intid, err := strconv.Atoi(id)
}

1.2?获取表单中的内容到struct

把表单里的内容赋值到一个 struct 里

定义 struct：

type user struct {
    Id    int         `form:"-"`
    Name  interface{} `form:"username"`
    Age   int         `form:"age"`
    Email string
}

表单：

<form id="user">
    名字：<input name="username" type="text" />
    年龄：<input name="age" type="text" />
    邮箱：<input name="Email" type="text" />
    <input type="submit" value="提交" />
</form>

Controller 里解析：

func (this *MainController) Post() {
    u := user{}
    if err := this.ParseForm(&u); err != nil {
        //handle error
    }
}

如果通过form:"username"这种方式指定，则按照指定的key值对应字段，否则，按照Email这类型的字段名

1.3 获取 Request Body 里的内容

如何在 beego 中获取 Request Body 里的 JSON 或 XML 的数据呢？

1. 在配置文件里设置?copyrequestbody = true
2. 在 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()
}

1.4?文件上传

在?form 表单中增加这个属性?enctype="multipart/form-data"

文件上传之后一般是放在系统的内存里面，如果文件的 size 大于设置的缓存内存大小，那么就放在临时文件中，默认的缓存内存是 64M，你可以通过如下来调整这个缓存内存大小:

beego.MaxMemory = 1<<22

或者在配置文件中通过如下设置：

maxmemory = 1<<22

Beego 提供了两个很方便的方法来处理文件上传：

• 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, 没有文件夹要先创建
}

1.5?数据绑定

支持从用户请求中直接数据 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"}

2 多种格式响应数据输出

beego 提供了JSON、XML、JSONP的方式直接输出。

JSON 数据直接输出：

func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["json"] = &mystruct
      this.ServeJSON()
  }

调用 ServeJSON 之后，会设置 content-type 为 application/json，然后同时把数据进行 JSON 序列化输出。

XML 数据直接输出：

 func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["xml"]=&mystruct
      this.ServeXML()
  }

调用 ServeXML 之后，会设置 content-type 为 application/xml，同时数据会进行 XML 序列化输出。

jsonp 调用

 func (this *AddController) Get() {
      mystruct := { ... }
      this.Data["jsonp"] = &mystruct
      this.ServeJSONP()
  }

调用 ServeJSONP 之后，会设置 content-type 为 application/javascript，然后同时把数据进行 JSON 序列化，然后根据请求的 callback 参数设置 jsonp 输出。

注意：开发模式下序列化后输出的是格式化易阅读的 JSON 或 XML 字符串；在生产模式下序列化后输出的是压缩的字符串。

3?表单数据验证

3.1?安装及测试

安装：

go get github.com/astaxie/beego/validation

测试：

go test github.com/astaxie/beego/validation

3.2 使用实例

直接使用：

import (
    "github.com/astaxie/beego/validation"
    "log"
)

type User struct {
    Name string
    Age int
}

func main() {
    u := User{"man", 40}
    valid := validation.Validation{}
    valid.Required(u.Name, "name")
    valid.MaxSize(u.Name, 15, "nameMax")
    valid.Range(u.Age, 0, 18, "age")

    if valid.HasErrors() {
        // 如果有错误信息，证明验证没通过
        // 打印错误信息
        for _, err := range valid.Errors {
            log.Println(err.Key, err.Message)
        }
    }
    // or use like this
    if v := valid.Max(u.Age, 140, "age"); !v.Ok {
        log.Println(v.Error.Key, v.Error.Message)
    }
    // 定制错误信息
    minAge := 18
    valid.Min(u.Age, minAge, "age").Message("少儿不宜！")
    // 错误信息格式化
    valid.Min(u.Age, minAge, "age").Message("%d不禁", minAge)
}

通过 StructTag 使用示例：

import (
    "log"
    "strings"

    "github.com/astaxie/beego/validation"
)

// 验证函数写在 "valid" tag 的标签里
// 各个函数之间用分号 ";" 分隔，分号后面可以有空格
// 参数用括号 "()" 括起来，多个参数之间用逗号 "," 分开，逗号后面可以有空格
// 正则函数(Match)的匹配模式用两斜杠 "/" 括起来
// 各个函数的结果的 key 值为字段名.验证函数名
type user struct {
    Id     int
    Name   string `valid:"Required;Match(/^Bee.*/)"` // Name 不能为空并且以 Bee 开头
    Age    int    `valid:"Range(1, 140)"` // 1 <= Age <= 140，超出此范围即为不合法
    Email  string `valid:"Email; MaxSize(100)"` // Email 字段需要符合邮箱格式，并且最大长度不能大于 100 个字符
    Mobile string `valid:"Mobile"` // Mobile 必须为正确的手机号
    IP     string `valid:"IP"` // IP 必须为一个正确的 IPv4 地址
}

// 如果你的 struct 实现了接口 validation.ValidFormer
// 当 StructTag 中的测试都成功时，将会执行 Valid 函数进行自定义验证
func (u *user) Valid(v *validation.Validation) {
    if strings.Index(u.Name, "admin") != -1 {
        // 通过 SetError 设置 Name 的错误信息，HasErrors 将会返回 true
        v.SetError("Name", "名称里不能含有 admin")
    }
}

func main() {
    valid := validation.Validation{}
    u := user{Name: "Beego", Age: 2, Email: "dev@beego.me"}
    b, err := valid.Valid(&u)
    if err != nil {
        // handle error
    }
    if !b {
        // validation does not pass
        // blabla...
        for _, err := range valid.Errors {
            log.Println(err.Key, err.Message)
        }
    }
}

StructTag 可用的验证函数：

• Required?不为空，即各个类型要求不为其零值
• Min(min int)?最小值，有效类型：int，其他类型都将不能通过验证
• Max(max int)?最大值，有效类型：int，其他类型都将不能通过验证
• Range(min, max int)?数值的范围，有效类型：int，他类型都将不能通过验证
• MinSize(min int)?最小长度，有效类型：string slice，其他类型都将不能通过验证
• MaxSize(max int)?最大长度，有效类型：string slice，其他类型都将不能通过验证
• Length(length int)?指定长度，有效类型：string slice，其他类型都将不能通过验证
• Alpha?alpha字符，有效类型：string，其他类型都将不能通过验证
• Numeric?数字，有效类型：string，其他类型都将不能通过验证
• AlphaNumeric?alpha 字符或数字，有效类型：string，其他类型都将不能通过验证
• Match(pattern string)?正则匹配，有效类型：string，其他类型都将被转成字符串再匹配(fmt.Sprintf("%v", obj).Match)
• AlphaDash?alpha 字符或数字或横杠?-_，有效类型：string，其他类型都将不能通过验证
• Email?邮箱格式，有效类型：string，其他类型都将不能通过验证
• IP?IP 格式，目前只支持 IPv4 格式验证，有效类型：string，其他类型都将不能通过验证
• Base64?base64 编码，有效类型：string，其他类型都将不能通过验证
• Mobile?手机号，有效类型：string，其他类型都将不能通过验证
• Tel?固定电话号，有效类型：string，其他类型都将不能通过验证
• Phone?手机号或固定电话号，有效类型：string，其他类型都将不能通过验证
• ZipCode?邮政编码，有效类型：string，其他类型都将不能通过验证

4 Flash数据

主要用于在两个逻辑间传递临时数据，flash 中存放的所有数据会在紧接着的下一个逻辑中调用后清除。一般用于传递提示和错误消息。它适合 Post/Redirect/Get 模式。下面看使用的例子：

// 显示设置信息
func (c *MainController) Get() {
    flash:=beego.ReadFromRequest(&c.Controller)
    if n,ok:=flash.Data["notice"];ok{
        // 5.1 显示设置成功
        c.TplName = "set_success.html"
    }else if n,ok=flash.Data["error"];ok{
        // 5.2 显示错误
        c.TplName = "set_error.html"
    }else{
        // 1 显示设置信息
        // 不然默认显示设置页面
        c.Data["list"]=GetInfo()
        c.TplName = "setting_list.html"
    }
}
// 2 用户设置信息之后点击递交，执行 Post
// 处理设置信息
func (c *MainController) Post() {
    // 3 初始化一个 flash
    flash:=beego.NewFlash()
    setting:=Settings{}
    valid := Validation{}
    c.ParseForm(&setting)
    //4 验证出错或者验证不通过设置 flash 的错误
    if b, err := valid.Valid(setting);err!=nil {
        flash.Error("Settings invalid!")
        flash.Store(&c.Controller)
        c.Redirect("/setting",302)
        return
    }else if b!=nil{
        flash.Error("validation err!")
        flash.Store(&c.Controller)
        c.Redirect("/setting",302)
        return
    }
    //4.1 如果通过了就保存设置，然后设置 flash 成功设置的信息。
    saveSetting(setting)
    flash.Notice("Settings saved!")
    flash.Store(&c.Controller)
    c.Redirect("/setting",302)
}

上面的代码执行的大概逻辑,上面标注了 。

默认情况下?ReadFromRequest?函数已经实现了读取的数据赋值给 flash，所以在你的模板里面你可以这样读取数据：

{{.flash.error}}
{{.flash.warning}}
{{.flash.notice}}

flash 对象有三个级别的设置：

• Notice 提示信息
• Warning 警告信息
• Error 错误信息

5 URL构建

?UrlFor() 函数就是用于构建指定函数的 URL 的。它把对应控制器和函数名结合的字符串作为第一个参数，其余参数对应 URL 中的变量。未知变量将添加到 URL 中作为查询参数。 例如：

定义了一个相应的控制器

type TestController struct {
    beego.Controller
}

func (this *TestController) Get() {
    this.Data["Username"] = "astaxie"
    this.Ctx.Output.Body([]byte("ok"))
}

func (this *TestController) List() {
    this.Ctx.Output.Body([]byte("i am list"))
}

func (this *TestController) Params() {
    this.Ctx.Output.Body([]byte(this.Ctx.Input.Params()["0"] + this.Ctx.Input.Params()["1"] + this.Ctx.Input.Params()["2"]))
}

func (this *TestController) Myext() {
    this.Ctx.Output.Body([]byte(this.Ctx.Input.Param(":ext")))
}

func (this *TestController) GetUrl() {
    this.Ctx.Output.Body([]byte(this.UrlFor(".Myext")))
}

注册的路由:

beego.Router("/api/list", &TestController{}, "*:List")
beego.Router("/person/:last/:first", &TestController{})
beego.AutoRouter(&TestController{})

那么通过方式可以获取相应的URL地址：

beego.URLFor("TestController.List")
// 输出 /api/list

beego.URLFor("TestController.Get", ":last", "xie", ":first", "asta")
// 输出 /person/xie/asta

beego.URLFor("TestController.Myext")
// 输出 /Test/Myext

beego.URLFor("TestController.GetUrl")
// 输出 /Test/GetUrl

模板中如何使用:

默认情况下，beego 已经注册了 urlfor 函数，用户可以通过如下的代码进行调用

{{urlfor "TestController.List"}}

参考文章：

https://www.huitongban.com/801199.html

https://www.dflian.com/531742.html?action=onClick

https://www.yfmao.com/531799.html