我家小花儿

这个屌丝很懒，什么也没留下！

热门标签

【Beego框架学习】

作者：我家小花儿 | 2024-04-29 19:29:32

踩

beego

1.Beego框架简述

beego简介

beego 是一个快速开发 Go 应用的 HTTP 框架，他可以用来快速开发 API、Web 及后端服务等各种应用，是一个 RESTful 的框架，主要设计灵感来源于 tornado、sinatra 和 flask 这三个框架，但是结合了 Go 本身的一些特性（interface、struct 嵌入等）而设计的一个框架。

beego 的架构

beego 的整体设计架构如下所示：

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-nqtt9Ety-1658140163641)(img/architecture.png)]

beego 是基于八大独立的模块构建的，是一个高度解耦的框架。当初设计 beego 的时候就是考虑功能模块化，用户即使不使用 beego 的 HTTP 逻辑，也依旧可以使用这些独立模块，例如：你可以使用 cache 模块来做你的缓存逻辑；使用日志模块来记录你的操作信息；使用 config 模块来解析你各种格式的文件。所以 beego 不仅可以用于 HTTP 类的应用开发，在你的 socket 游戏开发中也是很有用的模块，这也是 beego 如此受欢迎的一个原因。大家如果玩过乐高的话，应该知道很多高级的东西都是一块一块的积木搭建出来的，而设计 beego 的时候，这些模块就是积木，高级机器人就是 beego。至于这些模块的功能以及如何使用会在后面的文档逐一介绍。

beego 的执行逻辑

既然 beego 是基于这些模块构建的，那么它的执行逻辑是怎么样的呢？beego 是一个典型的 MVC 架构，它的执行逻辑如下图所示：

beego 项目结构

一般的 beego 项目的目录如下所示：

├── conf
│   └── app.conf
├── controllers
│   ├── admin
│   └── default.go
├── main.go
├── models
│   └── models.go
├── static
│   ├── css
│   ├── ico
│   ├── img
│   └── js
└── views
    ├── admin
    └── index.tpl
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

从上面的目录结构我们可以看出来 M（models 目录）、V（views 目录）和 C（controllers 目录）的结构， main.go 是入口文件。

2.第一个beego项目

安装包

go get -u github.com/beego/beego/v2
go get -u github.com/beego/bee/v2
1
2

创建项目

bee new pro01
1

管理项目依赖

go mod tidy
1

运行项目

bee run
1

3.beego项目结构分析

app.conf

appname = pro01
httpport = 8080
runmode = dev
1
2
3

controller

package controllers

import (
	beego "github.com/beego/beego/v2/server/web"
)

type MainController struct {
	beego.Controller
}

func (c *MainController) Get() {
	c.Data["Website"] = "beego.me"
	c.Data["Email"] = "astaxie@gmail.com"
	c.TplName = "index.tpl"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

路由

package controllers

import (
	beego "github.com/beego/beego/v2/server/web"
)

type MainController struct {
	beego.Controller
}

func (c *MainController) Get() {
	c.Data["Website"] = "golang-tech-stack.com"
	c.Data["Name"] = "老郭"
	c.TplName = "index.tpl"
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

视图

<!DOCTYPE html>
<html lang="en">
<head>
    <title>golang技术栈</title>
</head>
<body>


    网站：{{.Website}} <br>

    姓名：{{.Name}}

</body>
</html>
1
2
3
4
5
6
7
8
9
10
11
12
13
14

运行结果

网站：golang-tech-stack.com
姓名：老郭
1
2

4.bee 工具简介

bee 工具是一个为了协助快速开发 beego 项目而创建的项目，通过 bee 您可以很容易的进行 beego 项目的创建、热编译、开发、测试、和部署。

bee 工具的安装

您可以通过如下的方式安装 bee 工具：

go get -u github.com/beego/bee/v2
1

安装完之后，bee 可执行文件默认存放在 $GOPATH/bin 里面，所以您需要把 $GOPATH/bin 添加到您的环境变量中，才可以进行下一步。

bee 工具命令详解

我们在命令行输入 bee，可以看到如下的信息：

Bee is a Fast and Flexible tool for managing your Beego Web Application.

Usage:

    bee command [arguments]

The commands are:

    version     show the bee & beego version
    migrate     run database migrations
    api         create an api application base on beego framework
    bale        packs non-Go files to Go source files    
    new         create an application base on beego framework
    run         run the app which can hot compile
    pack        compress an beego project
    fix         Fixes your application by making it compatible with newer versions of Beego
    dlv         Start a debugging session using Delve
    dockerize   Generates a Dockerfile for your Beego application
    generate    Source code generator
    hprose      Creates an RPC application based on Hprose and Beego frameworks
    pack        Compresses a Beego application into a single file
    rs          Run customized scripts
    run         Run the application by starting a local development server
    server      serving static content over HTTP on port
    
Use bee help [command] for more information about a command.
    
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

`new` 命令

new 命令是新建一个 Web 项目，我们在命令行下执行 bee new <项目名> 就可以创建一个新的项目。但是注意该命令必须在 $GOPATH/src 下执行。最后会在 $GOPATH/src 相应目录下生成如下目录结构的项目：

bee new myproject
[INFO] Creating application...
/gopath/src/myproject/
/gopath/src/myproject/conf/
/gopath/src/myproject/controllers/
/gopath/src/myproject/models/
/gopath/src/myproject/static/
/gopath/src/myproject/static/js/
/gopath/src/myproject/static/css/
/gopath/src/myproject/static/img/
/gopath/src/myproject/views/
/gopath/src/myproject/conf/app.conf
/gopath/src/myproject/controllers/default.go
/gopath/src/myproject/views/index.tpl
/gopath/src/myproject/main.go
13-11-25 09:50:39 [SUCC] New application successfully created!
myproject
├── conf
│   └── app.conf
├── controllers
│   └── default.go
├── main.go
├── models
├── routers
│   └── router.go
├── static
│   ├── css
│   ├── img
│   └── js
├── tests
│   └── default_test.go
└── views
    └── index.tpl

8 directories, 4 files
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35

`api` 命令

上面的 new 命令是用来新建 Web 项目，不过很多用户使用 beego 来开发 API 应用。所以这个 api 命令就是用来创建 API 应用的，执行命令之后如下所示：

bee api apiproject
create app folder: /gopath/src/apiproject
create conf: /gopath/src/apiproject/conf
create controllers: /gopath/src/apiproject/controllers
create models: /gopath/src/apiproject/models
create tests: /gopath/src/apiproject/tests
create conf app.conf: /gopath/src/apiproject/conf/app.conf
create controllers default.go: /gopath/src/apiproject/controllers/default.go
create tests default.go: /gopath/src/apiproject/tests/default_test.go
create models object.go: /gopath/src/apiproject/models/object.go
create main.go: /gopath/src/apiproject/main.go
1
2
3
4
5
6
7
8
9
10
11

这个项目的目录结构如下：

apiproject
├── conf
│   └── app.conf
├── controllers
│   └── object.go
│   └── user.go
├── docs
│   └── doc.go
├── main.go
├── models
│   └── object.go
│   └── user.go
├── routers
│   └── router.go
└── tests
    └── default_test.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

从上面的目录我们可以看到和 Web 项目相比，少了 static 和 views 目录，多了一个 test 模块，用来做单元测试的。

同时，该命令还支持一些自定义参数自动连接数据库创建相关 model 和 controller: bee api [appname] [-tables=""] [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"] 如果 conn 参数为空则创建一个示例项目，否则将基于链接信息链接数据库创建项目。

`run` 命令

我们在开发 Go 项目的时候最大的问题是经常需要自己手动去编译再运行，bee run 命令是监控 beego 的项目，通过 fsnotify监控文件系统。但是注意该命令必须在 $GOPATH/src/appname 下执行。这样我们在开发过程中就可以实时的看到项目修改之后的效果：

bee run
13-11-25 09:53:04 [INFO] Uses 'myproject' as 'appname'
13-11-25 09:53:04 [INFO] Initializing watcher...
13-11-25 09:53:04 [TRAC] Directory(/gopath/src/myproject/controllers)
13-11-25 09:53:04 [TRAC] Directory(/gopath/src/myproject/models)
13-11-25 09:53:04 [TRAC] Directory(/gopath/src/myproject)
13-11-25 09:53:04 [INFO] Start building...
13-11-25 09:53:16 [SUCC] Build was successful
13-11-25 09:53:16 [INFO] Restarting myproject ...
13-11-25 09:53:16 [INFO] ./myproject is running...
1
2
3
4
5
6
7
8
9
10

如果我们修改了 Controller 下面的 default.go 文件，我们就可以看到命令行输出：

13-11-25 10:11:20 [EVEN] "/gopath/src/myproject/controllers/default.go": DELETE|MODIFY
13-11-25 10:11:20 [INFO] Start building...
13-11-25 10:11:20 [SKIP] "/gopath/src/myproject/controllers/default.go": CREATE
13-11-25 10:11:23 [SKIP] "/gopath/src/myproject/controllers/default.go": MODIFY
13-11-25 10:11:23 [SUCC] Build was successful
13-11-25 10:11:23 [INFO] Restarting myproject ...
13-11-25 10:11:23 [INFO] ./myproject is running...
1
2
3
4
5
6
7

刷新浏览器我们看到新的修改内容已经输出。

`pack` 命令

pack 目录用来发布应用的时候打包，会把项目打包成 zip 包，这样我们部署的时候直接把打包之后的项目上传，解压就可以部署了：

bee pack
app path: /gopath/src/apiproject
GOOS darwin GOARCH amd64
build apiproject
build success
exclude prefix:
exclude suffix: .go:.DS_Store:.tmp
file write to `/gopath/src/apiproject/apiproject.tar.gz`
1
2
3
4
5
6
7
8

我们可以看到目录下有如下的压缩文件：

rwxr-xr-x  1 astaxie  staff  8995376 11 25 22:46 apiproject
-rw-r--r--  1 astaxie  staff  2240288 11 25 22:58 apiproject.tar.gz
drwxr-xr-x  3 astaxie  staff      102 11 25 22:31 conf
drwxr-xr-x  3 astaxie  staff      102 11 25 22:31 controllers
-rw-r--r--  1 astaxie  staff      509 11 25 22:31 main.go
drwxr-xr-x  3 astaxie  staff      102 11 25 22:31 models
drwxr-xr-x  3 astaxie  staff      102 11 25 22:31 tests
1
2
3
4
5
6
7

`bale` 命令

这个命令目前仅限内部使用，具体实现方案未完善，主要用来压缩所有的静态文件变成一个变量申明文件，全部编译到二进制文件里面，用户发布的时候携带静态文件，包括 js、css、img 和 views。最后在启动运行时进行非覆盖式的自解压。

`version` 命令

这个命令是动态获取 bee、beego 和 Go 的版本，这样一旦用户出现错误，可以通过该命令来查看当前的版本

$ bee version
bee   :1.2.2
beego :1.4.2
Go    :go version go1.3.3 darwin/amd64
1
2
3
4

需要注意的是，目前 bee version 会试图输出当前beego的版本。

但是目前这个实现有点坑，它是通过读取$GOPATH/src/astaxie/beego下的文件来进行的。

这意味着，如果你本地并没有下载beego源码，或者放置的位置不对，bee都无法输出beego的版本信息。

`generate` 命令

这个命令是用来自动化的生成代码的，包含了从数据库一键生成 model，还包含了 scaffold 的，通过这个命令，让大家开发代码不再慢

bee generate scaffold [scaffoldname] [-fields=""] [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"]
    The generate scaffold command will do a number of things for you.
    -fields: a list of table fields. Format: field:type, ...
    -driver: [mysql | postgres | sqlite], the default is mysql
    -conn:   the connection string used by the driver, the default is root:@tcp(127.0.0.1:3306)/test
    example: bee generate scaffold post -fields="title:string,body:text"

bee generate model [modelname] [-fields=""]
    generate RESTful model based on fields
    -fields: a list of table fields. Format: field:type, ...

bee generate controller [controllerfile]
    generate RESTful controllers

bee generate view [viewpath]
    generate CRUD view in viewpath

bee generate migration [migrationfile] [-fields=""]
    generate migration file for making database schema update
    -fields: a list of table fields. Format: field:type, ...

bee generate docs
    generate swagger doc file
    
bee generate routers [-ctrlDir=/path/to/controller/directory] [-routersFile=/path/to/routers/file.go] [-routersPkg=myPackage]
    -ctrlDir: the directory contains controllers definition. Bee scans this directory and its subdirectory to generate routers info
    -routersFile: output file. All generated routers info will be output into this file. 
              If file not found, Bee create new one, or Bee truncates it.
              The default value is "routers/commentRouters.go"
    -routersPkg: package declaration.The default value is "routers". 
              When you pass routersFile parameter, you'd better pass this parameter

bee generate test [routerfile]
    generate testcase

bee generate appcode [-tables=""] [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"] [-level=3]
    generate appcode based on an existing database
    -tables: a list of table names separated by ',', default is empty, indicating all tables
    -driver: [mysql | postgres | sqlite], the default is mysql
    -conn:   the connection string used by the driver.
             default for mysql:    root:@tcp(127.0.0.1:3306)/test
             default for postgres: postgres://postgres:postgres@127.0.0.1:5432/postgres
    -level:  [1 | 2 | 3], 1 = models; 2 = models,controllers; 3 = models,controllers,router
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

例如： bee generate scaffold user -fields="id:int64,name:string" -driver=mysql -conn="root:123456@tcp(127.0.0.1:3306)/beego_db"

例如：bee generate appcode -tables="user" -fields="id:int64,name:string" -driver=mysql -conn="root:123456@tcp(127.0.0.1:3306)/beego_db"

注意：项目需要创建在GOPATH/src/下面才能生成

`migrate` 命令

这个命令是应用的数据库迁移命令，主要是用来每次应用升级，降级的SQL管理。

bee migrate [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"]
    run all outstanding migrations
    -driver: [mysql | postgresql | sqlite], the default is mysql
    -conn:   the connection string used by the driver, the default is root:@tcp(127.0.0.1:3306)/test

bee migrate rollback [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"]
    rollback the last migration operation
    -driver: [mysql | postgresql | sqlite], the default is mysql
    -conn:   the connection string used by the driver, the default is root:@tcp(127.0.0.1:3306)/test

bee migrate reset [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"]
    rollback all migrations
    -driver: [mysql | postgresql | sqlite], the default is mysql
    -conn:   the connection string used by the driver, the default is root:@tcp(127.0.0.1:3306)/test

bee migrate refresh [-driver=mysql] [-conn="root:@tcp(127.0.0.1:3306)/test"]
    rollback all migrations and run them all again
    -driver: [mysql | postgresql | sqlite], the default is mysql
    -conn:   the connection string used by the driver, the default is root:@tcp(127.0.0.1:3306)/test
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

`dockerize` 命令

这个命令可以通过生成Dockerfile文件来实现docker化你的应用。

例子: 生成一个以1.6.4版本Go环境为基础镜像的Dockerfile,并暴露9000端口:

$ bee dockerize -image="library/golang:1.6.4" -expose=9000
______
| ___ \
| |_/ /  ___   ___
| ___ \ / _ \ / _ \
| |_/ /|  __/|  __/
\____/  \___| \___| v1.6.2
2016/12/26 22:34:54 INFO     ▶ 0001 Generating Dockerfile...
2016/12/26 22:34:54 SUCCESS  ▶ 0002 Dockerfile generated.
1
2
3
4
5
6
7
8
9

更多帮助信息可执行bee help dockerize.

bee 工具配置文件

您可能已经注意到，在 bee 工具的源码目录下有一个 bee.json 文件，这个文件是针对 bee 工具的一些行为进行配置。该功能还未完全开发完成，不过其中的一些选项已经可以使用：

"version": 0：配置文件版本，用于对比是否发生不兼容的配置格式版本。
"go_install": false：如果您的包均使用完整的导入路径（例如：github.com/user/repo/subpkg）,则可以启用该选项来进行 go install 操作，加快构建操作。
"watch_ext": []：用于监控其它类型的文件（默认只监控后缀为 .go 的文件）。
"dir_structure":{}：如果您的目录名与默认的 MVC 架构的不同，则可以使用该选项进行修改。
"cmd_args": []：如果您需要在每次启动时加入启动参数，则可以使用该选项。
"envs": []：如果您需要在每次启动时设置临时环境变量参数，则可以使用该选项。

5.beego参数配置

beego 目前支持 INI、XML、JSON、YAML 格式的配置文件解析，但是默认采用了 INI 格式解析，用户可以通过简单的配置就可以获得很大的灵活性。

默认配置解析

beego 默认会解析当前应用下的 conf/app.conf 文件。

通过这个文件你可以初始化很多 beego 的默认参数：

appname = beepkg
httpaddr = "127.0.0.1"
httpport = 9090
runmode ="dev"
autorender = false
recoverpanic = false
viewspath = "myview"
1
2
3
4
5
6
7

它们都维护在结构体 beego/server/web#Config 。

上面这些参数会替换 beego 默认的一些参数, beego 的参数主要有哪些呢？请参考https://godoc.org/github.com/beego/beego#pkg-constants 。

BConfig 就是 beego 里面的默认的配置，也是结构体 beego/server/web#Config 的实例。

你也可以直接通过web.BConfig.AppName="beepkg"这样来修改，和上面的配置效果一样，只是一个在代码里面写死了，而配置文件就会显得更加灵活。

你也可以在配置文件中配置应用需要用的一些配置信息，例如下面所示的数据库信息：

mysqluser = "root"
mysqlpass = "rootpass"
mysqlurls = "127.0.0.1"
mysqldb   = "beego"
1
2
3
4

那么你就可以通过如下的方式获取设置的配置信息:

web.AppConfig.String("mysqluser")
web.AppConfig.String("mysqlpass")
web.AppConfig.String("mysqlurls")
web.AppConfig.String("mysqldb")
1
2
3
4

AppConfig 的方法如下：

Set(key, val string) error
String(key string) string
Strings(key string) []string
Int(key string) (int, error)
Int64(key string) (int64, error)
Bool(key string) (bool, error)
Float(key string) (float64, error)
DefaultString(key string, defaultVal string) string
DefaultStrings(key string, defaultVal []string)
DefaultInt(key string, defaultVal int) int
DefaultInt64(key string, defaultVal int64) int64
DefaultBool(key string, defaultVal bool) bool
DefaultFloat(key string, defaultVal float64) float64
DIY(key string) (interface{}, error)
GetSection(section string) (map[string]string, error)
SaveConfigFile(filename string) error

在使用 ini 类型的配置文件中, key 支持 section::key 模式.

你可以用 Default* 方法返回默认值.

你也可以参考配置模块

不同级别的配置

在配置文件里面支持 section，可以有不同的 Runmode 的配置，默认优先读取 runmode 下的配置信息，例如下面的配置文件：

appname = beepkg
httpaddr = "127.0.0.1"
httpport = 9090
runmode ="dev"
autorender = false
recoverpanic = false
viewspath = "myview"

[dev]
httpport = 8080
[prod]
httpport = 8088
[test]
httpport = 8888
1
2
3
4
5
6
7
8
9
10
11
12
13
14

上面的配置文件就是在不同的 runmode 下解析不同的配置，例如在 dev 模式下，httpport 是 8080，在 prod 模式下是 8088，在 test 模式下是 8888。其他配置文件同理。解析的时候优先解析 runmode 下的配置，然后解析默认的配置。

读取不同模式下配置参数的方法是“模式::配置参数名”，比如：beego.AppConfig.String(“dev::mysqluser”)。

对于自定义的参数，需使用 GetConfig(typ, key string, defaultVal interface{}) 来获取指定 runmode 下的配置（需 1.4.0 以上版本），typ 为参数类型，key 为参数名, defaultVal 为默认值。

多个配置文件

INI 格式配置支持 include 方式，引用多个配置文件，例如下面的两个配置文件效果同上：

app.conf

appname = beepkg
httpaddr = "127.0.0.1"
httpport = 9090

include "app2.conf"
1
2
3
4
5

app2.conf

runmode ="dev"
autorender = false
recoverpanic = false
viewspath = "myview"

[dev]
httpport = 8080
[prod]
httpport = 8088
[test]
httpport = 8888
1
2
3
4
5
6
7
8
9
10
11

支持环境变量配置

配置文件解析支持从环境变量中获取配置项，配置项格式：${环境变量}。例如下面的配置中优先使用环境变量中配置的 runmode 和 httpport，如果有配置环境变量 ProRunMode 则优先使用该环境变量值。如果不存在或者为空，则使用 “dev” 作为 runmode。

app.conf

runmode  = "${ProRunMode||dev}"
httpport = "${ProPort||9090}"
1
2

系统默认参数

beego 中带有很多可配置的参数，我们来一一认识一下它们，这样有利于我们在接下来的 beego 开发中可以充分的发挥他们的作用(你可以通过在 conf/app.conf 中设置对应的值，不区分大小写)：

基础配置

BConfig 保存了所有 beego 里面的系统默认参数，你可以通过 web.BConfig 来访问和修改底下的所有配置信息.

配置文件路径，默认是应用程序对应的目录下的 conf/app.conf，用户可以在程序代码中加载自己的配置文件 beego.LoadAppConfig("ini", "conf/app2.conf") 也可以加载多个文件，只要你调用多次就可以了，如果后面的文件和前面的 key 冲突，那么以最新加载的为最新值

App 配置

AppName

应用名称，默认是 beego。通过 bee new 创建的是创建的项目名。

web.BConfig.AppName = "beego"
RunMode

应用的运行模式，可选值为 prod, dev 或者 test. 默认是 dev, 为开发模式，在开发模式下出错会提示友好的出错页面，如前面错误描述中所述。

web.BConfig.RunMode = "dev"
RouterCaseSensitive

是否路由忽略大小写匹配，默认是 true，区分大小写

web.BConfig.RouterCaseSensitive = true
ServerName

beego 服务器默认在请求的时候输出 server 为 beego。

web.BConfig.ServerName = "beego"
RecoverPanic

是否异常恢复，默认值为 true，即当应用出现异常的情况，通过 recover 恢复回来，而不会导致应用异常退出。

web.BConfig.RecoverPanic = true
CopyRequestBody

是否允许在 HTTP 请求时，返回原始请求体数据字节，默认为 false （GET or HEAD or 上传文件请求除外）。

web.BConfig.CopyRequestBody = false
EnableGzip

是否开启 gzip 支持，默认为 false 不支持 gzip，一旦开启了 gzip，那么在模板输出的内容会进行 gzip 或者 zlib 压缩，根据用户的 Accept-Encoding 来判断。

web.BConfig.EnableGzip = false

Gzip允许用户自定义压缩级别、压缩长度阈值和针对请求类型压缩:
1. 压缩级别, gzipCompressLevel = 9,取值为 1~9,如果不设置为 1(最快压缩)
2. 压缩长度阈值, gzipMinLength = 256,当原始内容长度大于此阈值时才开启压缩,默认为 20B(ngnix默认长度)
3. 请求类型, includedMethods = get;post,针对哪些请求类型进行压缩,默认只针对 GET 请求压缩
MaxMemory

文件上传默认内存缓存大小，默认值是 1 << 26(64M)。

web.BConfig.MaxMemory = 1 << 26
EnableErrorsShow

是否显示系统错误信息，默认为 true。

web.BConfig.EnableErrorsShow = true
EnableErrorsRender

是否将错误信息进行渲染，默认值为 true，即出错会提示友好的出错页面，对于 API 类型的应用可能需要将该选项设置为 false 以阻止在 dev 模式下不必要的模板渲染信息返回。

Web配置

AutoRender

是否模板自动渲染，默认值为 true，对于 API 类型的应用，应用需要把该选项设置为 false，不需要渲染模板。

web.BConfig.WebConfig.AutoRender = true
EnableDocs

是否开启文档内置功能，默认是 false

web.BConfig.WebConfig.EnableDocs = true
FlashName

Flash 数据设置时 Cookie 的名称，默认是 BEEGO_FLASH

web.BConfig.WebConfig.FlashName = "BEEGO_FLASH"
FlashSeperator

Flash 数据的分隔符，默认是 BEEGOFLASH

web.BConfig.WebConfig.FlashSeparator = "BEEGOFLASH"
DirectoryIndex

是否开启静态目录的列表显示，默认不显示目录，返回 403 错误。

web.BConfig.WebConfig.DirectoryIndex = false
StaticDir

静态文件目录设置，默认是static

可配置单个或多个目录:
1. 单个目录, StaticDir = download. 相当于 beego.SetStaticPath("/download","download")
2. 多个目录, StaticDir = download:down download2:down2. 相当于 beego.SetStaticPath("/download","down") 和 beego.SetStaticPath("/download2","down2")
web.BConfig.WebConfig.StaticDir
StaticExtensionsToGzip

允许哪些后缀名的静态文件进行 gzip 压缩，默认支持 .css 和 .js

web.BConfig.WebConfig.StaticExtensionsToGzip = []string{".css", ".js"}

等价 config 文件中
```
StaticExtensionsToGzip = .css, .js
1
```
TemplateLeft

模板左标签，默认值是{{。

web.BConfig.WebConfig.TemplateLeft="{{"
TemplateRight

模板右标签，默认值是}}。

web.BConfig.WebConfig.TemplateRight="}}"
ViewsPath

模板路径，默认值是 views。

web.BConfig.WebConfig.ViewsPath="views"
EnableXSRF

是否开启 XSRF，默认为 false，不开启。

web.BConfig.WebConfig.EnableXSRF = false
XSRFKEY

XSRF 的 key 信息，默认值是 beegoxsrf。 EnableXSRF＝true 才有效

web.BConfig.WebConfig.XSRFKEY = "beegoxsrf"
XSRFExpire

XSRF 过期时间，默认值是 0，不过期。

web.BConfig.WebConfig.XSRFExpire = 0
CommentRouterPath

CommentRouterPath 注解路由所在位置。默认值是controllers。 Beego 会在启动的时候扫描下面的文件生成了路由。 web.BConfig.WebConfig.CommentRouterPath = "controllers"

监听配置

Graceful

是否开启热升级，默认是 false，关闭热升级。

web.BConfig.Listen.Graceful=false
ServerTimeOut

设置 HTTP 的超时时间，默认是 0，不超时。

web.BConfig.Listen.ServerTimeOut=0
ListenTCP4

监听本地网络地址类型，默认是TCP6，可以通过设置为true设置为TCP4。

web.BConfig.Listen.ListenTCP4 = true
EnableHTTP

是否启用 HTTP 监听，默认是 true。

web.BConfig.Listen.EnableHTTP = true
HTTPAddr

应用监听地址，默认为空，监听所有的网卡 IP。

web.BConfig.Listen.HTTPAddr = ""
HTTPPort

应用监听端口，默认为 8080。

web.BConfig.Listen.HTTPPort = 8080
EnableHTTPS

是否启用 HTTPS，默认是 false 关闭。当需要启用时，先设置 EnableHTTPS = true，并设置 HTTPSCertFile 和 HTTPSKeyFile

web.BConfig.Listen.EnableHTTPS = false
HTTPSAddr

应用监听地址，默认为空，监听所有的网卡 IP。

web.BConfig.Listen.HTTPSAddr = ""
HTTPSPort

应用监听端口，默认为 10443

web.BConfig.Listen.HTTPSPort = 10443
HTTPSCertFile

开启 HTTPS 后，ssl 证书路径，默认为空。

web.BConfig.Listen.HTTPSCertFile = "conf/ssl.crt"
HTTPSKeyFile

开启 HTTPS 之后，SSL 证书 keyfile 的路径。

web.BConfig.Listen.HTTPSKeyFile = "conf/ssl.key"
EnableAdmin

是否开启进程内监控模块，默认 false 关闭。

web.BConfig.Listen.EnableAdmin = false
AdminAddr

监控程序监听的地址，默认值是 localhost 。

web.BConfig.Listen.AdminAddr = "localhost"
AdminPort

监控程序监听的地址，默认值是 8088 。

web.BConfig.Listen.AdminPort = 8088
EnableFcgi

是否启用 fastcgi ，默认是 false。

web.BConfig.Listen.EnableFcgi = false
EnableStdIo

通过fastcgi 标准I/O，启用 fastcgi 后才生效，默认 false。

web.BConfig.Listen.EnableStdIo = false

Session配置

SessionOn

session 是否开启，默认是 false。

web.BConfig.WebConfig.Session.SessionOn = false
SessionProvider

session 的引擎，默认是 memory，详细参见 session 模块。

web.BConfig.WebConfig.Session.SessionProvider = ""
SessionName

存在客户端的 cookie 名称，默认值是 beegosessionID。

web.BConfig.WebConfig.Session.SessionName = "beegosessionID"
SessionGCMaxLifetime

session 过期时间，默认值是 3600 秒。

web.BConfig.WebConfig.Session.SessionGCMaxLifetime = 3600
SessionProviderConfig

配置信息，根据不同的引擎设置不同的配置信息，详细的配置请看下面的引擎设置，详细参见 session 模块
SessionCookieLifeTime

session 默认存在客户端的 cookie 的时间，默认值是 3600 秒。

web.BConfig.WebConfig.Session.SessionCookieLifeTime = 3600
SessionAutoSetCookie

是否开启SetCookie, 默认值 true 开启。

web.BConfig.WebConfig.Session.SessionAutoSetCookie = true
SessionDomain

session cookie 存储域名, 默认空。

web.BConfig.WebConfig.Session.SessionDomain = ""

Log配置

log详细配置，请参见 `logs 模块`。
1

AccessLogs

是否输出日志到 Log，默认在 prod 模式下不会输出日志，默认为 false 不输出日志。此参数不支持配置文件配置。

web.BConfig.Log.AccessLogs = false
FileLineNum

是否在日志里面显示文件名和输出日志行号，默认 true。此参数不支持配置文件配置。

web.BConfig.Log.FileLineNum = true
Outputs

日志输出配置，参考 logs 模块，console file 等配置，此参数不支持配置文件配置。

web.BConfig.Log.Outputs = map[string]string{"console": ""}

or

web.BConfig.Log.Outputs["console"] = ""

6.beego路由设置

什么是路由设置呢？前面介绍的 MVC 结构执行时，介绍过 beego 存在三种方式的路由:固定路由、正则路由、自动路由，接下来详细的讲解如何使用这三种路由。

基础路由

从 beego 1.2 版本开始支持了基本的 RESTful 函数式路由,应用中的大多数路由都会定义在 routers/router.go 文件中。最简单的 beego 路由由 URI 和闭包函数组成。

基本 GET 路由

web.Get("/",func(ctx *context.Context){
     ctx.Output.Body([]byte("hello world"))
})
1
2
3

基本 POST 路由

web.Post("/alice",func(ctx *context.Context){
     ctx.Output.Body([]byte("bob"))
})
1
2
3

注册一个可以响应任何 HTTP 的路由

web.Any("/foo",func(ctx *context.Context){
     ctx.Output.Body([]byte("bar"))
})
1
2
3

所有的支持的基础函数如下所示

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)

支持自定义的 handler 实现

有些时候我们已经实现了一些 rpc 的应用,但是想要集成到 beego 中,或者其他的 httpserver 应用,集成到 beego 中来.现在可以很方便的集成:

s := rpc.NewServer()
s.RegisterCodec(json.NewCodec(), "application/json")
s.RegisterService(new(HelloService), "")
web.Handler("/rpc", s)
1
2
3
4

web.Handler(router, http.Handler) 这个函数是关键,第一个参数表示路由 URI, 第二个就是你自己实现的 http.Handler, 注册之后就会把所有 rpc 作为前缀的请求分发到 http.Handler 中进行处理.

这个函数其实还有第三个参数就是是否是前缀匹配,默认是 false, 如果设置了 true, 那么就会在路由匹配的时候前缀匹配,即 /rpc/user 这样的也会匹配去运行

路由参数

后面会讲到固定路由,正则路由,这些参数一样适用于上面的这些函数

RESTful Controller 路由

在介绍这三种 beego 的路由实现之前先介绍 RESTful，我们知道 RESTful 是一种目前 API 开发中广泛采用的形式，beego 默认就是支持这样的请求方法，也就是用户 Get 请求就执行 Get 方法，Post 请求就执行 Post 方法。因此默认的路由是这样 RESTful 的请求方式。

固定路由

固定路由也就是全匹配的路由，如下所示：

web.Router("/", &controllers.MainController{})
web.Router("/admin", &admin.UserController{})
web.Router("/admin/index", &admin.ArticleController{})
web.Router("/admin/addpkg", &admin.AddController{})
1
2
3
4

如上所示的路由就是我们最常用的路由方式，一个固定的路由，一个控制器，然后根据用户请求方法不同请求控制器中对应的方法，典型的 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(“/
声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/我家小花儿/article/detail/509380

【Beego框架学习】

1.Beego框架简述

beego简介

beego 的架构

beego 的执行逻辑

beego 项目结构

2.第一个beego项目

安装包

创建项目

管理项目依赖

运行项目

3.beego项目结构分析

app.conf

controller

路由

视图

运行结果

4.bee 工具简介

bee 工具的安装

bee 工具命令详解

new 命令

api 命令

run 命令

pack 命令

bale 命令

version 命令

generate 命令

migrate 命令

dockerize 命令

bee 工具配置文件

5.beego参数配置

默认配置解析

多个配置文件

支持环境变量配置

系统默认参数

基础配置

App 配置

Web配置

监听配置

Session配置

Log配置

6.beego路由设置

基础路由

基本 GET 路由

基本 POST 路由

注册一个可以响应任何 HTTP 的路由

所有的支持的基础函数如下所示

支持自定义的 handler 实现

路由参数

RESTful Controller 路由

固定路由

正则路由

`new` 命令

`api` 命令

`run` 命令

`pack` 命令

`bale` 命令

`version` 命令

`generate` 命令

`migrate` 命令

`dockerize` 命令