begoo——路由設置

時間 2019-11-18

原文原文鏈接

路由本質是URL與要爲該URL調用的視圖函數之間的映射表，其實就是你定義的使用那個URL調用那段代碼的關係對應表。html

首先看一下最簡單的路由：node

package routers

import (
	"pro1/controllers"
	"github.com/astaxie/beego"
)

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

以及對應的控制器函數：ios

package controllers

import (
	"github.com/astaxie/beego"
)

type MainController struct {
	beego.Controller
}

func (c *MainController) Get() {
	c.Data["Website"] = "beego.me"
	c.Data["Email"] = "astaxie@gmail.com"
	c.TplName = "index.tpl"
}

基礎路由

從beego1.2版本開始支持基本的RESTful函數式路由，應用中大多數路由都會定義在routers/router.go文件中。git

基本GET路由

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

基本POST路由

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

註冊一個能夠響應任何HTTP的路由

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

全部的支持的基礎函數以下所示

beego.Get(router, beego.FilterFunc)
beego.Post(router, beego.FilterFunc)
beego.Put(router, beego.FilterFunc)
beego.Patch(router, beego.FilterFunc)
beego.Head(router, beego.FilterFunc)
beego.Options(router, beego.FilterFunc)
beego.Delete(router, beego.FilterFunc)
beego.Any(router, beego.FilterFunc)

支持自定義的handler實現

有時候咱們已經實現了一些rpc的應用，可是想要集成到beego中，或者其它的httpserver應用集成到beego中來，如今能夠很方便的集成。github

s := rpc.NewServer()
s.RegisterCodec(json.NewCodec(), "application/json")
s.RegisterService(new(HelloService), "")
beego.Handler("/rpc", s)

beego.Handler(router, http.Handler)這個函數是關鍵，第一個參數表示路由URL，第二個就是你本身實現的http.Handler，註冊時候就會把全部rpc做爲前綴的請求分發到http.handler中進行處理。json

這個函數其實還有第三個參數就是是不是前綴匹配，默認是false，若是這隻了true，那麼就會在路由匹配的時候前綴匹配，即/rpc/user這樣的也會匹配去運行。api

固定路由

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

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

如上所示的路由就是咱們最經常使用的路由方式，一個固定的路由，一個控制器，而後根據用戶請求方法的不一樣請求控制器中對應的方法。框架

正則路由

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

（1）beego.Router(「/api/?:id」, &controllers.RController{})

　　?表示匹配0個或1個任意字符，例如對於URL」/api/123」能夠匹配成功，此時變量」:id」值爲」123」。

（2）beego.Router(「/api/:id」, &controllers.RController{})

　　例如對於URL」/api/123」能夠匹配成功，此時變量」:id」值爲」123」，但URL」/api/「匹配失敗。

（3）beego.Router(「/api/:id([0-9]+)「, &controllers.RController{})

　　+表示匹配一個或多個任意字符，例如對於URL」/api/123」能夠匹配成功，此時變量」:id」值爲」123」。

（4）beego.Router(「/user/:username([\\w]+)「, &controllers.RController{})

　　\w表示匹配數字、字母和下劃線，例如對於URL」/user/astaxie」能夠匹配成功，此時變量」:username」值爲」astaxie」

（5）beego.Router(「/download/*.*」, &controllers.RController{})

　　例如對於URL」/download/file/api.xml」能夠匹配成功，此時變量」:path」值爲」file/api」，「:ext」值爲」xml」

（6）beego.Router(「/download/ceshi/*「, &controllers.RController{})

　　例如對於URL」/download/ceshi/file/api.json」能夠匹配成功，此時變量」:splat」值爲」file/api.json」

（7）beego.Router(「/:id:int」, &controllers.RController{})

　　int 類型設置方式，匹配 :id爲int 類型，框架幫你實現了正則 ([0-9]+)

（8）beego.Router(「/:hi:string」, &controllers.RController{})

　　string 類型設置方式，匹配 :hi 爲 string 類型。框架幫你實現了正則 ([\w]+)

（9）beego.Router(「/cms_:id([0-9]+).html」, &controllers.CmsController{})

　　帶有前綴的自定義正則 //匹配 :id 爲正則類型。匹配 cms_123.html 這樣的 url :id = 123

能夠在Controller中經過以下方式獲取上面的變量。

this.Ctx.Input.Param(":id")
this.Ctx.Input.Param(":username")
this.Ctx.Input.Param(":splat")
this.Ctx.Input.Param(":path")
this.Ctx.Input.Param(":ext")

自定義方法及RESTful規則

上面列舉的是默認的請求方法名（請求的method和函數名一致，例如Get請求執行Get函數），若是用戶指望自定義函數名，那麼可使用以下方式：

beego.Router("/",&IndexController{},"*:Index")

使用第三個參數，第三個參數就是用來設置對應method到函數名，定義以下：

*表示任意的method都執行該函數
使用httpmethod：funcname格式來顯式
多個不一樣的格式使用；分割
多個method對應同一個funcname，method之間經過「，」來分割

如下是一個RESTful的設計示例：

beego.Router("/api/list",&RestController{},"*:ListFood")
beego.Router("/api/create",&RestController{},"post:CreateFood")
beego.Router("/api/update",&RestController{},"put:UpdateFood")
beego.Router("/api/delete",&RestController{},"delete:DeleteFood")

如下是多個HTTP Method指向同一個函數的示例：

beego.Router("/api",&RestController{},"get,post:ApiFunc")

如下是不一樣的method對應不一樣的函數，經過「；」進行分割的示例：

beego.Router("/simple",&SimpleController{},"get:GetFunc;post:PostFunc")

可用的HTTP Method：

*: 包含如下全部的函數
get: GET 請求
post: POST 請求
put: PUT 請求
delete: DELETE 請求
patch: PATCH 請求
options: OPTIONS 請求
head: HEAD 請求

若是同時存在*和對應的HTTP Method，那麼優先執行HTTP Method方法，例如同時註冊了以下所示的路由：

beego.Router("/simple",&SimpleController{},"*:AllFunc;post:PostFunc")

那麼執行Post請求的時候，執行PostFunc而不執行AllFunc。

自定義函數的路由默認不支持RESTful方法，也就是若是你設置了beego.Router("/api",&RestController{},"post:ApiFunc")這樣的路由，若是請求的方法是POST，那麼不會默認去執行Post函數。

自動匹配

用戶首先須要把須要路由的控制器註冊到自動路由中：

beego.AutoRouter(&controllers.ObjectController{})

那麼beego就會經過反射獲取該結構體中全部的實現方法，你能夠經過以下方式訪問到對應的方法中：

/object/login   調用 ObjectController 中的 Login 方法
/object/logout  調用 ObjectController 中的 Logout 方法

除了前綴兩個 /:controller/:method 的匹配以外，剩下的 url beego 會幫你自動化解析爲參數，保存在 this.Ctx.Input.Params 當中：

/object/blog/2013/09/12  調用 ObjectController 中的 Blog 方法，參數以下：map[0:2013 1:09 2:12]

方法名在內部是保存了用戶設置的，例如 Login，url 匹配的時候都會轉化爲小寫，因此，/object/LOGIN 這樣的 url 也同樣能夠路由到用戶定義的 Login 方法中。

如今已經能夠經過自動識別出來下面相似的全部 url，都會把請求分發到 controller 的 simple 方法：

/controller/simple
/controller/simple.html
/controller/simple.json
/controller/simple.xml

能夠經過 this.Ctx.Input.Param(":ext") 獲取後綴名。

註解路由

從beego 1.3版本開始支持註解路由，用戶無需在router中註冊路由，只須要include相應的controller，

而後在controller的method方法上面寫上router註釋（//@router）就能夠了，詳細的使用請看下面的例子：

// CMS API
type CMSController struct {
    beego.Controller
}

func (c *CMSController) URLMapping() {
    c.Mapping("StaticBlock", c.StaticBlock)
    c.Mapping("AllBlock", c.AllBlock)
}


// @router /staticblock/:key [get]
func (this *CMSController) StaticBlock() {

}

// @router /all/:key [get]
func (this *CMSController) AllBlock() {

}

能夠在router.go中經過以下方式註冊路由：

beego.Include(&CMSController{})

beego自動會進行源碼分析，注意只會在dev模式下進行生成，生成的路由放在「/routers/commentsRouter.go」文件中。

這樣上面的路由就支持了以下的路由：

GET /staticblock/:key
GET /all/:key

其實效果和本身經過 Router 函數註冊是同樣的：

beego.Router("/staticblock/:key", &CMSController{}, "get:StaticBlock")
beego.Router("/all/:key", &CMSController{}, "get:AllBlock")

同時你們注意到新版本里面增長了 URLMapping 這個函數，這是新增長的函數，用戶若是沒有進行註冊，那麼就會經過反射來執行對應的函數，

若是註冊了就會經過 interface 來進行執行函數，性能上面會提高不少。

namespace

//初始化 namespace
ns :=
beego.NewNamespace("/v1",
    beego.NSCond(func(ctx *context.Context) bool {
        if ctx.Input.Domain() == "api.beego.me" {
            return true
        }
        return false
    }),
    beego.NSBefore(auth),
    beego.NSGet("/notallowed", func(ctx *context.Context) {
        ctx.Output.Body([]byte("notAllowed"))
    }),
    beego.NSRouter("/version", &AdminController{}, "get:ShowAPIVersion"),
    beego.NSRouter("/changepassword", &UserController{}),
    beego.NSNamespace("/shop",
        beego.NSBefore(sentry),
        beego.NSGet("/:id", func(ctx *context.Context) {
            ctx.Output.Body([]byte("notAllowed"))
        }),
    ),
    beego.NSNamespace("/cms",
        beego.NSInclude(
            &controllers.MainController{},
            &controllers.CMSController{},
            &controllers.BlockController{},
        ),
    ),
)
//註冊 namespace
beego.AddNamespace(ns)

上面這個代碼支持了以下這樣的請求 URL

GET /v1/notallowed
GET /v1/version
GET /v1/changepassword
POST /v1/changepassword
GET /v1/shop/123
GET /v1/cms/ 對應 MainController、CMSController、BlockController 中得註解路由

並且還支持前置過濾,條件判斷,無限嵌套 namespace

namespace 的接口以下:

NewNamespace(prefix string, funcs …interface{})

初始化 namespace 對象,下面這些函數都是 namespace 對象的方法,可是強烈推薦使用 NS 開頭的相應函數註冊，由於這樣更容易經過 gofmt 工具看的更清楚路由的級別關係
NSCond(cond namespaceCond)

支持知足條件的就執行該 namespace, 不知足就不執行
NSBefore(filiterList …FilterFunc)
NSAfter(filiterList …FilterFunc)

上面分別對應 beforeRouter 和 FinishRouter 兩個過濾器，能夠同時註冊多個過濾器
NSInclude(cList …ControllerInterface)
NSRouter(rootpath string, c ControllerInterface, mappingMethods …string)
NSGet(rootpath string, f FilterFunc)
NSPost(rootpath string, f FilterFunc)
NSDelete(rootpath string, f FilterFunc)
NSPut(rootpath string, f FilterFunc)
NSHead(rootpath string, f FilterFunc)
NSOptions(rootpath string, f FilterFunc)
NSPatch(rootpath string, f FilterFunc)
NSAny(rootpath string, f FilterFunc)
NSHandler(rootpath string, h http.Handler)
NSAutoRouter(c ControllerInterface)
NSAutoPrefix(prefix string, c ControllerInterface)

上面這些都是設置路由的函數,詳細的使用和上面 beego 的對應函數是同樣的
NSNamespace(prefix string, params …innnerNamespace)

嵌套其餘 namespace

ns :=
beego.NewNamespace("/v1",
    beego.NSNamespace("/shop",
        beego.NSGet("/:id", func(ctx *context.Context) {
            ctx.Output.Body([]byte("shopinfo"))
        }),
    ),
    beego.NSNamespace("/order",
        beego.NSGet("/:id", func(ctx *context.Context) {
            ctx.Output.Body([]byte("orderinfo"))
        }),
    ),
    beego.NSNamespace("/crm",
        beego.NSGet("/:id", func(ctx *context.Context) {
            ctx.Output.Body([]byte("crminfo"))
        }),
    ),
)

下面這些函數都是屬於 *Namespace 對象的方法：不建議直接使用，固然效果和上面的 NS 開頭的函數是同樣的，只是上面的方式更優雅，寫出來的代碼更容易看得懂

Cond(cond namespaceCond)

支持知足條件的就執行該 namespace, 不知足就不執行,例如你能夠根據域名來控制 namespace
Filter(action string, filter FilterFunc)

action 表示你須要執行的位置, before 和 after 分別表示執行邏輯以前和執行邏輯以後的 filter
Router(rootpath string, c ControllerInterface, mappingMethods …string)
AutoRouter(c ControllerInterface)
AutoPrefix(prefix string, c ControllerInterface)
Get(rootpath string, f FilterFunc)
Post(rootpath string, f FilterFunc)
Delete(rootpath string, f FilterFunc)
Put(rootpath string, f FilterFunc)
Head(rootpath string, f FilterFunc)
Options(rootpath string, f FilterFunc)
Patch(rootpath string, f FilterFunc)
Any(rootpath string, f FilterFunc)
Handler(rootpath string, h http.Handler)

上面這些都是設置路由的函數,詳細的使用和上面 beego 的對應函數是同樣的
Namespace(ns …*Namespace)

更多的例子代碼：

//APIS
ns :=
    beego.NewNamespace("/api",
        //此處正式版時改成驗證加密請求
        beego.NSCond(func(ctx *context.Context) bool {
            if ua := ctx.Input.Request.UserAgent(); ua != "" {
                return true
            }
            return false
        }),
        beego.NSNamespace("/ios",
            //CRUD Create(建立)、Read(讀取)、Update(更新)和Delete(刪除)
            beego.NSNamespace("/create",
                // /api/ios/create/node/
                beego.NSRouter("/node", &apis.CreateNodeHandler{}),
                // /api/ios/create/topic/
                beego.NSRouter("/topic", &apis.CreateTopicHandler{}),
            ),
            beego.NSNamespace("/read",
                beego.NSRouter("/node", &apis.ReadNodeHandler{}),
                beego.NSRouter("/topic", &apis.ReadTopicHandler{}),
            ),
            beego.NSNamespace("/update",
                beego.NSRouter("/node", &apis.UpdateNodeHandler{}),
                beego.NSRouter("/topic", &apis.UpdateTopicHandler{}),
            ),
            beego.NSNamespace("/delete",
                beego.NSRouter("/node", &apis.DeleteNodeHandler{}),
                beego.NSRouter("/topic", &apis.DeleteTopicHandler{}),
            )
        ),
    )

beego.AddNamespace(ns)

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。