beego框架使用

一，beego简介

1，beego是一个go语言框架，可以用来快速开发API、Web、后端服务等各种应用。
2，beego的安装，包地址即源码github地址，go get命令借助代码管理工具如git通过远程拉取或更新代码包及其依赖包，并自动完成编译和安装。
go get github.com/astaxie/beego
go get github.com/beego/bee
3，文件结构及逻辑
beego在执行逻辑上是一个典型的 MVC 架构：

image.png

二，beego流程及使用

通过使用bee工具的命令可以分别生成web和api两种项目结构

bee new myproject
bee api myapi

入口文件

• 文件名可以随意命名
• 初始化路由配置，监听http请求

路由配置

• 固定式路由 参数：路径，controller地址，函数方法名

package routers

import (
    "myapi/controllers"
    "github.com/astaxie/beego"
)

func init() {
    beego.Router("/", &controllers.MainController{})
    beego.Router("/v1/area/getArea", &controllers.AreaController{}, "post:GetArea")
}

• 正则路由 正则匹配路径及参数

beego.Router(“/api/:id([0-9]+)“, &controllers.RController{})

beego.Router(“/user/:username([\\w]+)“, &controllers.RController{})

• 自动匹配路由

beego.AutoRouter(&controllers.ObjectController{})

/object/login   调用 ObjectController 中的 Login 方法
/object/logout  调用 ObjectController 中的 Logout 方法

• 注解式路由 路由里使用namespace引入文件，函数方法的上方加上router注释
  beego.Include(&CMSController{})

// CMS API
type CMSController struct {
    beego.Controller
}

// @router /staticblock [post]
func (this *CMSController) StaticBlock() {

}

控制器

• 通过type struct结构体引入实现了类似继承的功能

type xxxController struct {
    beego.Controller
}

• beego.Controller 实现了接口 beego.ControllerInterface 定义了如下函数：

Init(ct *context.Context, childName string, app interface{})

这个函数主要初始化了 Context、相应的 Controller 名称，模板名，初始化模板参数的容器 Data 

Prepare() 这个函数主要是为了用户扩展用的，用户可以重写这个函数实现类似用户验证之类。

Get() 如果用户请求的 HTTP Method 是 GET， 处理 Get 请求。

Post() 如果用户请求的 HTTP Method 是 POST， 处理 Post 请求。

Delete() 如果用户请求的 HTTP Method 是 DELETE， 处理 Delete 请求。

Put() 如果用户请求的 HTTP Method 是 PUT，处理 Put 请求.

Head() 如果用户请求的 HTTP Method 是 HEAD， 处理 Head 请求。

Patch() 如果用户请求的 HTTP Method 是 PATCH， 处理 Patch 请求.

Options() 如果用户请求的HTTP Method是OPTIONS， 处理 Options 请求。

Finish() 这个函数是在执行完相应的 HTTP Method 方法之后执行的，默认是空， 执行例如数据库关闭，清理数据之类的工作。

Render() error 这个函数主要用来实现渲染模板，如果 beego.AutoRender 为 true 的情况下才会执行。

模型orm

• 默认支持MySQL、PostgreSQL和Sqlite3 三种数据库
• 数据库连接及增删改查示例

func init() {
    // set default database
    orm.RegisterDataBase("default", "mysql", "username:password@tcp(127.0.0.1:3306)/db_name?charset=utf8", 30)
    // register model
    orm.RegisterModel(new(User))
    // create table
    orm.RunSyncdb("default", false, true)
}

func main() {
    o := orm.NewOrm()
    user := User{Name: "slene"}
    // insert
    id, err := o.Insert(&user)
    fmt.Printf("ID: %d, ERR: %v\n", id, err)
    // update
    user.Name = "astaxie"
    num, err := o.Update(&user)
    fmt.Printf("NUM: %d, ERR: %v\n", num, err)
    // read one
    u := User{Id: user.Id}
    err = o.Read(&u)
    fmt.Printf("ERR: %v\n", err)
    // delete
    num, err = o.Delete(&u)
    fmt.Printf("NUM: %d, ERR: %v\n", num, err)
}

• 关联查询，关联方式大体有三种，均需在tag注解中说明：
  1, 一对一orm:"rel(one)" 反向：orm:"reverse(one)"
  2, 一对多orm:"rel(fk)" 反向：orm:"reverse(many)"
  4, 多对多orm:"rel(m2m)" 反向：orm:"reverse(many)"

type Post struct {
    Id    int    `orm:"auto"`
    Title string `orm:"size(100)"`
    User  *User  `orm:"rel(fk)"`
}

var posts []*Post
qs := o.QueryTable("post")
num, err := qs.Filter("User__Name", "slene").All(&posts)

• 原生sql查询

var maps []orm.Params
num, err := o.Raw("SELECT * FROM user").Values(&maps)
for _,term := range maps{
    fmt.Println(term["id"],":",term["name"])
}

• 事务处理

o.Begin()
...
user := User{Name: "slene"}
id, err := o.Insert(&user)
if err == nil {
    o.Commit()
} else {
    o.Rollback()
}

• 高级查询操作符

exact / iexact 等于
contains / icontains 包含
gt / gte 大于 / 大于等于
lt / lte 小于 / 小于等于
startswith / istartswith 以…起始
endswith / iendswith 以…结束
in
isnull
后面以 i 开头的表示：大小写不敏感

• 高级查询操作符示例：

qs.Filter("name__exact", "slene") // WHERE name = 'slene'
qs.Filter("name__contains", "slene") // WHERE name LIKE BINARY '%slene%'
ids:=[]int{17,18,19,20};  qs.Filter("age__in", ids) // WHERE age IN (17, 18, 19, 20)
qs.Filter("profile__age__gt", 17) // WHERE profile.age > 17
qs.Filter("name__startswith", "slene") // WHERE name LIKE BINARY 'slene%'
qs.Filter("profile__id__isnull", true) // WHERE profile_id IS NULL

//select示例
 orm1.QueryTable(TableName("user")).Filter("username__contains", m.Username).Limit(10, 0).OrderBy("-id").All(&users,"id","username");

• 构造查询接口

// User 包装了下面的查询结果
type User struct {
    Id  int
    Username string
    Age  int
}
var users []User

// 获取 QueryBuilder 对象. 需要指定数据库驱动参数。
// 第二个返回值是错误对象，在这里略过
qb, _ := orm.NewQueryBuilder("mysql")

// 构建查询对象
qb.Select("a.id","a.username","b.birthday").
     From(TableName("user") + " as a").
     InnerJoin(TableName("user_profile") + " as b").On("a.id = b.user_id").
     Where("a.username like '"+ m.Username +"%'").
     OrderBy("a.id").Desc().
     Limit(10).Offset(0)

// 导出 SQL 语句
sql := qb.String()

// 执行 SQL 语句
o := orm.NewOrm()
o.Raw(sql, 20).QueryRows(&users)

beego 模板语法

• go 统一使用了 {{ 和 }} 作为左右标签，没有其他的标签符号。如果您想要修改为其它符号，可以参考 模板标签。
• 使用 . 来访问当前位置的上下文
• 数据输出

func (this *MainController) Get() {
        this.Data["Website"] = "beego.me"
        this.Data["Email"] = "[email protected]"
        this.TplName = "index.tpl"
}

• if … else … end

{{if .IsHome}}
{{else}}
    {{if .IsAbout}}{{end}}
{{end}}

• range … end

{{range .Pages}}
    {{.Num}} of {{$.Total}}
{{end}}

• beego 中支持直接载入文件模板
  {{template "path/to/head.html" .}}

beego 单元测试

• 只有唯一的参数，必须是 t *testing.T 类型
• 必须以单词 Test 开头，再组合上首字母大写的单词或词组（一般是被测试的方法名称，如 TestValidateClient）
• 调用 t.Error 或者 t.Fail 方法指明测试失败（这里我使用了 t.Errorf 来提供更多的细节）
  t.Log 可以用来提供一些失败信息以外的调试信息
• 测试代码文件名必须是 _test 结尾的形式 something_test.go ，例如：addtion_test.go

1，功能测试
go test user_test.go -v -run="TestGetUser"

// TestGetUser is a sample to run an endpoint test
func TestGetUser(t *testing.T) {

    param := map[string]string{
        "username": "a",
    }

    marshaled, _ := json.Marshal(param)
    r, err := http.NewRequest("Post", "/v1/user/GetUser", bytes.NewBuffer(marshaled))
    if err != nil {
        t.Fatalf("should get user success, but fails to send request, error:%s\n", err)
    }
    w := httptest.NewRecorder()
    beego.BeeApp.Handlers.ServeHTTP(w, r)

    beego.Trace("testing", "TestGetUser", "Code[%d]\n%s", w.Code, w.Body.String())

}

2，性能测试
go test user_test.go -v -bench="BenchmarkGetUser"

// BenchmarkGetUser 
func BenchmarkGetUser(b *testing.B) {

    b.ResetTimer()
 
    for i := 0; i < b.N; i++ {
        param := map[string]string{
            "username": "a",
        }

        marshaled, _ := json.Marshal(param)
        r, err := http.NewRequest("Post", "/v1/user/GetUser", bytes.NewBuffer(marshaled))
        if err != nil {
            b.Fatalf("should get user success, but fails to send request, error:%s\n", err)
        }
        w := httptest.NewRecorder()
        beego.BeeApp.Handlers.ServeHTTP(w, r)

        beego.Trace("testing", "TestGetUser", "Code[%d]\n%s", w.Code, w.Body.String())
    }
}

其他

1，import 导入包时，初始化init函数里用到，但是主体各函数里没用到，引入包名左侧要有个下划线别名，否则会报错，例如数据库连接初始化

2, Go语言要求public的变量必须以大写字母开头，private变量则以小写字母开头, 函数名命名也遵循这个规则，否则小写开头的变量和函数名不能被外部访问

3，JSON输出的时候必须注意，只有导出的字段(首字母是大写)才会被输出，如果修改字段名，那么就会发现什么都不会输出，所以必须通过struct tag（结构体注解）定义来实现。针对JSON的输出，我们在定义struct tag的时候需要注意的几点是：

• 字段的tag是"-"，那么这个字段不会输出到JSON
• tag中带有自定义名称，那么这个自定义名称会出现在JSON的字段名中
• tag中如果带有"omitempty"选项，那么如果该字段值为空，就不会输出到JSON串中
• 如果字段类型是bool, string, int, int64等，而tag中带有",string"选项，那么这个字段在输出到JSON的时候会把该字段对应的值转换成JSON字符串

4，Beego框架orm在执行o.Insert(*p)插入数据时候需要传入指针变量作为参数，原因是因为在插入成功后，会返回id给user

5，当字段是指针类型时，如果没有用orm:"-"进行orm忽略，必须要添加标签来进行表关系设置。

6，多个接口返回字段不一样时，如果公用结构体指针查询的值，对输出的字段不好增减控制，建议接口方法内每次对接口输出的字段自定义结构体