跳到主要内容

Beego

Beego 是一个全功能的 Go Web 应用框架，灵感来源于 Python 的 Tornado 和 Sinatra 框架。它提供了 MVC 架构、ORM、缓存、日志等完整的企业级 Web 开发功能。

简介​

Beego 特性​

Beego 核心特性:

  • MVC 架构: 完整的 Model-View-Controller 分离
  • ORM 系统: 强大的数据库操作能力
  • 路由系统: 灵活的路由配置
  • 模板引擎: 快速的模板渲染
  • 智能路由: 自动路由和 RESTful 路由
  • Session 管理: 多种 Session 存储方式
  • 缓存系统: 支持 Redis、Memcache 等
  • 日志系统: 完善的日志管理
  • 监控工具: 健康检查、性能监控
  • 热更新: 代码修改自动重新编译

适用场景:

  • 企业级 Web 应用
  • 快速开发
  • RESTful API
  • 需要完整功能的 Web 项目
  • 从其他框架迁移到 Go 的项目

安装 Beego​

# 安装 Beego 和 Bee 工具
go get -u github.com/beego/beego/v2
go get -u github.com/beego/bee/v2

# 创建项目
bee new my-project

快速开始​

package main

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

type MainController struct {
    beego.Controller
}

func (c *MainController) Get() {
    c.Ctx.WriteString("Hello, Beego!")
}

func main() {
    beego.Router("/", &MainController{})
    beego.Run()
}

MVC 架构​

1. Controller (控制器)​

package controllers

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

type UserController struct {
    beego.Controller
}

// 获取用户列表
func (c *UserController) GetAll() {
    c.Data["json"] = map[string]interface{}{
        "users": []string{"Alice", "Bob"},
    }
    c.ServeJSON()
}

// 获取单个用户
func (c *UserController) GetOne() {
    id := c.Ctx.Input.Param(":id")
    c.Data["json"] = map[string]interface{}{
        "id":   id,
        "name": "Alice",
    }
    c.ServeJSON()
}

// 创建用户
func (c *UserController) Post() {
    name := c.GetString("name")
    email := c.GetString("email")

    c.Data["json"] = map[string]interface{}{
        "name":  name,
        "email": email,
    }
    c.ServeJSON()
}

// 更新用户
func (c *UserController) Put() {
    id := c.Ctx.Input.Param(":id")
    name := c.GetString("name")

    c.Data["json"] = map[string]interface{}{
        "id":   id,
        "name": name,
    }
    c.ServeJSON()
}

// 删除用户
func (c *UserController) Delete() {
    id := c.Ctx.Input.Param(":id")

    c.Data["json"] = map[string]interface{}{
        "message": "User " + id + " deleted",
    }
    c.ServeJSON()
}

2. Model (模型)​

package models

import (
    beego "github.com/beego/beego/v2/client/orm"
    _ "github.com/lib/pq"
)

type User struct {
    Id       int    `orm:"auto"`
    Name     string `orm:"size(100)"`
    Email    string `orm:"size(100);unique"`
    Password string `orm:"size(100)"`
    Created  time.Time `orm:"auto_now_add;type(datetime)"`
    Updated  time.Time `orm:"auto_now;type(datetime)"`
}

func init() {
    // 注册模型
    beego.RegisterModel(new(User))

    // 注册默认数据库
    beego.RegisterDriver("postgres", "github.com/lib/pq")
    beego.RegisterDataBase("default", "postgres", "user=password dbname=beego host=localhost port=5432 sslmode=disable")

    // 创建表
    beego.RunSyncdb("default", false, true)
}

// 增加用户
func AddUser(user *User) (int64, error) {
    o := beego.NewOrm()
    return o.Insert(user)
}

// 获取用户
func GetUser(id int) (*User, error) {
    o := beego.NewOrm()
    user := User{Id: id}
    err := o.Read(&user)
    return &user, err
}

// 获取所有用户
func GetAllUsers() ([]User, error) {
    o := beego.NewOrm()
    var users []User
    _, err := o.QueryTable("user").All(&users)
    return users, err
}

// 更新用户
func UpdateUser(user *User) (int64, error) {
    o := beego.NewOrm()
    return o.Update(user)
}

// 删除用户
func DeleteUser(id int) (int64, error) {
    o := beego.NewOrm()
    user := User{Id: id}
    return o.Delete(&user)
}

3. View (视图)​

<!-- views/layout.html -->
<!DOCTYPE html>
<html>
<head>
    <title>{{.title}}</title>
</head>
<body>
    {{.LayoutContent}}
</body>
</html>

<!-- views/user/index.html -->
<h1>User List</h1>
<ul>
{{range .users}}
    <li>{{.Name}} - {{.Email}}</li>
{{end}}
</ul>

<!-- views/user/detail.html -->
<h1>User Detail</h1>
<p>Name: {{.user.Name}}</p>
<p>Email: {{.user.Email}}</p>

路由配置​

1. 基本路由​

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

func init() {
    // 基本路由
    beego.Router("/", &controllers.MainController{})

    // 自动路由
    // 访问 /user/getall 调用 UserController.GetAll()
    beego.AutoRouter(&controllers.UserController{})

    // RESTful 路由
    beego.Router("/user", &controllers.UserController{})
    beego.Router("/user/:id", &controllers.UserController{})
}

2. 路由命名空间​

func init() {
    // 创建命名空间
    ns := beego.NewNamespace("/api",

        // API v1
        beego.NSNamespace("/v1",
            beego.NSInclude(
                &controllers.UserController{},
                &controllers.PostController{},
            ),
        ),

        // API v2
        beego.NSNamespace("/v2",
            beego.NSInclude(
                &controllers.UserControllerV2{},
            ),
        ),
    )

    beego.AddNamespace(ns)
}

3. 路由参数​

beego.Router("/user/:id", &controllers.UserController{})

// 在 Controller 中获取参数
func (c *UserController) Get() {
    id := c.Ctx.Input.Param(":id")
    // ...
}

// 正则表达式
beego.Router("/user/:id([0-9]+)", &controllers.UserController{})

ORM 操作​

1. 基本操作​

import beego "github.com/beego/beego/v2/client/orm"

// 插入
user := User{Name: "Alice", Email: "alice@example.com"}
o := beego.NewOrm()
id, err := o.Insert(&user)

// 查询
user = User{Id: 1}
err = o.Read(&user)

// 查询多个
var users []User
num, err := o.QueryTable("user").All(&users)

// 更新
user.Name = "Bob"
num, err = o.Update(&user)

// 删除
num, err = o.Delete(&user)

2. 高级查询​

o := beego.NewOrm()

// 条件查询
o.QueryTable("user").Filter("name", "Alice").One(&user)

// 多条件查询
o.QueryTable("user").
    Filter("name", "Alice").
    Filter("age__gte", 18).
    One(&user)

// 排序
o.QueryTable("user").OrderBy("-created").All(&users)

// 限制
o.QueryTable("user").Limit(10).All(&users)

// 分页
o.QueryTable("user").Limit(10, 20).All(&users)

// 统计
count, _ := o.QueryTable("user").Count()

// 原生 SQL
var users []User
o.Raw("SELECT * FROM user WHERE age > ?", 18).QueryRows(&users)

中间件​

// 自定义中间件
func authMiddleware(ctx *context.Context) {
    token := ctx.Input.Header("Authorization")

    if token == "" {
        ctx.Output.SetStatus(401)
        ctx.Output.Body([]byte("Unauthorized"))
        return
    }

    // 验证 token
    // ...
}

// 全局中间件
beego.InsertFilter("/*", beego.BeforeRouter, authMiddleware)

// 路由级别中间件
beego.InsertFilter("/api/*", beego.BeforeRouter, authMiddleware)

// 使用 Prepare 方法
func (c *BaseController) Prepare() {
    // 认证检查
    token := c.Ctx.Input.Header("Authorization")
    if token == "" {
        c.Data["json"] = map[string]string{"error": "Unauthorized"}
        c.ServeJSON()
        return
    }
}

配置管理​

1. 配置文件​

# conf/app.conf
appname = my-project
httpport = 8080
runmode = dev

# 数据库配置
dbname = testdb
dbuser = root
dbpassword = password
dbhost = 127.0.0.1
dbport = 3306

# Session 配置
sessionon = true
sessionprovider = redis
sessionprovidersavepath = 127.0.0.1:6379

2. 读取配置​

// 读取配置
appname := beego.AppConfig.String("appname")
port := beego.AppConfig.Int("httpport")
runmode := beego.AppConfig.String("runmode")

// 自定义配置
beego.AppConfig.Set("mykey", "myvalue")
myvalue := beego.AppConfig.String("mykey")

日志系统​

import beego "github.com/beego/beego/v2/core/logs"

// 初始化日志
logs.SetLogger(logs.AdapterFile, `{"filename":"test.log"}`)

// 设置日志级别
logs.SetLevel(logs.LevelInformational)

// 记录日志
logs.Info("This is info")
logs.Warning("This is warning")
logs.Error("This is error")
logs.Debug("This is debug")

// 异步日志
logs.Async(1000)

缓存系统​

import beego "github.com/beego/beego/v2/client/cache"

// 内存缓存
bm, err := cache.NewCache("memory", `{"interval":60}`)

// Redis 缓存
bm, err := cache.NewCache("redis", `{"conn":"127.0.0.1:6379"}`)

// 使用缓存
bm.Put("key", "value", 10*time.Second)
value := bm.Get("key")
bm.Delete("key")

Session 管理​

// 内存 Session
beego.BConfig.WebConfig.Session.SessionProviderConfig = ``

// Redis Session
beego.BConfig.WebConfig.Session.SessionProvider = "redis"
beego.BConfig.WebConfig.Session.SessionProviderConfig = `{"savePath":"127.0.0.1:6379"}`

// 在 Controller 中使用 Session
func (c *UserController) Get() {
    // 设置 Session
    c.SetSession("user", "Alice")

    // 获取 Session
    user := c.GetSession("user")

    // 删除 Session
    c.DelSession("user")

    // 销毁 Session
    c.DestroySession()
}

实战示例​

RESTful API​

package main

import (
    beego "github.com/beego/beego/v2/server/web"
    _ "my-project/routers"
)

func main() {
    beego.Run()
}

// routers/router.go
package routers

import (
    beego "github.com/beego/beego/v2/server/web"
    "my-project/controllers"
)

func init() {
    beego.Router("/", &controllers.MainController{})

    // 用户相关路由
    beego.Router("/api/users", &controllers.UserController{})
    beego.Router("/api/users/:id:int", &controllers.UserController{})
}

// controllers/user.go
package controllers

import (
    beego "github.com/beego/beego/v2/server/web"
    "my-project/models"
)

type UserController struct {
    beego.Controller
}

func (c *UserController) GetAll() {
    users, err := models.GetAllUsers()
    if err != nil {
        c.Data["json"] = map[string]string{"error": err.Error()}
        c.ServeJSON()
        return
    }

    c.Data["json"] = users
    c.ServeJSON()
}

func (c *UserController) GetOne() {
    id, _ := c.GetInt(":id")

    user, err := models.GetUser(id)
    if err != nil {
        c.Data["json"] = map[string]string{"error": "User not found"}
        c.ServeJSON()
        return
    }

    c.Data["json"] = user
    c.ServeJSON()
}

func (c *UserController) Post() {
    var user models.User
    json.Unmarshal(c.Ctx.Input.RequestBody, &user)

    id, err := models.AddUser(&user)
    if err != nil {
        c.Data["json"] = map[string]string{"error": err.Error()}
        c.ServeJSON()
        return
    }

    user.Id = int(id)
    c.Data["json"] = user
    c.ServeJSON()
}

最佳实践​

1. 项目结构​

my-project/
├── conf/
│   └── app.conf
├── controllers/
│   └── user.go
├── models/
│   └── user.go
├── routers/
│   └── router.go
├── views/
│   └── user/
│       └── index.html
├── static/
│   ├── css/
│   ├── js/
│   └── img/
└── main.go

2. 错误处理​

type Response struct {
    Code    int         `json:"code"`
    Message string      `json:"message"`
    Data    interface{} `json:"data,omitempty"`
}

func sendResponse(c *beego.Controller, code int, message string, data interface{}) {
    c.Data["json"] = Response{
        Code:    code,
        Message: message,
        Data:    data,
    }
    c.ServeJSON()
}

3. 参数验证​

func (c *UserController) Post() {
    name := c.GetString("name")
    email := c.GetString("email")

    if name == "" {
        c.Data["json"] = map[string]string{"error": "Name is required"}
        c.ServeJSON()
        return
    }

    if email == "" {
        c.Data["json"] = map[string]string{"error": "Email is required"}
        c.ServeJSON()
        return
    }

    // 处理逻辑
}

总结​

Beego 是一个功能全面的全栈 Web 框架，提供了从路由、ORM、缓存到日志的完整解决方案。它特别适合需要快速开发企业级 Web 应用的场景。虽然功能丰富，但也因此相对复杂一些，对于追求简洁和极致性能的项目，可以考虑使用更轻量的框架。

参考资料​

最后由 Embrace 于 更新