其他分享
首页 > 其他分享> > beego框架之控制器、模型、视图

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