运行逻辑可以拆分以下几段：

1. main文件监听启动端口接收请求。

package main
 
import (
    "github.com/astaxie/beego"  //导入beego依赖
)
 
type MainController struct {
    beego.Controller    //匿名包含beego.Controller
}
 
func (this *MainController) Get() {
    this.Ctx.WriteString("hello world")  //实现get响应
}
 
func main() {
    beego.Router("/", &MainController{})  //设置路由
    beego.Run()   //启动Beego       
}

把上面的代码保存为main.go，然后通过命令行进行编译并执行：

$ go build main.go
$ ./hello

├── conf           //配置文件
│   └── app.conf
├── controllers    //控制器
│   ├── admin
│   └── default.go
├── main.go        //项目入口
├── models         //模型   
│   └── models.go
├── routers       //路由
│   └──router.go
├── static         //静态文件
│   ├── css
│   ├── ico
│   ├── img
│   └── js
└── views          //界面模板
    ├── admin
    └── index.tpl

路由的主要功能是实现从请求地址到实现的方法，beego中封装了Controller，所以路由是从路径到ControllerInterface的过程，ControllerInterface的方法有如下：

type ControllerInterface interface {
Init(ct *Context, cn string)
Prepare()
Get()
Post()
Delete()
Put()
Head()
Patch()
Options()
Finish()
Render() error
}

用户可以通过如下的方式进行路由设置：

beego.Router("/user", &controllers.UserController{})
beego.Router("/bill", &controllers.BillController{})
beego.Router("/log", &controllers.LogController{})

beego.Router("/api/:id([0-9]+)", &controllers.RController{})
自定义正则匹配 //匹配 /api/123 :id= 123
beego.Router("/news/:all", &controllers.RController{})
全匹配方式 //匹配 /news/path/to/123.html :all= path/to/123.html
beego.Router("/user/:username([\w]+)", &controllers.RController{})
正则字符串匹配 //匹配 /user/astaxie :username = astaxie
beego.Router("/download/*.*", &controllers.RController{})
*匹配方式 //匹配 /download/file/api.xml :path= file/api :ext=xml
beego.Router("/download/ceshi/*", &controllers.RController{})
*全匹配方式 //匹配 /download/ceshi/file/api.json :splat=file/api.json
beego.Router("/int", &controllers.RController{})
int类型设置方式 //匹配 :id为int类型，框架帮你实现了正则([0-9]+)
beego.Router("/:hi:string", &controllers.RController{})
string类型设置方式 //匹配 :hi为string类型。框架帮你实现了正则([\w]+)

beego.Controller实现了接口beego.ControllerInterface，beego.ControllerInterface定义了如下函数：

type ControllerInterface interface {
    Init(ct *Context, cn string)
    Prepare()
    Get()
    Post()
    Delete()
    Put()
    Head()
    Patch()
    Options()
    Finish()
    Render() error
}

beego.SessionOn = true

或者通过配置文件配置如下：

sessionon = true

session有几个方便的方法：

SetSession(name string, value interface{})

GetSession(name string) interface{}

DelSession(name string)

例子：

func (this *MainController) Get() {
    v := this.GetSession("asta")
    if v == nil {
        this.SetSession("asta", int(1))
        this.Data["num"] = 0
    } else {
        this.SetSession("asta", v.(int)+1)
        this.Data["num"] = v.(int)
    }
    this.TplNames = "index.tpl"
}

sess:=this.StartSession()
defer sess.SessionRelease()

sess对象具有如下方法：

sess.Set()
sess.Get()
sess.Delete()
sess.SessionID()

当SessionProvider为file时，SessionSavePath是只保存文件的目录，如下所示：

beego.SessionProvider = "file"
beego.SessionSavePath = "./tmp"

当SessionProvider为mysql时，SessionSavePath是链接地址，采用go-sql-driver，如下所示：

beego.SessionProvider = "mysql"
beego.SessionSavePath = "username:password@protocol(address)/dbname?param=value"

当SessionProvider为redis时，SessionSavePath是redis的链接地址，采用了redigo，如下所示：

beego.SessionProvider = "redis"
beego.SessionSavePath = "127.0.0.1:6379"

Get(name string) interface{}
Put(name string, value interface{}, expired int) error
Delete(name string) (ok bool, err error)
IsExist(name string) bool

例子：

var (
    urllist *beego.BeeCache
)
 
func init() {
    urllist = beego.NewBeeCache()
    urllist.Every = 0 //不过期
    urllist.Start()
}
 
func (this *ShortController) Post() {
    var result ShortResult
    longurl := this.Input().Get("longurl")
    beego.Info(longurl)
    result.UrlLong = longurl
    urlmd5 := models.GetMD5(longurl)
    beego.Info(urlmd5)
    if urllist.IsExist(urlmd5) {
        result.UrlShort = urllist.Get(urlmd5).(string)
    } else {
        result.UrlShort = models.Generate()
        err := urllist.Put(urlmd5, result.UrlShort, 0)
        if err != nil {
            beego.Info(err)
        }
        err = urllist.Put(result.UrlShort, longurl, 0)
        if err != nil {
            beego.Info(err)
        }
    }
    this.Data["json"] = result
    this.ServeJson()
}

beego.SetLogger(*log.Logger)

beego.SetLevel(beego.LevelError)

Trace(v ...interface{})

Debug(v ...interface{})

Info(v ...interface{})

Warn(v ...interface{})

Error(v ...interface{})

Critical(v ...interface{})

例子：

fd,err := os.OpenFile("/var/log/beeapp/beeapp.log", os.O_RDWR|os.O_APPEND, 0644)
if err != nil {
    beego.Critical("openfile beeapp.log:", err)
    return
}
lg := log.New(fd, "", log.Ldate|log.Ltime)
beego.SetLogger(lg)

beego支持解析ini文件, beego默认会解析当前应用下的conf/app.conf文件

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

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

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

mysqluser = "root"
mysqlpass = "rootpass"
mysqlurls = "127.0.0.1"
mysqldb = "beego"

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

beego.AppConfig.String("mysqluser")
beego.AppConfig.String("mysqlpass")
beego.AppConfig.String("mysqlurls")
beego.AppConfig.String("mysqldb")

AppConfig支持如下方法：

Bool(key string) (bool, error)
Int(key string) (int, error)
Int64(key string) (int64, error)
Float(key string) (float64, error)
String(key string) string

ORM模块

目前beego-orm支持的数据有:

-MySQL：https://github.com/go-sql-driver/mysql

-PostgreSQL：https://github.com/lib/pq

-Sqlite3：https://github.com/mattn/go-sqlite

beego-orm的相关特性：

- 支持 Go 的所有类型存储

- 轻松上手，采用简单的 CRUD 风格

- 自动 Join 关联表

- 跨数据库兼容查询

- 允许直接使用 SQL 查询／映射

- 严格完整的测试保证 ORM 的稳定与健壮

示例请参考beego官方:https://beego.me/docs/mvc/model/orm.md

优点：

1）使用简单：通过命令行创建beego项目；监控代码修改进行热编译；自动化测试代码以及自动化打包部署。

2）模块化：配置解析，缓存操作，日志记录，性能监测，ORM模块，请求模拟，上下文操作，session。

3）智能化：智能监控，智能router。可监控cpu、memory、goroutine，QPS

缺点：依赖库多，不利于掌握

1. 适合用作服务器端开发，快速开发web服务，支持restful api。

2. 开发的后端服务可作为微服务的一部分，提供高并发的性能。

3. 可作为云平台的开发框架，目前国内很多云平台采用beego开发。

4. 开发的服务也可以用来进行分布式部署。

5. 可以开发高性能网关，提供高效路由功能。

6. 开发的服务支持生成docker镜像，使用docker容器部署。

【小结】通过上述介绍，可以看出Beego框架使用简单，快速开发非常方便，提供多个模块工具，智能监控，智能路由。依托于golang语言有着高效的性能，Beego可用于微服务、分布式、网关接入等场景开发，完全可以替代springboot进行项目快速开发。

【备注】本文参考自beego官网，地址：https://beego.me/docs/intro/

关于作者：十月，现任普元西安研发中心资深开发工程师，擅长Java、golang、大数据、云计算等领域技术；对公有云、混合云、微服务架构有着浓厚的兴趣。