Beego源码解析(二)-路由机制

原文地址:
Beego源码解析(二)-路由机制

---

上一篇文章介绍了　Beego关于配置项初始化的流程。那么今天就来说说在 Beego中非常重要的路由机制.
Beego到现在 v1.6.1版本为止支持了:固定路由、正则路由、自动路由这三种路由方法.
关于这三种路由的详细用法可以参考官方给出的开发文档,这里面已经记录的很全面了.

所以我们今天这篇文章就是要介绍这三种路由是如何在 Beego内部实现的.

关于 Beego的源码注释可以见我的Github

一个简单的示例

让我们先从官网给出的示例开始,下面是会在浏览器中打印”HelloWorld”的一个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()}

我们需要先知道它干了什么:
1. 自定义了一个内含 beego.Controller(这个类型后面会讲到)控制器的 MainController
2. 重写了 MainController的 Get()方法,熟悉 Go语言的应该知道这个方法来自 Controller
3. 在 main()函数中调用了 beego.Router()方法注册了路由”/”和一个 MainController实例
4. 执行了 beego.Run()方法启用了 beego程序

重要的类型和接口

为了不在接下来的流程中打断,在介绍流程之前需要先了解 beego中关于路由的一些东西

ControllerInterface 接口

源文件中的位置: beego/controller.go:90

type ControllerInterface interface {        Init(ct *context.Context,controllerName,actionName string,app interface{})        Prepare()        Get()        Post()        Delete()        Put()        Head()        Patch()        Options()        Finish()        Render() error        XSRFToken() string        CheckXSRFCookie() bool        HandlerFunc(fn string) bool        URLMapping()}

这个接口定义了 15个方法,看名字就能够知道这是每个 Controller都需要实现的接口

Controller结构体

位置 beego/controller.go:60

type Controller struct {//context dataCtx  *context.ContextData map[interface{}]interface{}//route controller infocontrollerName stringactionName     stringmethodMapping  map[string]func() //method:routertreegotofunc       stringAppController  interface{}// template dataTplName        stringLayout         stringLayoutSections map[string]string // the key is the section name and the value is the template nameTplExt         stringEnableRender   bool// xsrf data_xsrfToken stringXSRFExpire intEnableXSRF bool// sessionCruSession session.Store}

这个结构体保存了作为 Controller的一些必要的信息,一些基础的字段看名字就比较好理解
在这里的 context.Context(Beego中的上下文,封装了 HTTP的输入和输出)和 Session.Store(用于存储 Session)在以后的文章中会再提到

在这个源文件中的后面部分都是对 Controller的一些方法实现,我们会注意到 Controller实现了 ControllerInterface的方法,但是在一些方法实现中却是用 Ctx成员向客户端进行错误输出(例如 Get()方法)。
因为就像例子中给的一样,当我们需要自己定义 Controller,并且使用 Get()函数来完成对客户端 Get请求的处理时,我们就需要自己实现处理逻辑,这样就覆盖了本身输出错误的方法.而对于我们没有实现的方法(比如例子中的 Post()方法)没有重写,则对于客户端的 Post请求就会输出错误了

ControllerRegister结构体

这是一个非常关键的数据结构,为什么说他关键呢?我们可以先看下 Beego中 App结构体的定义
位置: beego/app.go

type App struct {    Handlers *ControllerRegister    Server *http.Server}

关于 App需要说下,在程序中 App类型的变量BeeApp(beego/app.go:32)在 init()函数中会调用 NewApp()创建出唯一的一个Beego程序实例
可以看到在例子中 main()函数最后调用了 beego.Run()函数,这个函数会在设置完hooks(关于回调方法以后也会介绍)后进入 BeeApp.Run()函数并且在进入这个函数后就会根据配置项开始不同的　HTTP请求的处理(在 ControllerRegister实现的 ServeHTTP()方法中)
App中一共就两个变量,一个Server(标准包中 http.Server类型,这个不做介绍,需要的可以看 Go语言文档).
另外一个就是 ControllerRegister,这个 ControllerRegister顾名思义就是注册 Controller的管理器,那么如何管理的呢?接下来看定义

位置: beego/router.go:115

type ControllerRegister struct {    routers map[string][]*Tree    enableFilter bool    filters map[int][]*FilterRouter    pool sync.Pool}

可以看到这篇文章的主角已经出现了, routers就是我们程序运行时所需要的路由表, routers的 key是我们注册的方法名(例如”get”、”post”等),而 value就是由注册的路由构建出来的路由树了(关于路由树,后面也会讲到).

ControllerInfo结构体

这个结构体是用来保存我们自定义的控制器信息的,看下定义便知道
位置: beego/router.go:104

type ControllerInfo struct {    pattern string  //模式    controllerType reflect.Type//类型    methods map[string]string//支持的方法    handler http.Handler//http.Handler接口    runFunction FilterFunc    routerType int//路由类型}

Tree结构体

type Tree struct {    //路由前缀    prefix string    //不带正则的路由    fixrouters []*Tree    //通配符,如果设置并且查找 fixrouters失败时会来查找 wildcard    wildcard *Tree    //叶子节点,如果设置并且查找 wildcard失败后会查找 leaves,里面保存了一些正则的信息    leaves []*leafInfo}

leafInfo结构体

type leafInfo struct {    wildcards []string//通配符    regexps *regexp.Regexp//正则对象    runObject interface{}//一般保存得到的 ControllerInfo对象,在处理请求时会返回该对象,并调用处理方法}

这两个结构体就会构成一颗用来查找路由的路由树

路由的注册过程

在前面的实例中可以看到需要注册自己的 Controller时使用的是 beego.Router()函数(在官方开发文档中的基础路由部分也可以使用 beego.Get()方法注册路由,不过内部与用 beego.Router()注册方法相比都会使用 addToRouter()函数,所以也是比较相似的)

看下 beego.Router的原型:

beego/app.go:211func Router(rootpath string,c ControllerInterface,mappingMethods ...string *App) {        BeeApp.Handlers.Add(rootpath,c,mappingMethods...)        return BeeApp}

看到第一个参数是需要注册路由,而第二个参数是我们自定义实现了 ControllerInterface接口的控制器,第三个就是自定义路由中方法和处理函数的映射关系
函数内部实际调用了 App.ControllerRegister的Add()方法来注册
接下来看看 Add()方法做了什么:
位置: beego/router.go:144

func (p *ControllerRegister) Add(pattern string, c ControllerInterface, mappingMethods ...string) {    reflectVal := reflect.ValueOf(c)    //反射获得 value    t := reflect.Indirect(reflectVal).Type()//反射获得 type    methods := make(map[string]string)    if len(mappingMethods) > 0 {        semi := strings.Split(mappingMethods[0], ";")//切分出每个以';'分隔的自定义方法和对应的函数        for _, v := range semi {            colon := strings.Split(v, ":")//切分出以':'分隔的方法名和对应的函数,colon[1]为处理的函数名            if len(colon) != 2 {                panic("method mapping format is invalid")            }            comma := strings.Split(colon[0], ",")//切分出以','分隔的方法名, comma包含了当前需要注册的所有方法名            for _, m := range comma {                if _, ok := HTTPMETHOD[strings.ToUpper(m)]; m == "*" || ok {                    //如果方法名为通配符'*'或者在支持的方法列表中.并使用反射包中的方法获得一个绑定对应函数的　Value类型                    //如果返回的值有效,就将当前方法加入到 methods中                    if val := reflectVal.MethodByName(colon[1]); val.IsValid() {                        methods[strings.ToUpper(m)] = colon[1]                    } else {                    //不支持方法时报错                        panic("'" + colon[1] + "' method doesn't exist in the controller " + t.Name())                    }                } else {                        panic(v + " is an invalid method mapping. Method doesn't exist " + m)                }            }        }    }    //添加 ControllerInfo类型来保存此项路由规则    route := &controllerInfo{}    route.pattern = pattern    route.methods = methods    route.routerType = routerTypeBeego    route.controllerType = t    //当传入的方法名为空时,给当前模式加入所有支持的方法    if len(methods) == 0 {        for _, m := range HTTPMETHOD {            p.addToRouter(m, pattern, route)        }    } else {        //方法名不为空时,判断是否含有通配符 "*"        for k := range methods {            if k == "*" {                for _, m := range HTTPMETHOD {                    //含有通配符,加入所有方法                    p.addToRouter(m, pattern, route)                    }            } else {                    //只加入指定的方法                    p.addToRouter(k, pattern, route)            }        }    }}

这是一个稍微长点的函数,不过通过注释可以看出这个函数做了几个工作:
1. 解析了传入的 mappingMethods,得到其中包含的全部方法
2. 用传入的4个参数构造出一个 ControllerInfo的实例,而这个实例中就保存了我们自定的控制器的 reflct.Type类型(可参考ControllerInfo)

在函数的最后调用了 ControllerRegister的 addToRouter()方法

位置: beego/router.go:199

func (p *ControllerRegister) addToRouter(method, pattern string, r *controllerInfo) {    if !BConfig.RouterCaseSensitive {        pattern = strings.ToLower(pattern)    }    if t, ok := p.routers[method]; ok {        //如果方法对应的路由树存在就直接添加        t.AddRouter(pattern, r)    } else {        //方法不存在这新创建一个路由树        t := NewTree()        t.AddRouter(pattern, r)        //设定新方法的路由树        p.routers[method] = t    }}

这个方法比较短,主要是判断当前的方法是否在 ControllerRegister的成员 routers所支持的方法中
* 存在就直接插入对应的路由树
* 否则创建一个新的路由树

路由树节点的插入操作就是 Tree.AddRouter()方法

位置: beego/tree.go:206

func (t *Tree) AddRouter(pattern string,runObject interface{}) {    t.addseg(splitPath(pattern),runObject,nil,"")}

可以看出它只是把 pattern中的路径进行了切割(例如”/admin/users”切割成”[“admin”,”users”]”),并返回一个 string类型的数组切片
那么接下来的目的就很明确了,我们需要使用 Tree提供的 addseg方法给路由树添加节点

这个函数也是最终的一个函数了,函数的逻辑可以看注释

func (t *Tree) addseg(segments []string, route interface{}, wildcards []string, reg string) {    if len(segments) == 0 {        if reg != "" {            //添加 leaves节点,并给 leaves添加正则规则            t.leaves = append(t.leaves, &leafInfo{runObject: route, wildcards: wildcards, regexps: regexp.MustCompile("^" + reg + "$")})        } else {            t.leaves = append(t.leaves, &leafInfo{runObject: route, wildcards: wildcards})        }    } else {        seg := segments[0]        iswild, params, regexpStr := splitSegment(seg)//splitSegment函数在后面介绍        // if it's ? meaning can igone this, so add one more rule for it        if len(params) > 0 && params[0] == ":" {            //当　params[0]为':'时,代表参数为空,开始解析下一个            t.addseg(segments[1:], route, wildcards, reg)//递归调用            params = params[1:]        }        //Rule: /login/*/access match /login/2009/11/access        //if already has *, and when loop the access, should as a regexpStr        //全匹配方式,可参考　http://beego.me/docs/mvc/controller/router.md 的正则路由->全匹配方式        // utils.InSlice()检查":solat"是否在wildcards中        if !iswild && utils.InSlice(":splat", wildcards) {            //如果使用了全匹配方式则继续使用正则解析            iswild = true            regexpStr = seg        }        //Rule: /user/:id/*        if seg == "*" && len(wildcards) > 0 && reg == "" {            regexpStr = "(.+)"        }        //包含有正则表达式　        if iswild {            if t.wildcard == nil {                t.wildcard = NewTree()            }            if regexpStr != "" {                if reg == "" {                    rr := ""                    for _, w := range wildcards {                        if w == ":splat" {                            rr = rr + "(.+)/"                        } else {                            rr = rr + "([^/]+)/"                        }                    }                    regexpStr = rr + regexpStr                } else {                    regexpStr = "/" + regexpStr                }            } else if reg != "" {                if seg == "*.*" {                    regexpStr = "/([^.]+).(.+)"                    params = params[1:]                } else {                    for range params {                        regexpStr = "/([^/]+)" + regexpStr                    }                }            } else {                if seg == "*.*" {                    params = params[1:]                }            }            t.wildcard.addseg(segments[1:], route, append(wildcards, params...), reg+regexpStr)//递归调用        } else {            var subTree *Tree            for _, sub := range t.fixrouters {                if sub.prefix == seg {                    subTree = sub                    break                }            }            if subTree == nil {                subTree = NewTree()                subTree.prefix = seg                t.fixrouters = append(t.fixrouters, subTree)            }            subTree.addseg(segments[1:], route, wildcards, reg)//递归调用        }    }}

至此路由树节点添加完成

这里需要提一下 splitSegment这个函数
位置: beego/tree.go:489

// "admin" -> false, nil, ""// ":id" -> true, [:id], ""// "?:id" -> true, [: :id], ""        : meaning can empty// ":id:int" -> true, [:id], ([0-9]+)// ":name:string" -> true, [:name], ([\w]+)// ":id([0-9]+)" -> true, [:id], ([0-9]+)// ":id([0-9]+)_:name" -> true, [:id :name], ([0-9]+)_(.+)// "cms_:id_:page.html" -> true, [:id_ :page], cms_(.+)(.+).html// "cms_:id(.+)_:page.html" -> true, [:id :page], cms_(.+)_(.+).html// "*" -> true, [:splat], ""// "*.*" -> true,[. :path :ext], ""      . meaning separator//正则路由,用于对正则的 Segment进行解析//当 key中包含正则 返回true，否则返回false//返回值第二个为不同的参数//第三个为正则的规则func splitSegment(key string) (bool, []string, string)

Final

最终我们从调用beego.Router()到最后给 ControllerRegister.router成功添加路由树节点的过程就完成了
总结一下就是注册路由的过程就是在添加 ControllerRegister中的路由树的节点,而在 HTTP执行的过程中对这棵树进行搜索(这就到树的搜索方法了),从而判断接受到的请求应该怎么样的处理(对应的根据 Controller不同的类型调用不同的方法)
完成 HTTP请求的正常处理过程:D

如果文章有误,非常希望能给我提出,好让我更正 :D