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")

 

这篇关于beego框架之控制器、模型、视图的文章就介绍到这儿，希望我们推荐的文章对大家有所帮助，也希望大家多多支持为之网！