beego入門文檔

轉自：https://my.oschina.net/astaxie/blog/124040

你對beego一無所知？沒關系，這篇文檔會很好的詳細介紹beego的各個方面，看這個文檔之前首先確認你已經安裝了beego，如果你沒有安裝的話，請看這篇安裝指南

導航

• 最小應用
• 新建項目
• 開發模式
• 路由設置
• 靜態文件
• 過濾和中間件
• Controller設計
• 模板處理
• request處理
• 跳轉和錯誤
• response處理
• Sessions
• Cache設置
• 安全的Map
• 日志處理
• 配置管理
• beego參數
• 第三方應用集成
• 部署編譯應用

最小應用

一個最小最簡單的應用如下代碼所示：

package mainimport ("github.com/astaxie/beego" )type MainController struct {beego.Controller }func (this *MainController) Get() {this.Ctx.WriteString("hello world") }func main() {beego.Router("/", &MainController{})beego.Run() }

把上面的代碼保存為hello.go，然后通過命令行進行編譯并執行：

$ go build main.go $ ./hello

這個時候你可以打開你的瀏覽器，通過這個地址瀏覽http://127.0.0.1:8080返回“hello world”

那么上面的代碼到底做了些什么呢？

1、首先我們引入了包github.com/astaxie/beego,我們知道Go語言里面引入包會深度優先的去執行引入包的初始化(變量和init函數，更多)，beego包中會初始化一個BeeAPP的應用，初始化一些參數。

2、定義Controller，這里我們定義了一個struct為MainController，充分利用了Go語言的組合的概念，匿名包含了beego.Controller，這樣我們的MainController就擁有了beego.Controller的所有方法。

3、定義RESTFul方法，通過匿名組合之后，其實目前的MainController已經擁有了Get、Post、Delete、Put等方法，這些方法是分別用來對應用戶請求的Method函數，如果用戶發起的是POST請求，那么就執行Post函數。所以這里我們定義了MainController的Get方法用來重寫繼承的Get函數，這樣當用戶GET請求的時候就會執行該函數。

4、定義main函數，所有的Go應用程序和C語言一樣都是Main函數作為入口，所以我們這里定義了我們應用的入口。

5、Router注冊路由，路由就是告訴beego，當用戶來請求的時候，該如何去調用相應的Controller，這里我們注冊了請求/的時候，請求到MainController。這里我們需要知道，Router函數的兩個參數函數，第一個是路徑，第二個是Controller的指針。

6、Run應用，最后一步就是把在1中初始化的BeeApp開啟起來，其實就是內部監聽了8080端口:Go默認情況會監聽你本機所有的IP上面的8080端口

停止服務的話，請按ctrl+c

新建項目

通過如下命令創建beego項目，首先進入gopath目錄

bee create hello

這樣就建立了一個項目hello，目錄結構如下所示

. ├── conf │ └── app.conf ├── controllers │ └── default.go ├── main.go ├── models ├── static │ ├── css │ ├── img │ └── js └── views└── index.tpl

開發模式

通過bee創建的項目，beego默認情況下是開發模式。

我們可以通過如下的方式改變我們的模式：

beego.RunMode = "pro"

或者我們在conf/app.conf下面設置如下：

runmode = pro

以上兩種效果一樣。

開發模式中

• 開發模式下，如果你的目錄不存在views目錄，那么會出現類似下面的錯誤提示：

  2013/04/13 19:36:17 [W] [stat views: no such file or directory]

• 模板會自動重新加載不緩存。

• 如果服務端出錯，那么就會在瀏覽器端顯示如下類似的截圖：

路由設置

路由的主要功能是實現從請求地址到實現方法，beego中封裝了Controller，所以路由是從路徑到ControllerInterface的過程，ControllerInterface的方法有如下：

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

這些方法beego.Controller都已經實現了，所以只要用戶定義struct的時候匿名包含就可以了。當然更靈活的方法就是用戶可以去自定義類似的方法，然后實現自己的邏輯。

用戶可以通過如下的方式進行路由設置：

beego.Router("/", &controllers.MainController{}) beego.Router("/admin", &admin.UserController{}) beego.Router("/admin/index", &admin.ArticleController{}) beego.Router("/admin/addpkg", &admin.AddController{})

為了用戶更加方便的路由設置，beego參考了sinatra的路由實現，支持多種方式的路由：

• 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]+)

靜態文件

Go語言內部其實已經提供了http.ServeFile，通過這個函數可以實現靜態文件的服務。beego針對這個功能進行了一層封裝，通過下面的方式進行靜態文件注冊：

beego.SetStaticPath("/static","public")

• 第一個參數是路徑，url路徑信息
• 第二個參數是靜態文件目錄（相對應用所在的目錄）

beego支持多個目錄的靜態文件注冊，用戶可以注冊如下的靜態文件目錄：

beego.SetStaticPath("/images","images") beego.SetStaticPath("/css","css") beego.SetStaticPath("/js","js")

設置了如上的靜態目錄之后，用戶訪問/images/login/login.png，那么就會訪問應用對應的目錄下面的images/login/login.png文件。如果是訪問/static/img/logo.png，那么就訪問public/img/logo.png文件。

過濾和中間件

beego支持自定義過濾中間件，例如安全驗證，強制跳轉等

如下例子所示，驗證用戶名是否是admin，應用于全部的請求：

var FilterUser = func(w http.ResponseWriter, r *http.Request) {if r.URL.User == nil || r.URL.User.Username() != "admin" {http.Error(w, "", http.StatusUnauthorized)} }beego.Filter(FilterUser)

還可以通過參數進行過濾，如果匹配參數就執行

beego.Router("/:id([0-9]+)", &admin.EditController{}) beego.FilterParam("id", func(rw http.ResponseWriter, r *http.Request) {dosomething() })

當然你還可以通過前綴過濾

beego.FilterPrefixPath("/admin", func(rw http.ResponseWriter, r *http.Request) {dosomething() })

控制器設計

基于beego的Controller設計，只需要匿名組合beego.Controller就可以了，如下所示：

type xxxController struct {beego.Controller }

beego.Controller實現了接口beego.ControllerInterface，beego.ControllerInterface定義了如下函數：

• Init(ct *Context, cn string)

  這個函數主要初始化了Context、相應的Controller名稱，模板名，初始化模板參數的容器Data

• Prepare()

  這個函數主要是為了用戶擴展用的，這個函數會在下面定義的這些Method方法之前執行，用戶可以重寫這個函數實現類似用戶驗證之類。

• Get()

  如果用戶請求的HTTP Method是GET, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Get請求.

• Post()

  如果用戶請求的HTTP Method是POST, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Post請求.

• Delete()

  如果用戶請求的HTTP Method是DELETE, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Delete請求.

• Put()

  如果用戶請求的HTTP Method是PUT, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Put請求.

• Head()

  如果用戶請求的HTTP Method是HEAD, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Head請求.

• Patch()

  如果用戶請求的HTTP Method是PATCH, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Patch請求.

• Options()

  如果用戶請求的HTTP Method是OPTIONS, 那么就執行該函數，默認是403，用戶繼承的子struct中可以實現了該方法以處理Options請求.

• Finish()

  這個函數實在執行完相應的http Method方法之后執行的，默認是空，用戶可以在子Strcut中重寫這個函數，執行例如數據庫關閉，清理數據之類的工作

• Render() error

  這個函數主要用來實現渲染模板，如果beego.AutoRender為true的情況下才會執行。

所以通過子struct的方法重寫，用戶就可以實現自己的邏輯，接下來我們看一個實際的例子：

type AddController struct {beego.Controller }func (this *AddController) Prepare() {}func (this *AddController) Get() {this.Data["content"] ="value"this.Layout = "admin/layout.html"this.TplNames = "admin/add.tpl" }func (this *AddController) Post() {pkgname := this.GetString("pkgname")content := this.GetString("content")pk := models.GetCruPkg(pkgname)if pk.Id == 0 {var pp models.PkgEntitypp.Pid = 0pp.Pathname = pkgnamepp.Intro = pkgnamemodels.InsertPkg(pp)pk = models.GetCruPkg(pkgname)}var at models.Articleat.Pkgid = pk.Idat.Content = contentmodels.InsertArticle(at)this.Ctx.Redirect(302, "/admin/index") }

模板處理

模板目錄

beego中默認的模板目錄是views，用戶可以把你的模板文件放到該目錄下，beego會自動在該目錄下的所有模板文件進行解析并緩存，開發模式下會每次重新解析，不做緩存。當然用戶可以通過如下的方式改變模板的目錄：

beego.ViewsPath = "/myviewpath"

自動渲染

beego中用戶無需手動的調用渲染輸出模板，beego會自動的在調用玩相應的method方法之后調用Render函數，當然如果你的應用是不需要模板輸出的，那么你可以在配置文件或者在main.go中設置關閉自動渲染。

配置文件配置如下：

autorender = false

main.go文件中設置如下：

beego.AutoRender = false

模板數據

模板中的數據是通過在Controller中this.Data獲取的，所以如果你想在模板中獲取內容{{.Content}},那么你需要在Controller中如下設置：

this.Data["Context"] = "value"

模板名稱

beego采用了Go語言內置的模板引擎，所有模板的語法和Go的一模一樣，至于如何寫模板文件，詳細的請參考模板教程。

用戶通過在Controller的對應方法中設置相應的模板名稱，beego會自動的在viewpath目錄下查詢該文件并渲染，例如下面的設置，beego會在admin下面找add.tpl文件進行渲染：

this.TplNames = "admin/add.tpl"

我們看到上面的模板后綴名是tpl，beego默認情況下支持tpl和html后綴名的模板文件，如果你的后綴名不是這兩種，請進行如下設置：

beego.AddTemplateExt("你文件的后綴名")

當你設置了自動渲染，然后在你的Controller中沒有設置任何的TplNames，那么beego會自動設置你的模板文件如下：

c.TplNames = c.ChildName + "/" + c.Ctx.Request.Method + "." + c.TplExt

也就是你對應的Controller名字+請求方法名.模板后綴，也就是如果你的Controller名是AddController，請求方法是POST，默認的文件后綴是tpl，那么就會默認請求/viewpath/AddController/POST.tpl文件。

lauout設計

beego支持layout設計，例如你在管理系統中，其實整個的管理界面是固定的，支會變化中間的部分，那么你可以通過如下的設置：

this.Layout = "admin/layout.html" this.TplNames = "admin/add.tpl"

在layout.html中你必須設置如下的變量：

{{.LayoutContent}}

beego就會首先解析TplNames指定的文件，獲取內容賦值給LayoutContent，然后最后渲染layout.html文件。

目前采用首先把目錄下所有的文件進行緩存，所以用戶還可以通過類似這樣的方式實現layout：

{{template "header.html"}} 處理邏輯 {{template "footer.html"}}

模板函數

beego支持用戶定義模板函數，但是必須在beego.Run()調用之前，設置如下：

func hello(in string)(out string){out = in + "world"return }beego.AddFuncMap("hi",hello)

定義之后你就可以在模板中這樣使用了：

{{.Content | hi}}

目前beego內置的模板函數有如下：

• markdown

  實現了把markdown文本轉化為html信息，使用方法{{markdown .Content}}

• dateformat

  實現了時間的格式化，返回字符串，使用方法{{dateformat .Time "2006-01-02T15:04:05Z07:00"}}

• date

  實現了類似PHP的date函數，可以很方便的根據字符串返回時間，使用方法{{date .T "Y-m-d H:i:s"}}

• compare

  實現了比較兩個對象的比較，如果相同返回true，否者false，使用方法{{compare .A .B}}

• substr

  實現了字符串的截取，支持中文截取的完美截取，使用方法{{substr .Str 0 30}}

• html2str

  實現了把html轉化為字符串，剔除一些script、css之類的元素，返回純文本信息，使用方法{{html2str .Htmlinfo}}

• str2html

  實現了把相應的字符串當作HTML來輸出，不轉義，使用方法{{str2html .Strhtml}}

• htmlquote

  實現了基本的html字符轉義，使用方法{{htmlquote .quote}}

• htmlunquote

  實現了基本的反轉移字符，使用方法{{htmlunquote .unquote}}

request處理

我們經常需要獲取用戶傳遞的數據，包括Get、POST等方式的請求，beego里面會自動解析這些數據，你可以通過如下方式獲取數據

• GetString(key string) string
• GetInt(key string) (int64, error)
• GetBool(key string) (bool, error)

使用例子如下：

func (this *MainController) Post() {jsoninfo := this.GetString("jsoninfo")if jsoninfo == "" {this.Ctx.WriteString("jsoninfo is empty")return} }

如果你需要的數據可能是其他類型的，例如是int類型而不是int64，那么你需要這樣處理：

func (this *MainController) Post() {id := this.Input().Get("id")intid, err := strconv.Atoi(id) }

更多其他的request的信息，用戶可以通過this.Ctx.Request獲取信息，關于該對象的屬性和方法參考手冊Request

文件上傳

在beego中你可以很容易的處理文件上傳，就是別忘記在你的form表單中增加這個屬性enctype="multipart/form-data"，否者你的瀏覽器不會傳輸你的上傳文件。

文件上傳之后一般是放在系統的內存里面，如果文件的size大于設置的緩存內存大小，那么就放在臨時文件中，默認的緩存內存是64M，你可以通過如下來調整這個緩存內存大小:

beego.MaxMemory = 1<<22

或者在配置文件中通過如下設置

maxmemory = 1<<22

beego提供了兩個很方便的方法來處理文件上傳：

• GetFile(key string) (multipart.File, *multipart.FileHeader, error)

  該方法主要用于用戶讀取表單中的文件名the_file，然后返回相應的信息，用戶根據這些變量來處理文件上傳：過濾、保存文件等。

• SaveToFile(fromfile, tofile string) error

  該方法是在GetFile的基礎上實現了快速保存的功能

保存的代碼例子如下：

func (this *MainController) Post() {this.SaveToFile("the_file","/var/www/uploads/uploaded_file.txt"") }

JSON和XML輸出

beego當初設計的時候就考慮了API功能的設計，而我們在設計API的時候經常是輸出JSON或者XML數據，那么beego提供了這樣的方式直接輸出：

JSON數據直接輸出，設置content-type為application/json：

func (this *AddController) Get() {mystruct := { ... }this.Data["json"] = &mystructthis.ServeJson() }

XML數據直接輸出，設置content-type為application/xml：

func (this *AddController) Get() {mystruct := { ... }this.Data["xml"]=&mystructthis.ServeXml() }

跳轉和錯誤

我們在做Web開發的時候，經常會遇到頁面調整和錯誤處理，beego這這方面也進行了考慮，通過Redirect方法來進行跳轉：

func (this *AddController) Get() {this.Redirect("/", 302) }

@todo?錯誤處理還需要后期改進

response處理

response可能會有集中情況：

模板輸出

模板輸出上面模板介紹里面已經介紹，beego會在執行完相應的Controller里面的對應的Method之后輸出到模板。

跳轉

上一節介紹的跳轉就是我們經常用到的頁面之間的跳轉

字符串輸出

有些時候我們只是想輸出相應的一個字符串，那么我們可以通過如下的代碼實現

this.Ctx.WriteString("ok")

Sessions

beego內置了session模塊，目前session模塊支持的后端引擎包括memory、file、mysql、redis四中，用戶也可以根據相應的interface實現自己的引擎。

beego中使用session相當方便，只要在main入口函數中設置如下：

beego.SessionOn = true

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

sessionon = true

通過這種方式就可以開啟session，如何使用session，請看下面的例子：

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

上面的例子中我們知道session有幾個方便的方法：

• SetSession(name string, value interface{})
• GetSession(name string) interface{}
• DelSession(name string)

session操作主要有設置session、獲取session、刪除session

當然你要可以通過下面的方式自己控制相應的邏輯這些邏輯：

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

sess對象具有如下方法：

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

但是我還是建議大家采用SetSession、GetSession、DelSession三個方法來操作，避免自己在操作的過程中資源沒釋放的問題。

關于Session模塊使用中的一些參數設置：

• SessionOn

  設置是否開啟Session，默認是false，配置文件對應的參數名：sessionon

• SessionProvider

  設置Session的引擎，默認是memory，目前支持還有file、mysql、redis等，配置文件對應的參數名：sessionprovider

• SessionName

  設置cookies的名字，Session默認是保存在用戶的瀏覽器cookies里面的，默認名是beegosessionID，配置文件對應的參數名是：sessionname

• SessionGCMaxLifetime

  設置Session過期的時間，默認值是3600秒，配置文件對應的參數：sessiongcmaxlifetime

• SessionSavePath

  設置對應file、mysql、redis引擎的保存路徑或者鏈接地址，默認值是空，配置文件對應的參數：sessionsavepath

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

Cache設置

beego內置了一個cache模塊，實現了類似memcache的功能，緩存數據在內存中，主要的使用方法如下：

var (urllist *beego.BeeCache )func init() {urllist = beego.NewBeeCache()urllist.Every = 0 //不過期urllist.Start() }func (this *ShortController) Post() {var result ShortResultlongurl := this.Input().Get("longurl")beego.Info(longurl)result.UrlLong = longurlurlmd5 := 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"] = resultthis.ServeJson() }

上面這個例子演示了如何使用beego的Cache模塊，主要是通過beego.NewBeeCache初始化一個對象，然后設置過期時間，開啟過期檢測，在業務邏輯中就可以通過如下的接口進行增刪改的操作：

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

安全的Map

我們知道在Go語言里面map是非線程安全的，詳細的atomic_maps。但是我們在平常的業務中經常需要用到線程安全的map，特別是在goroutine的情況下，所以beego內置了一個簡單的線程安全的map：

bm := NewBeeMap() if !bm.Set("astaxie", 1) {t.Error("set Error") } if !bm.Check("astaxie") {t.Error("check err") }if v := bm.Get("astaxie"); v.(int) != 1 {t.Error("get err") }bm.Delete("astaxie") if bm.Check("astaxie") {t.Error("delete err") }

上面演示了如何使用線程安全的Map，主要的接口有：

• Get(k interface{}) interface{}
• Set(k interface{}, v interface{}) bool
• Check(k interface{}) bool
• Delete(k interface{})

日志處理

beego默認有一個初始化的BeeLogger對象輸出內容到stdout中，你可以通過如下的方式設置自己的輸出：

beego.SetLogger(*log.Logger)

只要你的輸出符合*log.Logger就可以，例如輸出到文件：

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)

不同級別的log日志函數

• Trace(v ...interface{})
• Debug(v ...interface{})
• Info(v ...interface{})
• Warn(v ...interface{})
• Error(v ...interface{})
• Critical(v ...interface{})

你可以通過下面的方式設置不同的日志分級：

beego.SetLevel(beego.LevelError)

當你代碼中有很多日志輸出之后，如果想上線，但是你不想輸出Trace、Debug、Info等信息，那么你可以設置如下：

beego.SetLevel(beego.LevelWarning)

這樣的話就不會輸出小于這個level的日志，日志的排序如下：

LevelTrace、LevelDebug、LevelInfo、LevelWarning、 LevelError、LevelCritical

用戶可以根據不同的級別輸出不同的錯誤信息，如下例子所示：

Examples of log messages

• Trace

  • "Entered parse function validation block"
  • "Validation: entered second 'if'"
  • "Dictionary 'Dict' is empty. Using default value"

• Debug

  • "Web page requested:?http://somesite.com?Params='...'"
  • "Response generated. Response size: 10000. Sending."
  • "New file received. Type:PNG Size:20000"

• Info

  • "Web server restarted"
  • "Hourly statistics: Requested pages: 12345 Errors: 123 ..."
  • "Service paused. Waiting for 'resume' call"

• Warn

  • "Cache corrupted for file='test.file'. Reading from back-end"
  • "Database 192.168.0.7/DB not responding. Using backup 192.168.0.8/DB"
  • "No response from statistics server. Statistics not sent"

• Error

  • "Internal error. Cannot process request #12345 Error:...."
  • "Cannot perform login: credentials DB not responding"

• Critical

  • "Critical panic received: .... Shutting down"
  • "Fatal error: ... App is shutting down to prevent data corruption or loss"

Example

func internalCalculationFunc(x, y int) (result int, err error) {beego.Debug("calculating z. x:",x," y:",y)z := yswitch {case x == 3 :beego.Trace("x == 3")panic("Failure.")case y == 1 :beego.Trace("y == 1")return 0, errors.New("Error!")case y == 2 :beego.Trace("y == 2")z = xdefault :beego.Trace("default")z += x}retVal := z-3beego.Debug("Returning ", retVal)return retVal, nil } func processInput(input inputData) {defer func() {if r := recover(); r != nil {beego.Error("Unexpected error occurred: ", r)outputs <- outputData{result : 0, error : true}}}()beego.Info("Received input signal. x:",input.x," y:", input.y) res, err := internalCalculationFunc(input.x, input.y) if err != nil {beego.Warn("Error in calculation:", err.Error())}beego.Info("Returning result: ",res," error: ",err) outputs <- outputData{result : res, error : err != nil} }func main() {inputs = make(chan inputData)outputs = make(chan outputData)criticalChan = make(chan int)beego.Info("App started.")go consumeResults(outputs)beego.Info("Started receiving results.")go generateInputs(inputs)beego.Info("Started sending signals.")for {select {case input := <- inputs:processInput(input)case <- criticalChan:beego.Critical("Caught value from criticalChan: Go shut down.")panic("Shut down due to critical fault.")} } }

配置管理

beego支持解析ini文件, beego默認會解析當前應用下的conf/app.conf文件

通過這個文件你可以初始化很多beego的默認參數

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

上面這些參數會替換beego默認的一些參數。

你可以在配置文件中配置應用需要用的一些配置信息，例如下面所示的數據庫信息：

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

系統默認參數

beego中帶有很多可配置的參數，我們來一一認識一下它們，這樣有利于我們在接下來的beego開發中可以充分的發揮他們的作用：

• BeeApp

  beego默認啟動的一個應用器入口，在應用import beego的時候，在init中已經初始化的。

• AppConfig

  beego的配置文件解析之后的對象，也是在init的時候初始化的，里面保存有解析conf/app.conf下面所有的參數數據

• HttpAddr

  應用監聽地址，默認為空，監聽所有的網卡IP

• HttpPort

  應用監聽端口，默認為8080

• AppName

  應用名稱，默認是beego

• RunMode

  應用的模式，默認是dev，為開發模式，在開發模式下出錯會提示友好的出錯頁面，如前面錯誤描述中所述。

• AutoRender

  是否模板自動渲染，默認值為true，對于API類型的應用，應用需要把該選項設置為false，不需要渲染模板。

• RecoverPanic

  是否異常恢復，默認值為true，即當應用出現異常的情況，通過recover恢復回來，而不會導致應用異常退出。

• PprofOn

  是否啟用pprof，默認是false，當開啟之后，用戶可以通過如下地址查看相應的goroutine執行情況

  /debug/pprof /debug/pprof/cmdline /debug/pprof/profile /debug/pprof/symbol

  關于pprof的信息，請參考官方的描述pprof

• ViewsPath

  模板路徑，默認值是views

• SessionOn

  session是否開啟，默認是false

• SessionProvider

  session的引擎，默認是memory

• SessionName

  存在客戶端的cookie名稱，默認值是beegosessionID

• SessionGCMaxLifetime

  session過期時間，默認值是3600秒

• SessionSavePath

  session保存路徑，默認是空

• UseFcgi

  是否啟用fastcgi，默認是false

• MaxMemory

  文件上傳默認內存緩存大小，默認值是1 << 26(64M)

第三方應用集成

beego支持第三方應用的集成，用戶可以自定義http.Handler,用戶可以通過如下方式進行注冊路由：

beego.RouterHandler("/chat/:info(.*)", sockjshandler)

sockjshandler實現了接口http.Handler。

目前在beego的example中有支持sockjs的chat例子，示例代碼如下：

package mainimport ("fmt""github.com/astaxie/beego""github.com/fzzy/sockjs-go/sockjs""strings" )var users *sockjs.SessionPool = sockjs.NewSessionPool()func chatHandler(s sockjs.Session) {users.Add(s)defer users.Remove(s)for {m := s.Receive()if m == nil {break}fullAddr := s.Info().RemoteAddraddr := fullAddr[:strings.LastIndex(fullAddr, ":")]m = []byte(fmt.Sprintf("%s: %s", addr, m))users.Broadcast(m)} }type MainController struct {beego.Controller }func (m *MainController) Get() {m.TplNames = "index.html" }func main() {conf := sockjs.NewConfig()sockjshandler := sockjs.NewHandler("/chat", chatHandler, conf)beego.Router("/", &MainController{})beego.RouterHandler("/chat/:info(.*)", sockjshandler)beego.Run() }

通過上面的代碼很簡單的實現了一個多人的聊天室。上面這個只是一個sockjs的例子，我想通過大家自定義http.Handler，可以有很多種方式來進行擴展beego應用。

部署編譯應用

Go語言的應用最后編譯之后是一個二進制文件，你只需要copy這個應用到服務器上，運行起來就行。beego由于帶有幾個靜態文件、配置文件、模板文件三個目錄，所以用戶部署的時候需要同時copy這三個目錄到相應的部署應用之下，下面以我實際的應用部署為例：

$ mkdir /opt/app/beepkg $ cp beepkg /opt/app/beepkg $ cp -fr views /opt/app/beepkg $ cp -fr static /opt/app/beepkg $ cp -fr conf /opt/app/beepkg

這樣在/opt/app/beepkg目錄下面就會顯示如下的目錄結構：

. ├── conf │ ├── app.conf ├── static │ ├── css │ ├── img │ └── js └── views└── index.tpl ├── beepkg

這樣我們就已經把我們需要的應用搬到服務器了，那么接下來就可以開始部署了，我現在服務器端用兩種方式來run，

• Supervisord

  安裝和配置見Supervisord

• nohup方式

  nohup ./beepkg &

個人比較推薦第一種方式，可以很好的管理起來應用

總結

以上是生活随笔為你收集整理的beego入门文档的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。