beego框架之控制器、模型、视图
作者：互联网
一、beego框架
是go语言开发的web框架，也是HTTP框架。是MVC框架
M：Model，模型，数据库操作，增删改查
V：View，视图，接收客户端的数据，组织html界面
C：Controller,控制器，接收数据，数据处理。传输数据给M和V并接收应答，返回应答给浏览器
二、环境安装
需要安装或升级beego和Bee的开发工具
$ go get -u github.com/astaxie/beego $ go get -u github.com/beego/bee
为了更加方便的操作，请将 $GOPATH/bin 加入到你的 $PATH 变量中。请确保在此之前您已经添加了 $GOPATH 变量。
# 如果您还没添加 $GOPATH 变量 $ echo 'export GOPATH="$HOME/go"' >> ~/.profile # 或者 ~/.zshrc, ~/.cshrc, 您所使用的sh对应的配置文件 # 如果您已经添加了 $GOPATH 变量 $ echo 'export PATH="$GOPATH/bin:$PATH"' >> ~/.profile # 或者 ~/.zshrc, ~/.cshrc, 您所使用的sh对应的配置文件 $ exec $SHELL
检测安装
$ cd $GOPATH/src $ bee new hello $ cd hello $ bee run #Windows平台输入 >cd %GOPATH%/src >bee new hello #创建一个项目，并放到src下 >cd hello >bee run
之后：程序开始运行，您就可以在浏览器中打开 http://localhost:8080/ 进行访问。
补充：创建包含视图的项目bee new 项目名字。如果只创造api项目接口文件，则把上面的bee api 项目名字
然后进入src目录发现项目里面会生成如下文件夹
三、程序流程分析
1、项目根路径里面的main.go，这是项目的入口，里面导入了两个包，有一个引入了routers的包，（包前面有一个"_",表名引入了此包，并执行init方法，此时就去router里面的init方法）
2、之后在routers文件夹下，有router.go文件。
3、执行完init方法，之后就是在main.go里面执行init方法，执行beego.run()方法，里面的路由，然后执行MainController方法
四、路由配置
在routers文件夹下创建路由文件：.go文件
1、基础路由:包含get,post,head,options,delete等方法
package routers
import (
"github.com/astaxie/beego"
"github.com/astaxie/beego/context"
)
func init() {
//基础路由get方法
beego.Get(rootpath:"/get",func(context *context.Context){
context.Info(v:"基础路由之get方法") //设置信息
context.Output.Body([]byte("基础路由之get方法 get method")) //打印到前端页面
})
beego.Get(rootpath:"/get",func(context *context.Context){
context.Info(v:"获取用户请求")
context.Output.Body([]byte("获取用户请求"))
//基础路由之post方法
beego.Post(rootpath:"/post",func(context *context.Context){
context.Info(v:"基础路由之Post方法") //设置信息
context.Output.Body([]byte("基础路由之Post方法d")) //打印到前端页面
})
//delete方法
beego.Delete(rootpath:"/delete",func(context *context.Context){
context.Info(v:"基础路由之delete方法") //设置信息
context.ResponseWriter.Write([]byte("基础路由之delete方法d")) //打印到前端页面
})
//head方法
beego.Head(rootpath:"/head",func(context *context.Context){
context.Info(v:"基础路由之head方法") //设置信息
})
}
2、固定路由：同上，现在router文件夹里面，然后再去controller里面新建自己的固定路由MainContrl.go
#router
package routers
import (
"github.com/astaxie/beego"
)
func init() {
//固定路由get方法
beego.Router(rootpath:"/get", &controller.MainController{})
//固定路由Post方法
beego.Router(rootpath:"/post", &controller.MainController{}) #执行MainController方法
//固定路由delete方法
beego.Router(rootpath:"/delete", &controller.MainController{})
//固定路由options方法
beego.Router(rootpath:"/options", &controller.MainController{})
}
#controller
package controllers
import (
"github.com/astaxie/beego"
)
type MainController struct {
beego.Controller
}
//固定路由的get方法
func (this *MainController) Get() {
beego.Info(v:"固定路由get方法")
this.Ctx.Output.Body([]byte("固定路由get方法"))
}
//其他固定方法同理
3、正则路由：通固定路由配置方式
#router
package routers
import (
"github.com/astaxie/beego"
)
func init() {
//*代表全匹配
beego.Router(rootpath:"/*", &controller.MainController{})
//:id变量匹配，冒号声明表示变量
beego.Router(rootpath:"/getUser/:id", &controller.MainController{})
//自定义正则匹配表达式
// /getUser/davie1
beego.Router(rootpath:"/getUser/:name([0-9]+)", &controller.MainController{})
//*.*匹配
//http://localhost:8080/upload/file/img/helloword.png
beego.Router(rootpath:"/upload/*.*", &controller.MainController{})
//int类型
beego.Router(rootpath:"/getUserInfo/:id:int", &controller.MainController{})
//string类型
beego.Router(rootpath:"/getUser/:username:string", &controller.MainController{})
}
#controller
package controllers
import (
"github.com/astaxie/beego"
)
type MainController struct {
beego.Controller
}
//固定路由的get方法
func (this *MainController) Get() {
//*全匹配
beego.Info(v:"*全匹配")
this.Ctx.Output.Body([]byte("*方法"))
//变量匹配
id := this.Ctx.Input.Param(key:":id") //接收
beego.Info(v:"ID匹配")
this.Ctx.ResponseWriter.Write([]byte("id方法"))
//*.*获取文件后缀名
path := this.Ctx.Input.Param(key:":path")
beego.Info(path)
ext := this.Ctx.Input.Param(key:":ext") //获取后缀名
beego.Info(ext)
this.Ctx.ResponseWriter.Write([]byte(path,ext))
}
//其他固定方法同理
4、自定义路由
#routers
package routers
import (
"github.com/astaxie/beego"
)
func init() {
//获取用户信息
//get
beego.Router(rootpath:"/getUserInfo*", &controller.CustomController{},mappingMethod:"GET:GetUserInfo")
//POST
beego.Router(rootpath:"/registerInfo*", &controller.CustomController{},mappingMethod:"POST:RegisterInfo")
}
#controller
package controllers
import (
"github.com/astaxie/beego"
)
type CustomController struct {
beego.Controller
}
//自定义路由的get方法
func (this *CustomController) GetUserInfo() {
//GetUserInfo()方法
beego.Info(v:"获取用户信息")
username := this.GetString(key:"username")
userid := this.GetString(key:"userid")
this.Ctx.Output.Body([]byte("自定义路由方法"))
}
//其他固定方法同理
五、cookie和session
设置cookie:
1.设置Cookie,参数一为Cookie名称,参数二为Cookie值,参数三为Cookie的存活时间，单位秒。(如果不设置时间，Cookie只在本次回话有效，Beego默认存活3600秒。)
2.设置Cookie是不能存在中文，如果存在中文虽然可以设置成功，但是不能取出.
this.Ctx.SetCookie("username", "admin",10)
取出cookie：
this.Ctx.GetCookie("username")
删除cookie：
beego中并没有删除Cookie的函数，但是我们可通过SetCookie把Cookie设为空值，即可达成删除的效果。
代码演示：
package controllers
import "github.com/astaxie/beego"
type CookieController struct {
beego.Controller
}
func (this *CookieController)Get() {
if this.Ctx.GetCookie("user") ==""{
this.Ctx.SetCookie("user","admin")
this.Ctx.WriteString("Cookie设置成功")
}else{
user:= this.Ctx.GetCookie("user")
this.Ctx.WriteString("user="+user)
}
}
设置session
1.开启session两种方式
1.在main 入口函数中添加代码 beego.BConfig.WebConfig.Session.SessionOn = true 2. 在app.conf配置文件开启 sessionon=true
2.设置session
Session: this.SetSession("username", "admin")
代码演示
package controllers
import "github.com/astaxie/beego"
type SessionController struct {
beego.Controller
}
func (this *SessionController) Get() {
if this.GetSession("user") == nil {
this.SetSession("user", "admin")
this.Ctx.WriteString("Session设置成功!")
}else {
//获取session
username := this.GetSession("user")
fmt.Println("sessionid = ", this.CruSession.SessionID())
this.Ctx.WriteString("user = " + username.(string))
}
}
3.删除session
this.DelSession("username")和this.DestroySession()均可删除Session，其区别在于DelSession删除指定Session,而DestroySession删除全session。
代码演示
func (this *SessionController) GetDelSession() {
//DelSession和DestroySession的区别
this.SetSession("username", "admin")
this.SetSession("password", "123")
//根据传递的session名称删除指定session
//this.DelSession("username")
//删除所有session
this.DestroySession()
username := this.GetSession("username")
password := this.GetSession("password")
if username != nil {
fmt.Println("username = ", username)
}
if password != nil {
fmt.Println("password = ", password)
}
this.Ctx.WriteString("删除完毕")
}
4.设置session存活时间
在主函数入口文件
beego.BConfig.WebConfig.Session.SessionGCMaxLifetime =1000
六、控制器controller
1控制器之controller
简单写一个控制器
定义一个控制器结构体，一般一个模块定义一个控制器
import (
"github.com/astaxie/beego"
)
//定义结构体
type MainController struct {
// 嵌套 beego 基础控制器，在 go 语言中嵌套 struct，类似继承的概念。
// 这里就相当于，继承了 beego.Controller 的方法和属性。
beego.Controller
}
// 覆盖beego.Controller的Get方法，用于处理 RESTful 请求中的 get 请求
// beego.Controller 默认支持多种 RESTful方法，例如：Post、Put、Delete等
func (c *MainController) Get() {
// Data是继承过来的属性，是 map 类型，可以保存任意类型数据，主要用于保存请求响应数据
// 我们可以通过 Data 将参数，传入视图模板文件。
// 这里设置了两个参数
c.Data["Website"] = "codebaoku.com"
c.Data["Email"] = "go@codebaoku.com"
// 设置需要渲染的模板文件，框架会去 views 目录查找这个模板文件
c.TplName = "index.tpl"
}
2、控制器函数
控制器函数是 beego的 RESTful api 的实现方式，在 beego 的设计中，控制器就是一个嵌套了beego.Controller的结构体对象。
函数：
代码实例：
type UserController struct {
// 嵌套beego基础控制器
beego.Controller
}
// 在调用其他控制器函数之前，会优先调用Prepare函数
func (this *UserController) Prepare() {
// 可以进行初始化工作
//如果这里有权限验证，也可以放置权限认证逻辑在这里
//假如验证不通过
this.Data["json"] = map[string]interface{}{"error":"没有权限", "errno":401}
this.ServeJSON()
this.StopRun() //注意：调用 StopRun 之后，不会再执行Finish函数，如果有需要可以在调用StopRun之后，手动调用Finish函数。
}
// 处理get请求
func (this *UserController) Get() {
// 处理逻辑
}
// 处理post请求
func (this *UserController) Post() {
// 处理逻辑
}
//其他函数也是如此
3、获取返回参数
3.1常见定义参数
代码实例：
// 处理get请求
func (this *UserController) Get() {
// 获取参数, 返回int类型
id ,_:= this.GetInt("id")
// 获取参数，返回string类型, 如果参数不存在返回none作为默认值
username := this.GetString("username", "none")
// 获取参数，返回float类型, 参数不存在则返回 0
num, _ := this.GetFloat("num", 0)
}
3.2绑定结构体方式
针对POST请求的表单数据，beego支持直接将表单数据绑定到一个struct变量。
代码：
// 定义一个struct用来保存表单数据
// 通过给字段设置tag， 指定表单字段名， - 表示忽略这个字段不进行赋值
// 默认情况下表单字段名跟struct字段名同名（小写）
type UserForm struct {
// 忽略掉Id字段
Id int
// 表单字段名为username
Name string `form:"username"`
Phone string
}
//如果表单字段跟struct字段（小写）同名，不需要设置form标签。
控制器函数代码
func (this *UserController) Post() {
// 定义保存表单数据的struct对象
u := UserForm{}
// 通过ParseForm函数，将请求参数绑定到struct变量。
err := this.ParseForm(&u)
if err != nil {
// 绑定参数失败
}
}
3.3处理json数据参数
步骤：
1.在app.conf配置文件中，添加CopyRequestBody=true，
2.通过this.Ctx.Input.RequestBody获取请求body的内容
3.通过json.Unmarshal反序列化json字符串，将json参数绑定到struct变量。
代码演示
定义struct用于保存json数据
// 如果json字段跟struct字段名不一样，可以通过json标签设置json字段名
type UserForm struct {
// 忽略掉Id字段
Id int `json:"-"`
// json字段名为username
Name string `json:"username"`
Phone string
}
控制器函数
func (this *UserController) Post() {
// 定义保存json数据的struct对象
u := UserForm{}
// 获取body内容
body := this.Ctx.Input.RequestBody
// 反序列json数据，结果保存至u
if err := json.Unmarshal(body, &u); err == nil {
// 解析参数失败
}
}
4、响应数据
1.返回json数据
// 定义struct
// 如果struct字段名跟json字段名不一样，可以使用json标签,指定json字段名
type User struct {
// - 表示忽略id字段
Id int `json:"-"`
Username string `json:"name"`
Phone string
}
func (this *UserController) Get() {
// 定义需要返回给客户端的数据
user := User{1, "aaa", "123"}
// 将需要返回的数据赋值给json字段
this.Data["json"] = &user
// 将this.Data["json"]的数据，序列化成json字符串，然后返回给客户端
this.ServeJSON()
}
2.返回xml数据
// 定义struct
// 如果struct字段名跟xml字段名不一样，可以使用xml标签,指定xml字段名
type User struct {
// - 表示忽略id字段
Id int `xml:"-"`
Username string `xml:"name"`
Phone string
}
func (this *UserController) Get() {
// 定义需要返回给客户端的数据
user := User{1, "aaa", "123"}
// 将需要返回的数据赋值给xml字段
this.Data["xml"] = &user
// 将this.Data["xml"]的数据，序列化成xml字符串，然后返回给客户端
this.ServeXML()
}
3.返回jsonp数据（与返回json数据类似）
func (this *UserController) Get() {
// 定义需要返回给客户端的数据
user := User{1, "tizi365", "13089818901"}
// 将需要返回的数据赋值给jsonp字段
this.Data["jsonp"] = &user
// 将this.Data["json"]的数据，序列化成json字符串，然后返回给客户端
this.ServeJSONP()
}
4.返回html数据（一般用于网页开发，用于渲染html模板）
func (c *MainController) Get() {
// 设置模板参数
c.Data["Web"] = "aaa.com"
c.Data["Email"] = "aaa@demo.com"
// 需要渲染的模板， beego会渲染这个模板，然后返回结果
c.TplName = "index.tpl"
}
5.添加响应头
func (c *MainController) Get() {
// 通过this.Ctx.Output.Header设置响应头
this.Ctx.Output.Header("Content-Type", "aaa/http")
this.Ctx.Output.Header("Cache-Control", "no-store, must-revalidate")
}
七、模型models
负责操作所有数据和服务器进行交互，将请求到的数据传给 Controller。model 主要利用 ORM 进行数据库操作是指对象-关系映射，在 Go 语言中就是将 struct数据类型和数据库记录进行映射。
补充：go正常脚本操作数据库
package main
import (
"database/sql"
"fmt"
_"github.com/go-sql-driver/mysql" //导入数据库，且前面有“_”
)
func main() {
//打开数据库
db, err := sql.Open("mysql","root:123@tcp(127.0.0.1:3306)/test?charset=utf8")
if err != nil{
panic(err)
}
//增加数据的命令
stmr, err := db.Prepare("INSERT userinfo SET username=?,department=?,create_time=?") //输入SQL语句
//需要增加的数据
res, err := stmr.Exec("aaa","技术部","2011-01-09")
id, err := res.LastInsertId() //执行插入数据
if err != nil{
panic(err)
}
fmt.Println(id)
//修改数据
stmr, err := db.Prepare("UPDATE userinfo SET username=? where id=?") //输入SQL语句
//需要修改的数据
res, err := stmr.Exec("bbb",11)
id, err := res.RowsAffected() //执行命令
if err != nil{
panic(err)
}
fmt.Println(id)
//查询数据
rows, err := db.Query("SELECT * FROM user_info where id=11") //输入SQL语句
//需要修改的数据
if err != nil{
panic(err)
}
for rows.Next(){ //查询多行数据
var id int
var username string
var department string
var creat_time string
err = rows.Scan(&id, &username, &department, &creat_time)
fmt.Println(id,username,department,creat_time)
}
//删除数据
stmr, err := db.Prepare("DELETE FROM userinfo where id=?") //输入SQL语句
//需要删除的数据
res, err := stmr.Exec(id)
id, err := res.RowsAffected() //执行命令
if err != nil{
panic(err)
}
fmt.Println(id)
}
项目里面操作数据库
0、安装orm
go get github.com/astaxie/beego/orm go get github.com/Go-SQL-Driver/MySQL
1、链接数据库（在项目入口main.go里面配置）
package main
import (
_ "codebaoku/routers"
"github.com/astaxie/beego"
// 导入orm包
"github.com/astaxie/beego/orm"
// 导入mysql驱动
_ "github.com/go-sql-driver/mysql"
)
// 通过init函数配置mysql数据库连接信息
func init() {
// 这里注册一个default默认数据库，数据库驱动是mysql.
// 第三个参数是数据库dsn, 配置数据库的账号密码，数据库名等参数
// dsn参数说明：
// username - mysql账号
// password - mysql密码
// db_name - 数据库名
// 127.0.0.1:3306 - 数据库的地址和端口
orm.RegisterDataBase("default", "mysql", "username:password@tcp(127.0.0.1:3306)/db_name?charset=utf8&parseTime=true&loc=Local")
// 打开调试模式，开发的时候方便查看orm生成什么样子的sql语句
orm.Debug = true
}
func main() {
beego.Run()
}
2.orm操作通常都是围绕struct对象进行，我们先定义一个表结构，
CREATE TABLE `orders` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT COMMENT, `shop_id` int(10) unsigned NOT NULL COMMENT , `customer_id` int(10) unsigned NOT NULL COMMENT , `nickname` varchar(20) DEFAULT NULL COMMENT, `address` varchar(200) NOT NULL DEFAULT '' COMMENT, `init_time` datetime NOT NULL COMMENT , PRIMARY KEY (`id`) ) ENGINE=InnoDB DEFAULT CHARSET=utf8
定义模型：模型(Model)指的就是关联数据库表的struct类型。
// 默认情况struct字段名按照下面规则()转换成mysql表字段名：
// 规则: 以下滑线分割首字母大写的单词，然后转换成小写字母。
type Order struct {
// 对应表字段名为: id
Id int
// 对应表字段名为: shop_id , 下面字段名转换规则以此类推。
ShopId int
// struct字段名跟表字段名不一样，通过orm标签指定表字段名为customer_id
Uid int `orm:"column(customer_id)"`
Nickname string
Address string
// 数据库init_time字段是datetime类型，支持自动转换成Go的time.Time类型，但是数据库连接参数必须设置参数parseTime=true
InitTime time.Time
}
// 指定Order结构体默认绑定的表名
func (o *Order) TableName() string {
return "ok"
}
// 注册模型
orm.RegisterModel(new(Order))
3.插入数据
// 创建orm对象, 后面都是通过orm对象操作数据库
o := orm.NewOrm()
// 创建一个新的订单
order := []Order{
{ShopId:1, Uid:1001, Nickname:"1", Address:"北京市", InitTime: time.Now()},
{ShopId:1, Uid:1002, Nickname:"2", Address:"北京市", InitTime: time.Now()},
{ShopId:1, Uid:1003, Nickname:"3", Address:"北京市", InitTime: time.Now()},
}//插入多条数据
// 调用InsertMulti函数批量插入， 第一个参数指的是要插入多少数据
nums, err := o.InsertMulti(3, orders)
if err != nil {
fmt.Println("插入失败")
} else {
fmt.Println("新插入数据:", nums)
}
4.更新数据
orm的Update函数是根据主键id进行更新数据的，因此需要预先对id赋值。
o := orm.NewOrm()
// 需要更新的order对象
order := Order{}
// 先对主键id赋值, 更新数据的条件就是where id=2
order.Id = 2
// 对需要更新的数据进行赋值
order.Nickname = "1"
order.Address = "北京市"
// 调用Update函数更新数据, 默认Update根据struct字段，更新所有字段值，如果字段值为空也一样更新。
num, err := o.Update(&order)
if err != nil {
fmt.Println("更新失败")
} else {
fmt.Println("更新数据影响的行数:", num)
}
// 上面Update直接更新order结构体的所有字段，如果只想更新指定字段，
num, err := o.Update(&order, "Nickname", "Address")
// 这里只是更新Nickname和Address两个字段
5.查询数据
默认orm的Read函数也是通过主键id查询数据。
o := orm.NewOrm()
// 定义order
order := Order{}
// 先对主键id赋值, 查询数据的条件就是where id=2
order.Id = 2
// 通过Read函数查询数据
err := o.Read(&order)
if err == orm.ErrNoRows {
fmt.Println("查询不到")
} else if err == orm.ErrMissPK {
fmt.Println("找不到主键")
} else {
fmt.Println(order.Id, order.Nickname)
}
// 通过ReadOrCreate函数，先尝试根据主键id查询数据，如果数据不存在则插入一条数据
created, id, err := o.ReadOrCreate(&order, "Id")
// ReadOrCreate返回三个参数，第一个参数表示是否插入了一条数据，第二个参数表示插入的id
6.删除数据
o := orm.NewOrm()
// 定义order
order := Order{}
// 先对主键id赋值, 删除数据的条件就是where id=2
order.Id = 2
if num, err := o.Delete(&order); err != nil {
fmt.Println("删除失败")
} else {
fmt.Println("影响行数:", num)
}
数据库设置：
注册数据库的函数原型：
func RegisterDataBase(aliasName, driverName, dataSource string, params ...int) error
mysql数据库连接字符串DSN (Data Source Name)
username:password@protocol(address)/dbname?param=value
例子：
// 注册默认数据库，驱动为mysql, 第三个参数就是我们的数据库连接字符串。
orm.RegisterDataBase("default", "mysql", "root:123456@tcp(localhost:3306)/ccc?charset=utf8")
数据库高级查询之：QuerySeter 对象
// 创建orm对象
o := orm.NewOrm()
// 获取 QuerySeter 对象，并设置表名orders
qs := o.QueryTable("users")
// 定义保存查询结果的变量
var users []User
// 使用QuerySeter 对象构造查询条件，并执行查询。
num, err := qs.Filter("city", "chongqing"). // 设置查询条件
Filter("init_time__gt", "2022-06-28 22:00:00"). // 设置查询条件
Limit(10). // 限制返回行数
All(&users, "id", "username") // All 执行查询，并且返回结果，这里指定返回id和username字段，结果保存在users变量
// 上面代码的等价sql: SELECT T0.`id`, T0.`username` FROM `users` T0 WHERE T0.`city` = 'chongqing' AND T0.`init_time` > '2022-06-28 22:00:00' LIMIT 10
if err != nil {
panic(err)
}
fmt.Println("结果行数:", num)
数据库高级查询之：SQL
// 创建orm对象
o := orm.NewOrm()
// insert
// 使用Raw函数设置sql语句和参数
res, err := o.Raw("insert into users(username, password) values(?, ?)", "bbb", "123456").Exec()
// 插入数据的自增id
id := res.LastInsertId()
// update
res, err := o.Raw("update users set password=? where username=?", "654321", "bbb").Exec()
// 获取更新数据影响的行数
rows := res.RowsAffected()
// delete
o.Raw("delete from users where username=?", "bbb").Exec()
数据库高级查询之：事务
//手动事务
// 创建orm对象
o := orm.NewOrm()
// 开始事务
tx, err := o.Begin()
// 开始执行各种sql语句，更新数据库，这里可以使用beego orm支持任何一种方式操作数据库
// 更新
_, err1 := tx.QueryTable("orders").Filter("Id", 1001).Update(orm.Params{
"Status": "SUCCESS",
})
// 加分
_, err2 := tx.Raw("update users set points = points + ? where username=?", "bbb", 100).Exec()
// 检测事务执行状态
if err1 != nil || err2 != nil {
// 如果执行失败，回滚事务
tx.Rollback()
} else {
// 任务执行成功，提交事务
tx.Commit()
}
//自动事务
// 创建orm对象
o := orm.NewOrm()
// 在闭包内执行事务处理
err := o.DoTx(func(ctx context.Context, txOrm orm.TxOrmer) error {
// 准备数据
user := new(User)
user.Name = "transaction"
// 插入数据
// 使用txOrm执行SQL
_, e := txOrm.Insert(user)
return e
})
八、视图
beego 模板，默认支持 tpl 和 html 的后缀名。
视图模板例子
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Title</title>
</head>
<body>
<h1>用户个人信息:</h1>
<p>
{{ if ne .user nil}}
用户名: {{.user.Username}} <br/>
注册时间: {{.user.InitTime}}
{{else}}
用户不存在!
{{end}}}
</p>
</body>
</html>
控制器处理模板
// 处理get请求
func (this *UserController) Get() {
// 初始化，模板渲染需要的数据
user := &User{1, "aaa", time.Now()}
// 通过Data， 将参数传入模板, Data是map类型支持任意类型数据
this.Data["user"] = user
// 设置我们要渲染的模板路径， 也就是views目录下面的相对路径
// 如果你不设置TplName，那么beego就按照 <控制器名字>/<方法名>.tpl 这种格式去查找模板文件。
this.TplName = "user/index.html"
// 如果你关闭了自动渲染，则需要手动调用渲染函数, beego 默认是开启自动渲染的
// this.Render()
}
在app.conf配置文件中配置AutoRender参数为true或者false,表示是否开启自动渲染。
模板冲突问题
//默认情况，模板引擎使用 {{ 模板表达式 }} 作为模板标签，如果我们前端开发使用的是Vue之类的框架，这些前端框架也是使用 {{ 模板表达式 }} 作为模板标签，这样就造成冲突了。我们可以通过修改Go模板引擎的默认标签解决模板标签冲突问题。
// 修改Go的模板标签
web.TemplateLeft = "<"
web.TemplateRight = ">"
修改后的模板表达式:
<.user.username>
模板函数
1.内置函数
2.除内置函数外，还能自定义模板函数
// 定义模板函数, 自动在字符串后面加上标题
func demo(in string)(out string){
out = in + " - 欢迎欢迎"
return
}
// 注册模板函数
beego.AddFuncMap("helloFunc",demo)
//调用自定义模板函数例子:
{{.title | helloFunc}}
静态资源访问
beego 默认静态资源通常保存在 static 目录，访问静态资源的 url 的方式：http://域名/static/资源路径名。主要通过 beego.SetStaticPath 函数设置静态资源路由和目录。
// 通过 /images/资源路径 可以访问static/images目录的内容
// 例: /images/user/1.jpg 实际访问的是 static/images/user/1.jpg
beego.SetStaticPath("/images","static/images")
// 通过 /css/资源路径 可以访问static/css目录的内容
beego.SetStaticPath("/css","static/css")
// 通过 /js/资源路径 可以访问static/js目录的内容
beego.SetStaticPath("/js","static/js")
标签：username,控制器,beego,err,视图,orm,func,id 来源： https://www.cnblogs.com/wmtly/p/16071104.html