beego框架开发文档
简介
beego 是一个快速开发 Go 应用的 HTTP 框架，他可以用来快速开发 API、Web 及后端服务等各种应用，是一个 RESTful 的框架，主要设计灵感来源于 tornado、sinatra 和 flask 这三个框架，但是结合了 Go 本身的一些特性（interface、struct 嵌入等）而设计的一个框架。
架构
beego 的整体设计架构如下所示：
beego 是基于八大独立的模块构建的，是一个高度解耦的框架。当初设计 beego 的时候就是考虑功能模块化，用户即使不使用 beego 的 HTTP 逻辑，也依旧可以使用这些独立模块，例如：你可以使用 cache 模块来做你的缓存逻辑；使用日志模块来记录你的操作信息；使用 config 模块来解析你各种格式的文件。所以 beego 不仅可以用于 HTTP 类的应用开发，在你的 socket 游戏开发中也是很有用的模块，这也是 beego 如此受欢迎的一个原因。大家如果玩过乐高的话，应该知道很多高级的东西都是一块一块的积木搭建出来的，而设计 beego 的时候，这些模块就是积木，高级机器人就是 beego。
执行逻辑
既然 beego 是基于这些模块构建的，那么它的执行逻辑是怎么样的呢？beego 是一个典型的 MVC 架构，它的执行逻辑如下图所示：
项目结构
一般的 beego 项目的目录如下所示：
1 | ├── conf |
从上面的目录结构我们可以看出来 M（models 目录）、V（views 目录）和 C（controllers 目录）的结构， main.go 是入口文件。
安装与升级
beego安装
beego 的安装是典型的 Go 安装包的形式：
1 | go get github.com/beego/beego/v2@latest |
beego 升级
beego 升级分为 go 方式升级和源码下载升级：
Go 升级,通过该方式用户可以升级 beego 框架，强烈推荐该方式：
1
go get -u github.com/beego/beego/v2
源码下载升级，用户访问
https://github.com/beego/beego,下载源码，然后覆盖到$GOPATH/src/github.com/beego/beego目录，然后通过本地执行安装就可以升级了：1
go install github.com/beego/beego/v2
bee 工具
bee 工具是一个为了协助快速开发 beego 项目而创建的项目，通过 bee 您可以很容易的进行 beego 项目的创建、热编译、开发、测试、和部署。
bee 工具的安装
您可以通过如下的方式安装 bee 工具：
1 | # go 1.16 以前的版本 |
安装完之后，bee 可执行文件默认存放在 $GOPATH/bin 里面，所以您需要把 $GOPATH/bin 添加到您的环境变量中，才可以进行下一步。
bee 工具命令详解
我们在命令行输入 bee，可以看到如下的信息：
1 | version Prints the current Bee version |
new命令
new 命令是新建一个 Web 项目，我们在命令行下执行 bee new <项目名> 就可以创建一个新的项目。但是注意该命令必须在 $GOPATH/src 下执行。最后会在 $GOPATH/src 相应目录下生成如下目录结构的项目：
1 | bee new myproject |
以上是官方文档的描述，但是我亲测可以在任意路径使用
bee new <项目名>命令，不一定要在$GOPATH/src。
api 命令
上面的 new 命令是用来新建 Web 项目，不过很多用户使用 beego 来开发 API 应用。所以这个 api 命令就是用来创建 API 应用的，执行命令之后如下所示：
1 | bee api apiproject |
这个项目的目录结构如下：
1 | apiproject |
从上面的目录我们可以看到和 Web 项目相比，少了 static 和 views 目录，多了一个 test 模块，用来做单元测试的。同时，该命令还支持一些自定义参数自动连接数据库创建相关 model 和 controller:bee api [appname] [-tables=""] [-driver=mysql] [-conn="root:<password>@tcp(127.0.0.1:3306)/test"]
如果 conn 参数为空则创建一个示例项目，否则将基于链接信息链接数据库创建项目。
同样笔者亲测该命令也不一定要在
$GOPATH/src运行
run 命令
我们在开发 Go 项目的时候最大的问题是经常需要自己手动去编译再运行，bee run 命令是监控 beego 的项目，通过 fsnotify监控文件系统。但是注意该命令必须在 $GOPATH/src/appname 下执行。
这样我们在开发过程中就可以实时的看到项目修改之后的效果：
1 | bee run |
我们打开浏览器就可以看到效果 http://localhost:8080/:
如果我们修改了 Controller 下面的 default.go 文件，我们就可以看到命令行输出：
1 | 13-11-25 10:11:20 [EVEN] "/gopath/src/myproject/controllers/default.go": DELETE|MODIFY |
刷新浏览器我们看到新的修改内容已经输出。
pack 命令
pack 目录用来发布应用的时候打包，会把项目打包成 zip 包，这样我们部署的时候直接把打包之后的项目上传，解压就可以部署了：
1 | bee pack |
我们可以看到目录下有如下的压缩文件：
1 | rwxr-xr-x 1 astaxie staff 8995376 11 25 22:46 apiproject |
version 命令
1 | $ bee version |
generate 命令
这个命令是用来自动化的生成代码的，包含了从数据库一键生成 model，还包含了 scaffold 的，通过这个命令，让大家开发代码不再慢
1 | bee generate scaffold [scaffoldname] [-fields=""] [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"] |
migrate 命令
这个命令是应用的数据库迁移命令，主要是用来每次应用升级，降级的SQL管理。
1 | bee migrate [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"] |
快速入门
beego 是一个能够进行快速开发应用的框架，快速入门将带领你快速的建立一个 beego 的项目，然后运行起来。接着修改代码，让我们了解整个 MVC 的运行机制。那么让我们开始创建项目吧！
创建项目
beego 的项目基本都是通过 bee 命令来创建的，所以在创建项目之前确保你已经安装了 bee 工具和 beego。
现在一切就绪我们就可以开始创建项目了，打开终端，进入 $GOPATH/src 所在的目录：
1 | ➜ src bee new quickstart |
通过一个简单的命令就创建了一个 beego 项目。他的目录结构如下所示
1 | quickstart |
从目录结构中我们也可以看出来这是一个典型的 MVC 架构的应用，main.go 是入口文件。
运行项目
beego 项目创建之后，我们还需要初始化go.mod文件。进入目录之后，使用go mod init初始化模块依赖。
接着我们就开始运行项目，首先进入创建的项目，我们使用 bee run 来运行该项目，这样就可以做到热编译的效果：
1 | ➜ src cd quickstart |
这样我们的应用已经在 8080 端口(beego 的默认端口)跑起来了.你是不是觉得很神奇，为什么没有 nginx 和 apache 居然可以自己干这个事情？是的，Go 其实已经做了网络层的东西，beego 只是封装了一下，所以可以做到不需要 nginx 和 apache。让我们打开浏览器看看效果吧：
路由设置
前面我们已经创建了 beego 项目，而且我们也看到它已经运行起来了，那么是如何运行起来的呢？让我们从入口文件先分析起来吧：
1 | package main |
我们看到 main 函数是入口函数，但是我们知道 Go 的执行过程是如下图所示的方式：
这里我们就看到了我们引入了一个包 _ "quickstart/routers",这个包只引入执行了里面的 init 函数，那么让我们看看这个里面做了什么事情：
1 | package routers |
路由包里面我们看到执行了路由注册 web.Router, 这个函数的功能是映射 URL 到 controller，第一个参数是 URL (用户请求的地址)，这里我们注册的是 /，也就是我们访问的不带任何参数的 URL，第二个参数是对应的 Controller，也就是我们即将把请求分发到那个控制器来执行相应的逻辑，我们可以执行类似的方式注册如下路由：
1 | web.Router("/user", &controllers.UserController{}) |
这样用户就可以通过访问 /user 去执行 UserController 的逻辑。这就是我们所谓的路由。
一旦 run 起来之后，我们的服务就监听在两个端口了，一个服务端口 8080 作为对外服务，另一个 8088 端口实行对内监控。
controller 逻辑
前面我们了解了如何把用户的请求分发到控制器，这小节我们就介绍大家如何来写控制器，首先我们还是从源码分析入手：
1 | package controllers |
上面的代码显示首先我们声明了一个控制器 MainController，这个控制器里面组合了 web.Controller，这就是 Go 的组合方式，也就是 MainController 自动拥有了所有 web.Controller 的方法。
而 web.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 函数（这个函数是在 web.Controller 中实现的），所以无需用户自己来调用渲染。
当然也可以不使用模版，直接用 this.Ctx.WriteString 输出字符串，如：
1 | func (this *MainController) Get() { |
至此我们的控制器分析基本完成了，接下来让我们看看如何来编写 model。
model 逻辑
我们知道 Web 应用中我们用的最多的就是数据库操作，而 model 层一般用来做这些操作，我们的 bee new 例子不存在 Model 的演示，但是 bee api 应用中存在 model 的应用。说的简单一点，如果您的应用足够简单，那么 Controller 可以处理一切的逻辑，如果您的逻辑里面存在着可以复用的东西，那么就抽取出来变成一个模块。因此 Model 就是逐步抽象的过程，一般我们会在 Model 里面处理一些数据读取，如下是一个日志分析应用中的代码片段：
1 | package models |
所以如果您的应用足够简单，那么就不需要 Model 了；如果你的模块开始多了，需要复用，需要逻辑分离了，那么 Model 是必不可少的。接下来我们将分析如何编写 View 层的东西。
View 编写
在前面编写 Controller 的时候，我们在 Get 里面写过这样的语句 this.TplName = "index.tpl"，设置显示的模板文件，默认支持 tpl 和 html 的后缀名，如果想设置其他后缀你可以调用 beego.AddTemplateExt 接口设置，那么模板如何来显示相应的数据呢？beego 采用了 Go 语言默认的模板引擎，所以和 Go 的模板语法一样，Go 模板的详细使用方法在我这篇文章有讲解。
我们看看快速入门里面的代码（去掉了 css 样式）：
1 | <!DOCTYPE html> |
我们在 Controller 里面把数据赋值给了 data（map 类型），然后我们在模板中就直接通过 key 访问 .Website 和 .Email 。这样就做到了数据的输出。接下来我们讲解如何让静态文件输出。
静态文件处理
前面我们介绍了如何输出静态页面，但是我们的网页往往包含了很多的静态文件，包括图片、JS、CSS 等，刚才创建的应用里面就创建了如下目录：
1 | ├── static |
beego 默认注册了 static 目录为静态处理的目录，注册样式：URL 前缀和映射的目录（在/main.go文件中web.Run()之前加入）：
1 | StaticDir["/static"] = "static" |
用户可以设置多个静态文件处理目录，例如你有多个文件下载目录 download1、download2，你可以这样映射（在 /main.go 文件中 web.Run() 之前加入）：
1 | web.SetStaticPath("/down1", "download1") |
这样用户访问 URL http://localhost:8080/down1/123.txt 则会请求 download1 目录下的 123.txt 文件。
beego 的 MVC 架构
beego 是一个典型的 MVC 框架，它的整个执行逻辑如下图所示：
通过文字来描述如下：
- 在监听的端口接收数据，默认监听在 8080 端口。
- 用户请求到达 8080 端口之后进入 beego 的处理逻辑。
- 初始化 Context 对象，根据请求判断是否为 WebSocket 请求，如果是的话设置 Input，同时判断请求的方法是否在标准请求方法中（GET、POST、PUT、DELETE、PATCH、OPTIONS、HEAD），防止用户的恶意伪造请求攻击造成不必要的影响。
- 执行 BeforeRouter 过滤器，当然在 beego 里面有开关设置。如果用户设置了过滤器，那么该开关打开，这样可以提高在没有开启过滤器的情况下提高执行效率。如果在执行过滤器过程中，responseWriter 已经有数据输出了，那么就提前结束该请求，直接跳转到监控判断。
- 开始执行静态文件的处理，查看用户的请求 URL 是否和注册在静态文件处理 StaticDir 中的 prefix 是否匹配。如果匹配的话，采用
http包中默认的 ServeFile 来处理静态文件。 - 如果不是静态文件开始初始化 session 模块(如果开启 session 的话)，这个里面大家需要注意，如果你的 BeforeRouter 过滤器用到了 session 就会报错，你应该把它加入到 AfterStatic 过滤器中。
- 开始执行 AfterStatic 过滤器，如果在执行过滤器过程中，responseWriter 已经有数据输出了，那么就提前结束该请求，直接跳转到监控判断。
- 执行过过滤器之后，开始从固定的路由规则中查找和请求 URL 相匹配的对象。这个匹配是全匹配规则，即如果用户请求的 URL 是
/hello/world，那么固定规则中/hello是不会匹配的，只有完全匹配才算匹配。如果匹配的话就进入逻辑执行，如果不匹配进入下一环节的正则匹配。 - 正则匹配是进行正则的全匹配，这个正则是按照用户添加 beego 路由顺序来进行匹配的，也就是说，如果你在添加路由的时候你的顺序影响你的匹配。和固定匹配一样，如果匹配的话就进行逻辑执行，如果不匹配进入 Auto 匹配。
- 如果用户注册了 AutoRouter，那么会通过
controller/method这样的方式去查找对应的 Controller 和他内置的方法，如果找到就开始执行逻辑，如果找不到就跳转到监控判断。 - 如果找到 Controller 的话，那么就开始执行逻辑，首先执行 BeforeExec 过滤器，如果在执行过滤器过程中，responseWriter 已经有数据输出了，那么就提前结束该请求，直接跳转到监控判断。
- Controller 开始执行 Init 函数，初始化基本的一些信息，这个函数一般都是 beego.Controller 的初始化，不建议用户继承的时候修改该函数。
- 是否开启了 XSRF，开启的话就调用 Controller 的 XsrfToken，然后如果是 POST 请求就调用 CheckXsrfCookie 方法。
- 继续执行 Controller 的 Prepare 函数，这个函数一般是预留给用户的，用来做 Controller 里面的一些参数初始化之类的工作。如果在初始化中 responseWriter 有输出，那么就直接进入 Finish 函数逻辑。
- 如果没有输出的话，那么根据用户注册的方法执行相应的逻辑，如果用户没有注册，那么就调用 http.Method 对应的方法（Get/Post 等）。执行相应的逻辑，例如数据读取，数据赋值，模板显示之类的，或者直接输出 JSON 或者 XML。
- 如果 responseWriter 没有输出，那么就调用 Render 函数进行模板输出。
- 执行 Controller 的 Finish 函数，这个函数是预留给用户用来重写的，用于释放一些资源。释放在 Init 中初始化的信息数据。
- 执行 AfterExec 过滤器，如果有输出的话就跳转到监控判断逻辑。
- 执行 Controller 的 Destructor，用于释放 Init 中初始化的一些数据。
- 如果这一路执行下来都没有找到路由，那么会调用 404 显示找不到该页面。
- 最后所有的逻辑都汇聚到了监控判断，如果用户开启了监控模块（默认是开启一个 8088 端口用于进程内监控），这样就会把访问的请求链接扔给监控程序去记录当前访问的 QPS，对应的链接访问的执行时间，请求链接等。
controller 设计
参数配置
beego 目前支持 INI、XML、JSON、YAML 格式的配置文件解析，但是默认采用了 INI 格式解析，用户可以通过简单的配置就可以获得很大的灵活性。
默认配置解析
beego 默认会解析当前应用下的 conf/app.conf 文件。
通过这个文件你可以初始化很多 beego 的默认参数：
1 | appname = beepkg |
它们都维护在结构体 beego/server/web#Config 。
BConfig 就是 beego 里面的默认的配置，也是结构体 beego/server/web#Config 的实例。
你也可以直接通过web.BConfig.AppName="beepkg"这样来修改，和上面的配置效果一样，只是一个在代码里面写死了，而配置文件就会显得更加灵活。
你也可以在配置文件中配置应用需要用的一些配置信息，例如下面所示的数据库信息：
1 | mysqluser = "root" |
那么你就可以通过如下的方式获取设置的配置信息:
1 | web.AppConfig.String("mysqluser") |
不同级别的配置
在配置文件里面支持 section，可以有不同的 Runmode 的配置，默认优先读取 runmode 下的配置信息，例如下面的配置文件：
1 | appname = beepkg |
上面的配置文件就是在不同的 runmode 下解析不同的配置，例如在 dev 模式下，httpport 是 8080，在 prod 模式下是 8088，在 test 模式下是 8888。其他配置文件同理。解析的时候优先解析 runmode 下的配置，然后解析默认的配置。
多个配置文件
INI 格式配置支持 include 方式，引用多个配置文件，例如下面的两个配置文件效果同上：
app.conf
1 | appname = beepkg |
app2.conf
1 | runmode ="dev" |
关于系统的默认参数，参考官方文档：https://git-books.github.io/books/beego/?p=mvc/controller/config.md
路由设置
基础路由
从 beego 1.2 版本开始支持了基本的 RESTful 函数式路由,应用中的大多数路由都会定义在 routers/router.go 文件中。最简单的 beego 路由由 URI 和闭包函数组成。
GET
1 | web.Get("/",func(ctx *context.Context){ |
POST
1 | web.Post("/alice",func(ctx *context.Context){ |
响应任何 HTTP 的路由
1 | web.Any("/foo",func(ctx *context.Context){ |
支持的基础函数
- web.Get(router, web.HandleFunc)
- web.Post(router, web.HandleFunc)
- web.Put(router, web.HandleFunc)
- web.Patch(router, web.HandleFunc)
- web.Head(router, web.HandleFunc)
- web.Options(router, web.HandleFunc)
- web.Delete(router, web.HandleFunc)
- web.Any(router, web.HandleFunc)
固定路由
固定路由也就是全匹配的路由，如下所示：
1 | web.Router("/", &controllers.MainController{}) |
如上所示的路由就是我们最常用的路由方式，一个固定的路由，一个控制器，然后根据用户请求方法不同请求控制器中对应的方法，典型的 RESTful 方式。
正则路由
为了用户更加方便的路由设置，beego 参考了 sinatra 的路由实现，支持多种方式的路由：
web.Router(“/api/?:id”, &controllers.RController{})
默认匹配 //例如对于URL”/api/123”可以匹配成功，此时变量”:id”值为”123”，URL”/api/“可正常匹配
web.Router(“/api/:id”, &controllers.RController{})
默认匹配 //例如对于URL”/api/123”可以匹配成功，此时变量”:id”值为”123”，但URL”/api/“匹配失败
web.Router(“/api/:id([0-9]+)”, &controllers.RController{})
自定义正则匹配 //例如对于URL”/api/123”可以匹配成功，此时变量”:id”值为”123”
web.Router(“/user/:username([\w]+)”, &controllers.RController{})
正则字符串匹配 //例如对于URL”/user/astaxie”可以匹配成功，此时变量”:username”值为”astaxie”
web.Router(“/download/.“, &controllers.RController{})
*匹配方式 //例如对于URL”/download/file/api.xml”可以匹配成功，此时变量”:path”值为”file/api”， “:ext”值为”xml”
web.Router(“/download/ceshi/*”, &controllers.RController{})
*全匹配方式 //例如对于URL”/download/ceshi/file/api.json”可以匹配成功，此时变量”:splat”值为”file/api.json”
web.Router(“/:id:int”, &controllers.RController{})
int 类型设置方式，匹配 :id为int 类型，框架帮你实现了正则 ([0-9]+)
web.Router(“/:hi:string”, &controllers.RController{})
string 类型设置方式，匹配 :hi 为 string 类型。框架帮你实现了正则 ([\w]+)
web.Router(“/cms_:id([0-9]+).html”, &controllers.CmsController{})
带有前缀的自定义正则 //匹配 :id 为正则类型。匹配 cms_123.html 这样的 url :id = 123
可以在 Controller 中通过如下方式获取上面的变量：
1 | this.Ctx.Input.Param(":id") |
自定义方法及 RESTful 规则
上面列举的是默认的请求方法名（请求的 method 和函数名一致，例如 GET 请求执行 Get 函数，POST 请求执行 Post 函数），如果用户期望自定义函数名，那么可以使用如下方式：
1 | web.Router("/",&IndexController{},"*:Index") |
使用第三个参数，第三个参数就是用来设置对应 method 到函数名，定义如下
*表示任意的 method 都执行该函数- 使用 httpmethod:funcname 格式来展示
- 多个不同的格式使用
;分割 - 多个 method 对应同一个 funcname，method 之间通过
,来分割
以下是一个 RESTful 的设计示例：
1 | web.Router("/api/food",&RestController{},"get:ListFood") |
以下是多个 HTTP Method 指向同一个函数的示例：
1 | web.Router("/api",&RestController{},"get,post:ApiFunc") |
以下是不同的 method 对应不同的函数，通过 ; 进行分割的示例：
1 | web.Router("/api/food",&RestController{},"get:ListFood;post:CreateFood;put:UpdateFood;delete:DeleteFood") |
可用的 HTTP Method：
- *: 包含以下所有的函数
- get: GET 请求
- post: POST 请求
- put: PUT 请求
- delete: DELETE 请求
- patch: PATCH 请求
- options: OPTIONS 请求
- head: HEAD 请求
如果同时存在 * 和对应的 HTTP Method，那么优先执行 HTTP Method 的方法，例如同时注册了如下所示的路由：
1 | web.Router("/simple",&SimpleController{},"*:AllFunc;post:PostFunc") |
那么执行 POST 请求的时候，执行 PostFunc 而不执行 AllFunc。
自定义函数的路由默认不支持 RESTful 的方法，也就是如果你设置了
web.Router("/api",&RestController{},"post:ApiFunc")这样的路由，如果请求的方法是POST，那么不会默认去执行Post函数。
自动匹配
用户首先需要把需要路由的控制器注册到自动路由中：
1 | web.AutoRouter(&controllers.ObjectController{}) |
那么 beego 就会通过反射获取该结构体中所有的实现方法，你就可以通过如下的方式访问到对应的方法中：
1 | /object/login 调用 ObjectController 中的 Login 方法 |
除了前缀两个 /:controller/:method 的匹配之外，剩下的 url beego 会帮你自动化解析为参数，保存在 this.Ctx.Input.Params 当中：
1 | /object/blog/2013/09/12 调用 ObjectController 中的 Blog 方法，参数如下：map[0:2013 1:09 2:12] |
方法名在内部是保存了用户设置的，例如 Login，url 匹配的时候都会转化为小写，所以，/object/LOGIN 这样的 url 也一样可以路由到用户定义的 Login 方法中。
现在已经可以通过自动识别出来下面类似的所有 url，都会把请求分发到 controller 的 simple 方法：
1 | /controller/simple |
可以通过 this.Ctx.Input.Param(":ext") 获取后缀名。
注解路由
从2.0开始，我们使用配置CommentRouterPath来配置注解路由的扫描路径。在dev环境下，我们将自动扫描该配置指向的目录及其子目录，生成路由文件。
生成之后，用户需要显示 Include 相应的 controller。注意， controller 的 method 方法上面须有 router 注释（// @router），详细的使用请看下面的例子：
1 | // CMS API |
可以在 router.go 中通过如下方式注册路由：
1 | web.Include(&CMSController{}) |
web 自动会进行源码分析，注意只会在 dev 模式下进行生成，生成的路由放在 “/routers/commentsRouter.go” 文件中。
这样上面的路由就支持了如下的路由：
- GET /staticblock/:key
- GET /all/:key
其实效果和自己通过 Router 函数注册是一样的：
1 | web.Router("/staticblock/:key", &CMSController{}, "get:StaticBlock") |
同时大家注意到新版本里面增加了 URLMapping 这个函数，这是新增加的函数，用户如果没有进行注册，那么就会通过反射来执行对应的函数，如果注册了就会通过 interface 来进行执行函数，性能上面会提升很多。
方法表达式路由
方法表达式路由与上面的RESTful基本相似，区别是无需在传入http method和controller方法（如："get:StaticBlock"）。
只需要通过golang的method expression进行传入方法表达式。如果方法是receiver是非指针，则直接使用 包名.Controller.Method 方法 传入，
如果receiver是指针，则使用 (*包名.Controller).Method 进行传参。假如在同包下，包名可进行省略。
1 | type BaseController struct { |
共有以下几种函数：
- web.CtrlGet(router, pkg.controller.method)
- web.CtrlPost(router, pkg.controller.method)
- web.CtrlPut(router, pkg.controller.method)
- web.CtrlPatch(router, pkg.controller.method)
- web.CtrlHead(router, pkg.controller.method)
- web.CtrlOptions(router, pkg.controller.method)
- web.CtrlDelete(router, pkg.controller.method)
- web.CtrlAny(router, pkg.controller.method)
控制器函数
控制器介绍
基于 beego 的 Controller 设计，只需要匿名组合 beego.Controller 就可以了，如下所示：
1 | package your_package |
控制器方法
web.Controller 实现了接口 web.ControllerInterface，web.ControllerInterface 定义了如下函数：
Init(ctx *context.Context, controllerName, actionName 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 的情况下才会执行。
Redirect(url string, code int)
重定向。
url是目的地址。
子类扩展
通过子 struct 的方法重写，用户就可以实现自己的逻辑，接下来我们看一个实际的例子：
1 | type AddController struct { |
从上面的例子可以看出来，通过重写方法可以实现对应 method 的逻辑，实现 RESTFul 结构的逻辑处理。
提前终止运行
我们应用中经常会遇到这样的情况，在 Prepare 阶段进行判断，如果用户认证不通过，就输出一段信息，然后直接中止进程，之后的 Post、Get 之类的不再执行，那么如何终止呢？可以使用 StopRun 来终止执行逻辑，可以在任意的地方执行。
1 | type RController struct { |
调用 StopRun 之后，如果你还定义了 Finish 函数就不会再执行，如果需要释放资源，那么请自己在调用 StopRun 之前手工调用 Finish 函数。
XSRF 过滤
跨站请求伪造
跨站请求伪造(Cross-site request forgery)， 简称为 XSRF，是 Web 应用中常见的一个安全问题。前面的链接也详细讲述了 XSRF 攻击的实现方式。
当前防范 XSRF 的一种通用的方法，是对每一个用户都记录一个无法预知的 cookie 数据，然后要求所有提交的请求（POST/PUT/DELETE）中都必须带有这个 cookie 数据。如果此数据不匹配 ，那么这个请求就可能是被伪造的。
beego 有内建的 XSRF 的防范机制，要使用此机制，你需要在应用配置文件中加上 enablexsrf 设定：
1 | enablexsrf = true |
或者直接在 main 入口处这样设置：
1 | web.EnableXSRF = true |
如果开启了 XSRF，那么 beego 的 Web 应用将对所有用户设置一个 _xsrf 的 cookie 值（默认过期 1 小时），如果 POST PUT DELET 请求中没有这个 cookie 值，那么这个请求会被直接拒绝。如果你开启了这个机制，那么在所有被提交的表单中，你都需要加上一个域来提供这个值。你可以通过在模板中使用 专门的函数 XSRFFormHTML() 来做到这一点：
过期时间上面我们设置了全局的过期时间 web.XSRFExpire，但是有些时候我们也可以在控制器中修改这个过期时间，专门针对某一类处理逻辑：
1 | func (this *HomeController) Get(){ |
支持controller 级别的屏蔽
XSRF 之前是全局设置的一个参数,如果设置了那么所有的 API 请求都会进行验证,但是有些时候API 逻辑是不需要进行验证的,因此现在支持在controller 级别设置屏蔽:
1 | type AdminController struct{ |
请求数据处理
获取参数
我们经常需要获取用户传递的数据，包括 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)
使用例子如下：
1 | func (this *MainController) Post() { |
如果你需要的数据可能是其他类型的，例如是 int 类型而不是 int64，那么你需要这样处理：
1 | func (this *MainController) Post() { |
更多其他的 request 的信息，用户可以通过 this.Ctx.Request 获取信息。
直接解析到 struct
如果要把表单里的内容赋值到一个 struct 里，除了用上面的方法一个一个获取再赋值外，beego 提供了通过另外一个更便捷的方式，就是通过 struct 的字段名或 tag 与表单字段对应直接解析到 struct。
定义 struct：
1 | type user struct { |
表单：
1 | <form id="user"> |
Controller 里解析：
1 | func (this *MainController) Post() { |
注意：
- 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 中
1 | func (this *ObjectController) Post() { |
文件上传
在 beego 中你可以很容易的处理文件上传，就是别忘记在你的 form 表单中增加这个属性 enctype="multipart/form-data"，否则你的浏览器不会传输你的上传文件。
文件上传之后一般是放在系统的内存里面，如果文件的 size 大于设置的缓存内存大小，那么就放在临时文件中，默认的缓存内存是 64M，你可以通过如下来调整这个缓存内存大小:
1 | web.MaxMemory = 1<<22 |
或者在配置文件中通过如下设置：
1 | maxmemory = 1<<22 |
与此同时，beego 提供了另外一个参数，MaxUploadSize来限制最大上传文件大小——如果你一次长传多个文件，那么它限制的就是这些所有文件合并在一起的大小。
默认情况下，MaxMemory应该设置得比MaxUploadSize小，这种情况下两个参数合并在一起的效果则是：
- 如果文件大小小于
MaxMemory，则直接在内存中处理； - 如果文件大小介于
MaxMemory和MaxUploadSize之间，那么比MaxMemory大的部分将会放在临时目录； - 文件大小超出
MaxUploadSize，直接拒绝请求，返回响应码 413
Beego 提供了两个很方便的方法来处理文件上传：
GetFile(key string) (multipart.File, *multipart.FileHeader, error)
该方法主要用于用户读取表单中的文件名
the_file，然后返回相应的信息，用户根据这些变量来处理文件上传：过滤、保存文件等。SaveToFile(fromfile, tofile string) error
该方法是在 GetFile 的基础上实现了快速保存的功能
fromfile 是提交时候的 html 表单中的 name
1 | <form enctype="multipart/form-data" method="post"> |
保存的代码例子如下：
1 | func (c *FormController) Post() { |
数据绑定
支持从用户请求中直接数据 bind 到指定的对象,例如请求地址如下：
1 | ?id=123&isok=true&ft=1.2&ol[0]=1&ol[1]=2&ul[]=str&ul[]=array&user.Name=astaxie |
1 | var id int |
session 控制
beego 内置了 session 模块，使用 session 相当方便，只要在 main 入口函数中设置如下：
1 | web.BConfig.WebConfig.Session.SessionOn = true |
或者通过配置文件配置如下：
1 | sessionon = true |
通过这种方式就可以开启 session，如何使用 session，请看下面的例子：
1 | func (this *MainController) Get() { |
session 有几个方便的方法：
- SetSession(name string, value interface{})
- GetSession(name string) interface{}
- DelSession(name string)
- SessionRegenerateID()
- DestroySession()
session 操作主要有设置 session、获取 session、删除 session。
当然你可以通过下面的方式自己控制这些逻辑：
1 | sess:=this.StartSession() |
sess 对象具有如下方法：
- sess.Set()
- sess.Get()
- sess.Delete()
- sess.SessionID()
- sess.Flush()
但是我还是建议大家采用 SetSession、GetSession、DelSession 三个方法来操作，避免自己在操作的过程中资源没释放的问题。
关于 Session 模块使用中的一些参数设置：
web.BConfig.WebConfig.Session.SessionOn
设置是否开启 Session，默认是 false，配置文件对应的参数名：sessionon。
web.BConfig.WebConfig.Session.SessionName
设置 cookies 的名字，Session 默认是保存在用户的浏览器 cookies 里面的，默认名是 beegosessionID，配置文件对应的参数名是：sessionname。
web.BConfig.WebConfig.Session.SessionGCMaxLifetime
设置 Session 过期的时间，默认值是 3600 秒，配置文件对应的参数：sessiongcmaxlifetime。
web.BConfig.WebConfig.Session.SessionHashFunc
默认值为 sha1，采用 sha1 加密算法生产 sessionid
web.BConfig.WebConfig.Session.SessionCookieLifeTime
设置 cookie 的过期时间，cookie 是用来存储保存在客户端的数据。
过滤器
beego 支持自定义过滤中间件，例如安全验证，强制跳转等。
过滤器函数如下所示：
1 | web.InsertFilter(pattern string, pos int, filter FilterFunc, opts ...FilterOpt) |
InsertFilter 函数的三个必填参数，一个可选参数
- pattern 路由规则，可以根据一定的规则进行路由，如果你全匹配可以用
* - position 执行 Filter 的地方，五个固定参数如下，分别表示不同的执行过程
- BeforeStatic 静态地址之前
- BeforeRouter 寻找路由之前
- BeforeExec 找到路由之后，开始执行相应的 Controller 之前
- AfterExec 执行完 Controller 逻辑之后执行的过滤器
- FinishRouter 执行完逻辑之后执行的过滤器
- BeforeStatic 静态地址之前
- filter filter 函数 type FilterFunc func(*context.Context)
- opts
如下例子所示，验证用户是否已经登录，应用于全部的请求：
1 | var FilterUser = func(ctx *context.Context) { |
这里需要特别注意使用 session 的 Filter 必须在 BeforeStatic 之后才能获取，因为 session 没有在这之前初始化。
还可以通过正则路由进行过滤，如果匹配参数就执行：
1 | var FilterUser = func(ctx *context.Context) { |
flash 数据
这个 flash 与 Adobe/Macromedia Flash 没有任何关系。它主要用于在两个逻辑间传递临时数据，flash 中存放的所有数据会在紧接着的下一个逻辑中调用后清除。一般用于传递提示和错误消息。它适合 Post/Redirect/Get 模式。下面看使用的例子：
1 | // 显示设置信息 |
上面的代码执行的大概逻辑是这样的：
- Get 方法执行，因为没有 flash 数据，所以显示设置页面。
- 用户设置信息之后点击递交，执行 Post，然后初始化一个 flash，通过验证，验证出错或者验证不通过设置 flash 的错误，如果通过了就保存设置，然后设置 flash 成功设置的信息。
- 设置完成后跳转到 Get 请求。
- Get 请求获取到了 Flash 信息，然后执行相应的逻辑，如果出错显示出错的页面，如果成功显示成功的页面。
默认情况下 ReadFromRequest 函数已经实现了读取的数据赋值给 flash，所以在你的模板里面你可以这样读取数据：
1 | {{.flash.error}} |
flash 对象有三个级别的设置：
- Notice 提示信息
- Warning 警告信息
- Error 错误信息
URL 构建
如果可以匹配 URL ，那么 beego 也可以生成 URL 吗？当然可以。 UrlFor() 函数就是用于构建指定函数的 URL 的。它把对应控制器和函数名结合的字符串作为第一个参数，其余参数对应 URL 中的变量。未知变量将添加到 URL 中作为查询参数。 例如：
下面定义了一个相应的控制器
1 | type TestController struct { |
下面是我们注册的路由：
1 | web.Router("/api/list", &TestController{}, "*:List") |
那么通过方式可以获取相应的URL地址：
1 | web.URLFor("TestController.List") |
模板中如何使用
默认情况下，beego 已经注册了 urlfor 函数，用户可以通过如下的代码进行调用
1 | {{urlfor "TestController.List"}} |
为什么不在把 URL 写死在模板中，反而要动态构建？有两个很好的理由：
- 反向解析通常比硬编码 URL 更直观。同时，更重要的是你可以只在一个地方改变 URL ，而不用到处乱找。
- URL 创建会为你处理特殊字符的转义和 Unicode 数据，不用你操心。
多种格式数据输出
beego 当初设计的时候就考虑了 API 功能的设计，而我们在设计 API 的时候经常是输出 JSON 或者 XML 数据，那么 beego 提供了这样的方式直接输出：
注意 struct 属性应该 为 exported Identifier
首字母应该大写
JSON 数据直接输出：
1
2
3
4
5func (this *AddController) Get() {
mystruct := { ... }
this.Data["json"] = &mystruct
this.ServeJSON()
}调用 ServeJSON 之后，会设置
content-type为application/json，然后同时把数据进行 JSON 序列化输出。XML 数据直接输出：
1
2
3
4
5func (this *AddController) Get() {
mystruct := { ... }
this.Data["xml"]=&mystruct
this.ServeXML()
}调用 ServeXML 之后，会设置
content-type为application/xml，同时数据会进行 XML 序列化输出。jsonp 调用
1
2
3
4
5func (this *AddController) Get() {
mystruct := { ... }
this.Data["jsonp"] = &mystruct
this.ServeJSONP()
}调用 ServeJSONP 之后，会设置
content-type为application/javascript，然后同时把数据进行 JSON 序列化，然后根据请求的 callback 参数设置 jsonp 输出。
开发模式下序列化后输出的是格式化易阅读的 JSON 或 XML 字符串；在生产模式下序列化后输出的是压缩的字符串。
表单数据验证
安装及测试
安装：
1 | go get github.com/beego/beego/v2/core/validation |
测试：
1 | go test github.com/beego/beego/v2/core/validation |
示例
直接使用示例：
1 | import ( |
通过 StructTag 使用示例：
1 | import ( |
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，其他类型都将不能通过验证Alphaalpha字符，有效类型：string，其他类型都将不能通过验证Numeric数字，有效类型：string，其他类型都将不能通过验证AlphaNumericalpha 字符或数字，有效类型：string，其他类型都将不能通过验证Match(pattern string)正则匹配，有效类型：string，其他类型都将被转成字符串再匹配(fmt.Sprintf(“%v”, obj).Match)AlphaDashalpha 字符或数字或横杠-_，有效类型：string，其他类型都将不能通过验证Email邮箱格式，有效类型：string，其他类型都将不能通过验证IPIP 格式，目前只支持 IPv4 格式验证，有效类型：string，其他类型都将不能通过验证Base64base64 编码，有效类型：string，其他类型都将不能通过验证Mobile手机号，有效类型：string，其他类型都将不能通过验证Tel固定电话号，有效类型：string，其他类型都将不能通过验证Phone手机号或固定电话号，有效类型：string，其他类型都将不能通过验证ZipCode邮政编码，有效类型：string，其他类型都将不能通过验证
自定义验证
我们允许自己注册验证逻辑。使用方法：
1 | AddCustomFunc(name string, f CustomFunc) error |
错误处理
我们在做 Web 开发的时候，经常需要页面跳转和错误处理，beego 这方面也进行了考虑，通过 Redirect 方法来进行跳转：
1 | func (this *AddController) Get() { |
如何中止此次请求并抛出异常，beego 可以在控制器中这样操作：
1 | func (this *MainController) Get() { |
这样 this.Abort("401") 之后的代码不会再执行，而且会默认显示给用户如下页面：
web 框架默认支持 401、403、404、500、503 这几种错误的处理。用户可以自定义相应的错误处理，例如下面重新定义 404 页面：
1 | func page_not_found(rw http.ResponseWriter, r *http.Request){ |
我们可以通过自定义错误页面 404.html 来处理 404 错误。
beego 更加人性化的还有一个设计就是支持用户自定义字符串错误类型处理函数，例如下面的代码，用户注册了一个数据库出错的处理页面：
1 | func dbError(rw http.ResponseWriter, r *http.Request){ |
一旦在入口注册该错误处理代码，那么你可以在任何你的逻辑中遇到数据库错误调用 this.Abort("dbError") 来进行异常页面处理。
Controller 定义 Error
从 1.4.3 版本开始，支持 Controller 方式定义 Error 错误处理函数，这样就可以充分利用系统自带的模板处理，以及 context 等方法。
1 | package controllers |
通过上面的例子我们可以看到，所有的函数都是有一定规律的，都是 Error 开头，后面的名字就是我们调用 Abort 的名字，例如 Error404 函数其实调用对应的就是 Abort("404")
我们就只要在 web.Run 之前采用 web.ErrorController 注册这个错误处理函数就可以了
1 | package main |
model设计
概述
beego ORM 是一个强大的 Go 语言 ORM 框架。她的灵感主要来自 Django ORM 和 SQLAlchemy。
目前该框架仍处于开发阶段，可能发生任何导致不兼容的改动。
已支持数据库驱动：
- MySQL：github.com/go-sql-driver/mysql
- PostgreSQL：github.com/lib/pq
- Sqlite3：github.com/mattn/go-sqlite3
ORM 特性：
- 支持 Go 的所有类型存储
- 轻松上手，采用简单的 CRUD 风格
- 自动 Join 关联表
- 跨数据库兼容查询
- 允许直接使用 SQL 查询／映射
- 严格完整的测试保证 ORM 的稳定与健壮
安装 ORM：
1 | go get github.com/beego/beego/v2/client/orm |
快速入门
简单示例
1 | package main |
关联查询
1 | type Post struct { |
SQL 查询
当您无法使用 ORM 来达到您的需求时，也可以直接使用 SQL 来完成查询／映射操作。
1 | var maps []orm.Params |
ORM使用
我们建议在使用过程中，一个数据库应该只存在一个ORM对象。
models.go
1 | package main |
main.go
1 | package main |
RegisterDriver
默认数据库类型
1 | orm.DRMySQL |
RegisterDataBase
ORM 必须注册一个别名为 default 的数据库，作为默认使用。
ORM 使用 golang 自己的连接池
1 | // 参数1 数据库的别名，用来在 ORM 中切换数据库使用 |
RegisterModel
将你定义的 Model 进行注册，最佳设计是有单独的 models.go 文件，在他的 init 函数中进行注册。
迷你版 models.go
1 | package main |
RegisterModel 也可以同时注册多个 model
1 | orm.RegisterModel(new(User), new(Profile), new(Post)) |
RegisterModelWithPrefix
使用表名前缀
1 | orm.RegisterModelWithPrefix("prefix_", new(User)) |
创建后的表名为 prefix_user
QueryTable
传入表名，或者 Model 对象，返回一个 QuerySeter
1 | o := orm.NewOrm() |
Raw
使用 sql 语句直接进行操作
Raw 函数，返回一个 RawSeter 用以对设置的 sql 语句和参数进行操作
1 | o := orm.NewOrm() |
CRUD 操作
如果已知主键的值，那么可以使用这些方法进行 CRUD 操作
对 object 操作的四个方法 Read / Insert / Update / Delete
1 | o := orm.NewOrm() |
Read
1 | o := orm.NewOrm() |
Read 默认通过查询主键赋值，可以使用指定的字段进行查询：
1 | user := User{Name: "slene"} |
ReadOrCreate
尝试从数据库读取，不存在的话就创建一个。
它的实现机制，和具体的数据库有关。例如在 MYSQL 中，是使用
默认必须传入一个参数作为条件字段，同时也支持多个参数多个条件字段
1 | o := orm.NewOrm() |
Insert
第一个返回值为自增健 Id 的值
1 | o := orm.NewOrm() |
创建后会自动对 auto 的 field 赋值
InsertMulti
同时插入多个对象
类似sql语句
1 | insert into table (name, age) values("slene", 28),("astaxie", 30),("unknown", 20) |
第一个参数 bulk 为并列插入的数量，第二个为对象的slice
返回值为成功插入的数量
1 | users := []User{ |
bulk 为 1 时，将会顺序插入 slice 中的数据
Update
第一个返回值为影响的行数
1 | o := orm.NewOrm() |
Update 默认更新所有的字段，可以更新指定的字段：
1 | // 只更新 Name |
根据复杂条件更新字段值参见 Update
Delete
第一个返回值为影响的行数
1 | o := orm.NewOrm() |
Delete 操作会对反向关系进行操作，此例中 Post 拥有一个到 User 的外键。删除 User 的时候。如果 on_delete 设置为默认的级联操作，将删除对应的 Post
Changed in 1.0.3 删除以后不会删除 auto field 的值
高级查询
ORM 以 QuerySeter 来组织查询，每个返回 QuerySeter 的方法都会获得一个新的 QuerySeter 对象。
基本使用方法:
1 | o := orm.NewOrm() |
expr
QuerySeter 中用于描述字段和 sql 操作符，使用简单的 expr 查询方法
字段组合的前后顺序依照表的关系，比如 User 表拥有 Profile 的外键，那么对 User 表查询对应的 Profile.Age 为条件，则使用 Profile__Age 注意，字段的分隔符号使用双下划线 __，除了描述字段， expr 的尾部可以增加操作符以执行对应的 sql 操作。比如 Profile__Age__gt 代表 Profile.Age > 18 的条件查询。
注释后面将描述对应的 sql 语句，仅仅是描述 expr 的类似结果，并不代表实际生成的语句。
1 | qs.Filter("id", 1) // WHERE id = 1 |
Operators
当前支持的操作符号：
- exact / iexact 等于
- contains / icontains 包含
- [gt / gte](#gt / gte) 大于 / 大于等于
- [lt / lte](#lt / lte) 小于 / 小于等于
- startswith / istartswith 以…起始
- endswith / iendswith 以…结束
- in
- isnull
后面以 i 开头的表示：大小写不敏感
exact
Filter / Exclude / Condition expr 的默认值
1 | qs.Filter("name", "slene") // WHERE name = 'slene' |
iexact
1 | qs.Filter("name__iexact", "slene") |
contains
1 | qs.Filter("name__contains", "slene") |
icontains
1 | qs.Filter("name__icontains", "slene") |
in
1 | qs.Filter("age__in", 17, 18, 19, 20) |
gt / gte
1 | qs.Filter("profile__age__gt", 17) |
lt / lte
1 | qs.Filter("profile__age__lt", 17) |
startswith
1 | qs.Filter("name__startswith", "slene") |
istartswith
1 | qs.Filter("name__istartswith", "slene") |
endswith
1 | qs.Filter("name__endswith", "slene") |
iendswith
1 | qs.Filter("name__iendswithi", "slene") |
isnull
1 | qs.Filter("profile__isnull", true) |
Filter
用来过滤查询结果，起到 包含条件 的作用
多个 Filter 之间使用 AND 连接
1 | qs.Filter("profile__isnull", true).Filter("name", "slene") |
Exclude
用来过滤查询结果，起到 排除条件 的作用
使用 NOT 排除条件
多个 Exclude 之间使用 AND 连接
1 | qs.Exclude("profile__isnull", true).Filter("name", "slene") |
SetCond
自定义条件表达式
1 | cond := orm.NewCondition() |
Limit
限制最大返回数据行数，第二个参数可以设置 Offset
1 | var DefaultRowsLimit = 1000 // ORM 默认的 limit 值为 1000 |
Offset
设置 偏移行数
1 | qs.Offset(20) |
GroupBy
1 | qs.GroupBy("id", "age") |
OrderBy
参数使用 expr
在 expr 前使用减号 - 表示 DESC 的排列
1 | qs.OrderBy("id", "-profile__age") |
Distinct
对应 sql 的 distinct 语句, 返回指定字段不重复的值.
1 | qs.Distinct() |
RelatedSel
关系查询，参数使用 expr
1 | var DefaultRelsDepth = 5 // 默认情况下直接调用 RelatedSel 将进行最大 5 层的关系查询 |
Count
依据当前的查询条件，返回结果行数
1 | cnt, err := o.QueryTable("user").Count() // SELECT COUNT(*) FROM USER |
Exist
1 | exist := o.QueryTable("user").Filter("UserName", "Name").Exist() |
Update
依据当前查询条件，进行批量更新操作
1 | num, err := o.QueryTable("user").Filter("name", "slene").Update(orm.Params{ |
原子操作增加字段值
1 | // 假设 user struct 里有一个 nums int 字段 |
orm.ColValue 支持以下操作
1 | ColAdd // 加 |
Delete
依据当前查询条件，进行批量删除操作
1 | num, err := o.QueryTable("user").Filter("name", "slene").Delete() |
PrepareInsert
用于一次 prepare 多次 insert 插入，以提高批量插入的速度。
1 | var users []*User |
All
返回对应的结果集对象
All 的参数支持 *[]Type 和 *[]*Type 两种形式的 slice
1 | var users []*User |
All / Values / ValuesList / ValuesFlat 受到 Limit 的限制，默认最大行数为 1000
可以指定返回的字段：
1 | type Post struct { |
对象的其他字段值将会是对应类型的默认值
One
尝试返回单条记录
1 | var user User |
可以指定返回的字段：
1 | // 只返回 Id 和 Title |
对象的其他字段值将会是对应类型的默认值
Values
返回结果集的 key => value 值
key 为Model里的Field name, value的值是interface{}类型,例如，如果你要将value赋值给struct中的某字段，需要根据结构体对应字段类型使用断言获取真实值。举例:Name : m["Name"].(string)
1 | var maps []orm.Params |
返回指定的 Field 数据
TODO: 暂不支持级联查询 RelatedSel 直接返回 Values
但可以直接指定 expr 级联返回需要的数据
1 | var maps []orm.Params |
ValuesList
顾名思义，返回的结果集以slice存储
结果的排列与 Model 中定义的 Field 顺序一致
返回的每个元素值以 string 保存
1 | var lists []orm.ParamsList |
当然也可以指定 expr 返回指定的 Field
1 | var lists []orm.ParamsList |
ValuesFlat
只返回特定的 Field 值，将结果集展开到单个 slice 里
1 | var list orm.ParamsList |
关系查询
User 和 Profile 是 OneToOne 的关系
已经取得了 User 对象，查询 Profile：
1 | user := &User{Id: 1} |
直接关联查询：
1 | user := &User{} |
通过 User 反向查询 Profile：
1 | var profile Profile |
Post 和 User 是 ManyToOne 关系，也就是 ForeignKey 为 User
1 | type Post struct { |
根据 Post.Title 查询对应的 User：
RegisterModel 时，ORM 也会自动建立 User 中 Post 的反向关系，所以可以直接进行查询
1 | var user User |
Post 和 Tag 是 ManyToMany 关系
设置 rel(m2m) 以后，ORM 会自动创建中间表
1 | type Post struct { |
一条 Post 纪录可能对应不同的 Tag 纪录,一条 Tag 纪录可能对应不同的 Post 纪录，所以 Post 和 Tag 属于多对多关系,通过 tag name 查询哪些 post 使用了这个 tag
1 | var posts []*Post |
通过 post title 查询这个 post 有哪些 tag
1 | var tags []*Tag |
载入关系字段
LoadRelated 用于载入模型的关系字段，包括所有的 rel/reverse - one/many 关系
ManyToMany 关系字段载入
1 | // 载入相应的 Tags |
User 是 Post 的 ForeignKey，对应的 ReverseMany 关系字段载入
1 | type User struct { |
多对多关系操作
- type QueryM2Mer interface {
- }
创建一个 QueryM2Mer 对象
1 | o := orm.NewOrm() |
QueryM2Mer Add
1 | tag := &Tag{Name: "golang"} |
Add 支持多种类型 Tag *Tag []*Tag []Tag []interface{}
1 | var tags []*Tag |
QueryM2Mer Remove
从M2M关系中删除 tag
Remove 支持多种类型 Tag *Tag []*Tag []Tag []interface{}
1 | var tags []*Tag |
QueryM2Mer Exist
判断 Tag 是否存在于 M2M 关系中
1 | if m2m.Exist(&Tag{Id: 2}) { |
QueryM2Mer Clear
清除所有 M2M 关系
1 | nums, err := m2m.Clear() |
QueryM2Mer Count
计算 Tag 的数量
1 | nums, err := m2m.Count() |
原生 SQL 查询
- 使用 Raw SQL 查询，无需使用 ORM 表定义
- 多数据库，都可直接使用占位符号
?，自动转换 - 查询时的参数，支持使用 Model Struct 和 Slice, Array
1 | o := orm.NewOrm() |
创建一个 RawSeter
1 | o := orm.NewOrm() |
Exec
执行 sql 语句，返回 sql.Result 对象
1 | res, err := o.Raw("UPDATE user SET name = ?", "your").Exec() |
QueryRow
QueryRow 和 QueryRows 提供高级 sql mapper 功能
支持 struct
1 | type User struct { |
QueryRows
QueryRows 支持的对象还有 map 规则是和 QueryRow 一样的，但都是 slice
1 | type User struct { |
SetArgs
改变 Raw(sql, args…) 中的 args 参数，返回一个新的 RawSeter
用于单条 sql 语句，重复利用，替换参数然后执行。
1 | res, err := r.SetArgs("arg1", "arg2").Exec() |
Values / ValuesList / ValuesFlat
Raw SQL 查询获得的结果集 Value 为 string 类型，NULL 字段的值为空 ``
Values
返回结果集的 key => value 值
1 | var maps []orm.Params |
ValuesList
返回结果集 slice
1 | var lists []orm.ParamsList |
ValuesFlat
返回单一字段的平铺 slice 数据
1 | var list orm.ParamsList |
RowsToMap
SQL 查询结果是这样
| name | value |
|---|---|
| total | 100 |
| found | 200 |
查询结果匹配到 map 里
1 | res := make(orm.Params) |
RowsToStruct
SQL 查询结果是这样
| name | value |
|---|---|
| total | 100 |
| found | 200 |
查询结果匹配到 struct 里
1 | type Options struct { |
匹配支持的名称转换为 snake -> camel, eg: SELECT user_name … 需要你的 struct 中定义有 UserName
Prepare
用于一次 prepare 多次 exec，以提高批量执行的速度。
1 | p, err := o.Raw("UPDATE user SET name = ? WHERE name = ?").Prepare() |
构造查询
QueryBuilder 提供了一个简便，流畅的 SQL 查询构造器。在不影响代码可读性的前提下用来快速的建立 SQL 语句。
QueryBuilder 在功能上与 ORM 重合， 但是各有利弊。ORM 更适用于简单的 CRUD 操作，而 QueryBuilder 则更适用于复杂的查询，例如查询中包含子查询和多重联结。
使用方法:
1 | // User 包装了下面的查询结果 |
模型定义
复杂的模型定义不是必须的，此功能用作数据库数据转换和自动建表
默认的表名规则，使用驼峰转蛇形：
1 | AuthUser -> auth_user |
除了开头的大写字母以外，遇到大写会增加 _，原名称中的下划线保留。
自定义表名
实现接口TableNameI:
1 | type User struct { |
如果前缀设置为 prefix_ 那么表名为：prefix_auth_user
设置参数
1 | orm:"null;rel(fk)" |
多个设置间使用 ; 分隔，设置的值如果是多个，使用 , 分隔。
忽略字段
设置 - 即可忽略 struct 中的字段
1 | type User struct { |
auto
当 Field 类型为 int, int32, int64, uint, uint32, uint64 时，可以设置字段为自增健
- 当模型定义里没有主键时，符合上述类型且名称为
Id的 Field 将被视为自增健。
鉴于 go 目前的设计，即使使用了 uint64，但你也不能存储到他的最大值。依然会作为 int64 处理。
pk
设置为主键，适用于自定义其他类型为主键
null
数据库表默认为 NOT NULL，设置 null 代表 ALLOW NULL
1 | Name string `orm:"null"` |
index
为单个字段增加索引
1 | Name string `orm:"index"` |
unique
为单个字段增加 unique 键
1 | Name string `orm:"unique"` |
column
为字段设置 db 字段的名称
1 | Name string `orm:"column(user_name)"` |
size
string 类型字段默认为 varchar(255)
设置 size 以后，db type 将使用 varchar(size)
1 | Title string `orm:"size(60)"` |
digits / decimals
设置 float32, float64 类型的浮点精度
1 | Money float64 `orm:"digits(12);decimals(4)"` |
总长度 12 小数点后 4 位 eg: 99999999.9999
auto_now / auto_now_add
1 | Created time.Time `orm:"auto_now_add;type(datetime)"` |
- auto_now 每次 model 保存时都会对时间自动更新
- auto_now_add 第一次保存时才设置时间
对于批量的 update 此设置是不生效的
type
设置为 date 时，time.Time 字段的对应 db 类型使用 date
1 | Created time.Time `orm:"auto_now_add;type(date)"` |
设置为 datetime 时，time.Time 字段的对应 db 类型使用 datetime
1 | Created time.Time `orm:"auto_now_add;type(datetime)"` |
default
在 v2.x 里面，我们提供了默认值的Filter:
1 | import ( |
我们一个很重要的认识，是认为显式设置值才是更加优雅的实践，所以我们将默认值的功能做成了一种可选的filter实现。
Comment
为字段添加注释
1 | type User struct { |
注意: 注释中禁止包含引号
Precision
为datetime字段设置精度值位数，不同DB支持最大精度值位数也不一致。
type User struct {
…
Created time.Time orm:"type(datetime);precision(4)"
…
}
表关系设置
rel / reverse
RelOneToOne:
1 | type User struct { |
对应的反向关系 RelReverseOne:
1 | type Profile struct { |
RelForeignKey:
1 | type Post struct { |
对应的反向关系 RelReverseMany:
1 | type User struct { |
RelManyToMany:
1 | type Post struct { |
对应的反向关系 RelReverseMany:
1 | type Tag struct { |
rel_table / rel_through
此设置针对 orm:"rel(m2m)" 的关系字段
1 | rel_table 设置自动生成的 m2m 关系表的名称 |
当设置 rel_table 时会忽略 rel_through
设置方法：
1 | orm:"rel(m2m);rel_table(the_table_name)" |
on_delete
设置对应的 rel 关系删除时，如何处理关系字段。
1 | cascade 级联删除(默认值) |
关于 on_delete 的相关例子
1 | type User struct { |
假设 Post -> User 是 ManyToOne 的关系，也就是外键。
1 | o.Filter("Id", 1).Delete() |
这个时候即会删除 Id 为 1 的 User 也会删除其发布的 Post
不想删除的话，需要设置 set_null
1 | type Post struct { |
那这个时候，删除 User 只会把对应的 Post.user_id 设置为 NULL
当然有时候为了高性能的需要，多存点数据无所谓啊，造成批量删除才是问题。
1 | type Post struct { |
那么只要删除的时候，不操作 Post 就可以了。
模型字段与数据库类型的对应
在此列出 ORM 推荐的对应数据库类型，自动建表功能也会以此为标准。
默认所有的字段都是 NOT NULL
MySQL
| go | mysql |
|---|---|
int, int32 - 设置 auto 或者名称为 Id 时 |
integer AUTO_INCREMENT |
int64 - 设置 auto 或者名称为 Id 时 |
bigint AUTO_INCREMENT |
uint, uint32 - 设置 auto 或者名称为 Id 时 |
integer unsigned AUTO_INCREMENT |
uint64 - 设置 auto 或者名称为 Id 时 |
bigint unsigned AUTO_INCREMENT |
| bool | bool |
| string - 默认为 size 255 | varchar(size) |
| string - 设置 type(char) 时 | char(size) |
| string - 设置 type(text) 时 | longtext |
| time.Time - 设置 type 为 date 时 | date |
| time.Time | datetime |
| byte | tinyint unsigned |
| rune | integer |
| int | integer |
| int8 | tinyint |
| int16 | smallint |
| int32 | integer |
| int64 | bigint |
| uint | integer unsigned |
| uint8 | tinyint unsigned |
| uint16 | smallint unsigned |
| uint32 | integer unsigned |
| uint64 | bigint unsigned |
| float32 | double precision |
| float64 | double precision |
| float64 - 设置 digits, decimals 时 | numeric(digits, decimals) |
关系型字段
其字段类型取决于对应的主键。
- RelForeignKey
- RelOneToOne
- RelManyToMany
- RelReverseOne
- RelReverseMany
命令模式
注册模型与数据库以后，调用 RunCommand 执行 orm 命令。
1 | func main() { |
自动建表
1 | ./main orm syncdb -h |
使用 -force=1 可以 drop table 后再建表
使用 -v 可以查看执行的 sql 语句
在程序中直接调用自动建表：
1 | // 数据库别名 |
自动建表功能在非 force 模式下，是会自动创建新增加的字段的。也会创建新增加的索引。
对于改动过的旧字段，旧索引，需要用户自行进行处理。
打印建表SQL
1 | ./main orm sqlall -h |
默认使用别名为 default 的数据库。
view设计
模板语法指南
本文讲述 beego 中使用的模板语法，与 go 模板语法基本相同。
基本语法
go 统一使用了 {{` 和 `}} 作为左右标签，没有其他的标签符号。如果您想要修改为其它符号，可以参考 模板标签。
使用 . 来访问当前位置的上下文
使用 $ 来引用当前模板根级的上下文
使用 $var 来访问创建的变量
[more]
模板中支持的 go 语言符号
1 | {{"string"}} // 一般 string |
模板中的 pipeline
可以是上下文的变量输出，也可以是函数通过管道传递的返回值
1 | {{. | FuncA | FuncB | FuncC}} |
当 pipeline 的值等于:
- false 或 0
- nil 的指针或 interface
- 长度为 0 的 array, slice, map, string
那么这个 pipeline 被认为是空
if … else … end
1 | {{if pipeline}}{{end}} |
if 判断时，pipeline 为空时，相当于判断为 False
1 | this.Data["IsLogin"] = true |
支持嵌套的循环
1 | {{if .IsHome}} |
也可以使用 else if 进行
1 | {{if .IsHome}} |
range … end
1 | {{range pipeline}}{{.}}{{end}} |
pipeline 支持的类型为 array, slice, map, channel
range 循环内部的 . 改变为以上类型的子元素
对应的值长度为 0 时，range 不会执行，. 不会改变
1 | pages := []struct { |
使用 .Num 输出子元素的 Num 属性，使用 $. 引用模板中的根级上下文
1 | {{range .Pages}} |
使用创建的变量，在这里和 go 中的 range 用法是相同的。
1 | {{range $index, $elem := .Pages}} |
range 也支持 else
1 | {{range .Pages}} |
with … end
1 | {{with pipeline}}{{end}} |
with 用于重定向 pipeline
1 | {{with .Field.NestField.SubField}} |
也可以对变量赋值操作
1 | {{with $value := "My name is %s"}} |
with 也支持 else
1 | {{with pipeline}} |
define
define 可以用来定义自模板，可用于模块定义和模板嵌套
1 | {{define "loop"}} |
使用 template 调用模板
1 | <ul> |
template
1 | {{template "模板名" pipeline}} |
将对应的上下文 pipeline 传给模板，才可以在模板中调用
Beego 中支持直接载入文件模板
1 | {{template "path/to/head.html" .}} |
Beego 会依据你设置的模板路径读取 head.html
在模板中可以接着载入其他模板，对于模板的分模块处理很有用处
注释
允许多行文本注释，不允许嵌套
1 | {{/* comment content |
基本函数
变量可以使用符号 | 在函数间传递
1 | {{.Con | markdown | addlinks}} |
使用括号
1 | {{printf "nums is %s %d" (printf "%d %d" 1 2) 3}} |
and
1 | {{and .X .Y .Z}} |
and 会逐一判断每个参数，将返回第一个为空的参数，否则就返回最后一个非空参数
call
1 | {{call .Field.Func .Arg1 .Arg2}} |
call 可以调用函数，并传入参数
调用的函数需要返回 1 个值 或者 2 个值，返回两个值时，第二个值用于返回 error 类型的错误。返回的错误不等于 nil 时，执行将终止。
index
index 支持 map, slice, array, string，读取指定类型对应下标的值
1 | this.Data["Maps"] = map[string]string{"name": "Beego"} |
len
1 | {{printf "The content length is %d" (.Content|len)}} |
返回对应类型的长度，支持类型：map, slice, array, string, chan
not
not 返回输入参数的否定值，if true then false else true
or
1 | {{or .X .Y .Z}} |
or 会逐一判断每个参数，将返回第一个非空的参数，否则就返回最后一个参数
对应 fmt.Sprint
printf
对应 fmt.Sprintf
println
对应 fmt.Sprintln
urlquery
1 | {{urlquery "http://beego.vip"}} |
将返回
1 | http%3A%2F%2Fbeego.vip |
eq / ne / lt / le / gt / ge
这类函数一般配合在 if 中使用
eq: arg1 == arg2ne: arg1 != arg2lt: arg1 < arg2le: arg1 <= arg2gt: arg1 > arg2ge: arg1 >= arg2
eq 和其他函数不一样的地方是，支持多个参数，和下面的逻辑判断相同
1 | arg1==arg2 || arg1==arg3 || arg1==arg4 ... |
与 if 一起使用
1 | {{if eq true .Var1 .Var2 .Var3}}{{end}} |
模板处理
beego 的模板处理引擎采用的是 Go 内置的 html/template 包进行处理，而且 beego 的模板处理逻辑是采用了缓存编译方式，也就是所有的模板会在 beego 应用启动的时候全部编译然后缓存在 map 里面。
模板目录
beego 中默认的模板目录是 views，用户可以把模板文件放到该目录下，beego 会自动在该目录下的所有模板文件进行解析并缓存，开发模式下每次都会重新解析，不做缓存。当然，用户也可以通过如下的方式改变模板的目录（只能指定一个目录为模板目录）：
1 | beego.ViewsPath = "myviewpath" |
自动渲染
用户无需手动的调用渲染输出模板，beego 会自动的在调用完相应的 method 方法之后调用 Render 函数，当然如果您的应用是不需要模板输出的，那么可以在配置文件或者在 main.go 中设置关闭自动渲染。
配置文件配置如下：
1 | autorender = false |
main.go 文件中设置如下：
1 | web.AutoRender = false |
模板标签
Go 语言的默认模板采用了 {{` 和 `}} 作为左右标签，但是我们有时候在开发中可能界面是采用了 AngularJS 开发，他的模板也是这个标签，故而引起了冲突。在 beego 中你可以通过配置文件或者直接设置配置变量修改：
1 | web.TemplateLeft = "<<<" |
模板数据
模板中的数据是通过在 Controller 中 this.Data 获取的，所以如果你想在模板中获取内容 {{.Content}} ,那么你需要在 Controller 中如下设置：
1 | this.Data["Content"] = "value" |
如何使用各种类型的数据渲染：
- 结构体数据渲染
1 | 结构体： |
- 数组数据渲染
1 | lista := [5]int{1,2,3,4,5} |
- 结构体数组渲染
1 | 结构体： |
- map数据渲染
1 | //teacher :=map[string]string{"name":"张三","age":"18"} |
- 结构体和map组合渲染
1 | 结构体： |
- 切片数据渲染
1 | listb := []int{1,2,3,4,5,6,7} |
模板名称
beego 采用了 Go 语言内置的模板引擎，所有模板的语法和 Go 的一模一样，至于如何写模板文件，详细的请参考 模板教程。
用户通过在 Controller 的对应方法中设置相应的模板名称，beego 会自动的在 viewpath 目录下查询该文件并渲染，例如下面的设置，beego 会在 admin 下面找 add.tpl 文件进行渲染：
1 | this.TplName = "admin/add.tpl" |
我们看到上面的模板后缀名是 tpl，beego 默认情况下支持 tpl 和 html 后缀名的模板文件，如果你的后缀名不是这两种，请进行如下设置：
1 | web.AddTemplateExt("你文件的后缀名") |
当你设置了自动渲染，然后在你的 Controller 中没有设置任何的 TplName，那么 beego 会自动设置你的模板文件如下：
1 | c.TplName = strings.ToLower(c.controllerName) + "/" + strings.ToLower(c.actionName) + "." + c.TplExt |
也就是你对应的 Controller 名字+请求方法名.模板后缀，也就是如果你的 Controller 名是 AddController，请求方法是 POST，默认的文件后缀是 tpl，那么就会默认请求 /viewpath/AddController/post.tpl 文件。
Layout 设计
beego 支持 layout 设计，例如你在管理系统中，整个管理界面是固定的，只会变化中间的部分，那么你可以通过如下的设置：
1 | this.Layout = "admin/layout.html" |
在 layout.html 中你必须设置如下的变量：
1 | {{.LayoutContent}} |
beego 就会首先解析 TplName 指定的文件，获取内容赋值给 LayoutContent，然后最后渲染 layout.html 文件。
目前采用首先把目录下所有的文件进行缓存，所以用户还可以通过类似这样的方式实现 layout：
1 | {{template "header.html" .}} |
特别注意后面的
.,这是传递当前参数到子模板
LayoutSection
对于一个复杂的 LayoutContent，其中可能包括有javascript脚本、CSS 引用等，根据惯例，通常 css 会放到 Head 元素中，javascript 脚本需要放到 body 元素的末尾，而其它内容则根据需要放在合适的位置。在 Layout 页中仅有一个 LayoutContent 是不够的。所以在 Controller 中增加了一个 LayoutSections属性，可以允许 Layout 页中设置多个 section，然后每个 section 可以分别包含各自的子模板页。
layout_blog.tpl:
1 |
|
html_head.tpl:
1 | <style> |
scripts.tpl：
1 | <script type="text/javascript"> |
逻辑处理如下所示：
1 | type BlogsController struct { |
renderform 使用
定义 struct:
1 | type User struct { |
- StructTag 的定义用的标签用为
form，和 ParseForm 方法 共用一个标签，标签后面有三个可选参数，用,分割。第一个参数为表单中类型的name的值，如果为空，则以struct field name为值。第二个参数为表单组件的类型，如果为空，则为text。表单组件的标签默认为struct field name的值，否则为第三个值。 - 如果
form标签只有一个值，则为表单中类型name的值，除了最后一个值可以忽略外，其他位置的必须要有,号分割，如：form:",,姓名：" - 如果要忽略一个字段，有两种办法，一是：字段名小写开头，二是：
form标签的值设置为- - 现在的代码版本只能实现固定的格式，用 br 标签实现换行，无法实现 css 和 class 等代码的插入。所以，要实现 form 的高级排版，不能使用 renderform 的方法，而需要手动处理每一个字段。
controller：
1 | func (this *AddController) Get() { |
Form 的参数必须是一个 struct 的指针。
template:
1 | <form action="" method="post"> |
上面的代码生成的表单为：
1 | Name: <input name="username" type="text" value="test"></br> |
模板函数
beego 支持用户定义模板函数，但是必须在 web.Run() 调用之前，设置如下：
1 | func hello(in string)(out string){ |
定义之后你就可以在模板中这样使用了：
1 | {{.Content | hi}} |
目前 beego 内置的模板函数如下所示：
dateformat
实现了时间的格式化，返回字符串，使用方法
{{dateformat .Time "2006-01-02T15:04:05Z07:00"}}。date
实现了类似 PHP 的 date 函数，可以很方便的根据字符串返回时间，使用方法
{{date .T "Y-m-d H:i:s"}}。compare
实现了比较两个对象的比较，如果相同返回 true，否者 false，使用方法
{{compare .A .B}}。substr
实现了字符串的截取，支持中文截取的完美截取，使用方法
{{substr .Str 0 30}}。html2str
实现了把 html 转化为字符串，剔除一些 script、css 之类的元素，返回纯文本信息，使用方法
{{html2str .Htmlinfo}}。str2html
实现了把相应的字符串当作 HTML 来输出，不转义，使用方法
{{str2html .Strhtml}}。htmlquote
实现了基本的 html 字符转义，使用方法
{{htmlquote .quote}}。htmlunquote
实现了基本的反转移字符，使用方法
{{htmlunquote .unquote}}。renderform
根据 StructTag 直接生成对应的表单，使用方法
{{&struct | renderform}}。assets_js
为 js 文件生成一个
<script>标签. 使用方法{{assets_js src}}assets_css
为 css 文件生成一个
<link>标签. 使用方法{{assets_css src}}config
获取 AppConfig 的值. 使用方法 {
{config configType configKey defaultValue}}. 可选的 configType 有 String, Bool, Int, Int64, Float, DIYmap_get
获取
map的值用法:
1
2
3
4
5
6
7
8
9
10
11// In controller
Data["m"] = map[string]interface{} {
"a": 1,
"1": map[string]float64{
"c": 4,
},
}
// In view
{{ map_get .m "a" }} // return 1
{{ map_get .m 1 "c" }} // return 4urlfor
获取控制器方法的 URL
1
{{urlfor "TestController.List"}}
静态文件处理
Go 语言内部其实已经提供了 http.ServeFile，通过这个函数可以实现静态文件的服务。beego 针对这个功能进行了一层封装，通过下面的方式进行静态文件注册：
1 | web.SetStaticPath("/static","public") |
- 第一个参数是路径，url 路径信息
- 第二个参数是静态文件目录（相对应用所在的目录）
beego 支持多个目录的静态文件注册，用户可以注册如下的静态文件目录：
1 | web.SetStaticPath("/images","images") |
设置了如上的静态目录之后，用户访问 /images/login/login.png，那么就会访问应用对应的目录下面的 images/login/login.png 文件。如果是访问 /static/img/logo.png，那么就访问 public/img/logo.png文件。
默认情况下 beego 会判断目录下文件是否存在，不存在直接返回 404 页面，如果请求的是 index.html，那么由于 http.ServeFile 默认是会跳转的，不提供该页面的显示。因此 beego 可以设置 web.BConfig.WebConfig.DirectoryIndex=true 这样来使得显示 index.html 页面。而且开启该功能之后，用户访问目录就会显示该目录下所有的文件列表。
微信
支付宝
