ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

beego框架之控制器、模型、视图

2022-03-29 22:01:40  阅读:243  来源: 互联网

标签:username 控制器 beego err 视图 orm func id


一、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

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有