Beego AutoRouter工作原理解析

一、前言

Beego Web框架应该是国内Go语言社区第一个框架，个人觉得十分适合新手入门Go Web。笔者半年前写过一篇搭建Beego项目并实习简单功能的文章，大家有兴趣可以先看看。

其实我接触的大部分人都在学校学过Java Web，其实有Java Web的经验，上手Beego也会很舒服。

本文着重讲讲Beego的AutoRouter模块，会结合源码来讲讲，不过由于笔者技术水平有限，如有错误，烦请指出。

二、从一个例子入手

Beego的路由设计灵感是sinatra，刚开始并不支持自动路由，项目的每一个路由都需要开发者配置。

不过，在Beego里面注册一个路由是十分简单的，不信你看：

import "github.com/beego/beego/v2/server/web" 
    type ReganYueController struct {    
        web.Controller 
    }

接下来我们可以添加一个方法，也可以重写Get，Post，Delete等方法来响应客户端不同的请求方式。

import "github.com/beego/beego/v2/server/web" 
    type ReganYueController struct
      { 
       web.Controller
      }
func (u *ReganYueController) HelloWorld()  {  
    u.Ctx.WriteString("Welcome, Regan Yue") 
} 
func main() {  
    web.AutoRouter(&ReganYueController{})  
    web.Run() 
}

该处web.AutoRouter(&ReganYueController{})就是使用的自动路由，如果是以前的话，我们还需要配置路由 。例如以下这种形式：

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

对于下面这段代码，有几点需要注意：

func (u *ReganYueController) HelloWorld()  {  
    u.Ctx.WriteString("Welcome, Regan Yue")     
}

这个处理HTTP请求的方法必须是公共方法（首字母要大写），并且不能有参数，不能有返回值，若非如此，可能会发生Panic。

AutoRouter的解析规则：

影响因素有三：

• RouterCaseSensitive的值。

• Controller的名字

• 方法名字

比如我们上面ReganYueController的名字是ReganYue，而方法名字是HelloWorld，那么就会有以下几种情况出现：

• 如果RouterCaseSensitive为true，那么AutoRouter就会注册两个路由，其中一个是/ReganYue/HelloWorld/*，另一个是/reganyue/helloworld/*。

• 如果RouterCaseSensitive为false，那么AutoRouter只会注册一个路由，即/reganyue/helloworld/*。

三、AutoRouter是如何工作的

先看看web.AutoRouter()

// AutoRouter see HttpServer.AutoRouter 
func AutoRouter(c ControllerInterface) *HttpServer {  
    return BeeApp.AutoRouter(c) 
}

web.AutoRouter()马上又指向(app *HttpServer) AutoRouter(c ControllerInterface)

// AutoRouter adds defined controller handler to BeeApp. 
// it's same to HttpServer.AutoRouter. 
// if beego.AddAuto(&MainContorlller{}) and MainController has methods List and Page, 
// visit the url /main/list to exec List function or /main/page to exec Page function. 
func (app *HttpServer) AutoRouter(c ControllerInterface) *HttpServer {  
    app.Handlers.AddAuto(c)  
    return app 
}

前面传来的主语BeeApp执行该处程序：

BeeApp是一个应用实例，使用NewHttpSever()创建，继续跟进，发现是根据Bconfig这个配置文件创建的，

// NewHttpServerWithCfg will create an sever with specific cfg 
func NewHttpServerWithCfg(cfg *Config) *HttpServer {  
        cr := NewControllerRegisterWithCfg(cfg)  
        app := &HttpServer{    
            Handlers: cr,    
            Server:   &http.Server{},    
            Cfg:      cfg,  
        }  
        return app
}

上图即配置Bconfig的主要结构。

到此我们对于BeeApp已经有一定了解了，下面我们回过头来看看app.Handlers.AddAuto(c)。

先看看这个c是什么，它的类型是ControllerInterface，我们现在进去看看。

这个c是用来统一所有controller handler的接口。

根据上图我们可以知道，这个app.Handles就是ControllerRegister，再来看看ControllerRegister的AddAuto方法：

func (p *ControllerRegister) AddAuto(c ControllerInterface) {  
    p.AddAutoPrefix("/", c) 
}

AddAuto又指向AddAutoPrefix，这个AddAutoPrefix有什么用，我们先给出一个例子，然后再来看源码。

beego.AddAutoPrefix("/admin",&MainContorlller{})

如果MainContorlller有两个方法List、Page。那么我们可以访问/admin/main/list来执行List函数，访问/admin/main/page来执行Page函数

来看看ControllerRegister的AddAutoPrefix方法：

func (p *ControllerRegister) AddAutoPrefix(prefix string, c ControllerInterface) {    
//对传入的Controller做反射  
reflectVal := reflect.ValueOf(c)    
//获取传入的Controller的类型  
rt := reflectVal.Type()    
//因为c是指针，所以要用Indirect方法获取指针指向的变量类型  
ct := reflect.Indirect(reflectVal).Type()    
//使用Beego注册controller的名称后面有Controller，这里把它去掉得到controllerName。  
controllerName := strings.TrimSuffix(ct.Name(), "Controller")    
//  for i := 0; i < rt.NumMethod(); i++ {    
if !utils.InSlice(rt.Method(i).Name, exceptMethod) 
{      
    route := &ControllerInfo{}      
    route.routerType = routerTypeBeego      
    route.methods = map[string]string{"*": rt.Method(i).Name}    
  route.controllerType = ct    
  pattern := path.Join(prefix, strings.ToLower(controllerName), strings.ToLower(rt.Method(i).Name), "*")      
  patternInit := path.Join(prefix, controllerName, rt.Method(i).Name, "*")      
  patternFix := path.Join(prefix, strings.ToLower(controllerName), strings.ToLower(rt.Method(i).Name))      
  patternFixInit := path.Join(prefix, controllerName, rt.Method(i).Name)      
  route.pattern = pattern      
  for m := range HTTPMETHOD {        
      p.addToRouter(m, pattern, route)        
      p.addToRouter(m, patternInit, route)        
      p.addToRouter(m, patternFix, route)      
    p.addToRouter(m, patternFixInit, route)    
    }   
   } 
  }
 }

reflectVal.Type()直接的获取传入的Controller的类型，而reflect.Indirect(reflectVal).Type()，interface其实就是两个指针，一个指向类型信息，一个指向实际的对象，用Indirect方法获取指针指向的实际变量的类型。

在runtime/runtime2.go可以了解interface其实就是两个指针：

type iface struct {        
tab  *itab //类型信息        
data unsafe.Pointer //实际对象指针 
}
type itab struct {       
     inter *interfacetype //接口类型      
     _type *_type         
     //实际对象类型        
     hash  uint32        
     _   [4]byte        
     fun   [1]uintptr     //实际对象方法地址 
 }

接下来是for i := 0; i < rt.NumMethod(); i++，我们来看看这个NumMethod()，可以看到这个方法获得interface类型的方法数量。

utils.InSlice()方法正如其名：

func InSlice(v string, sl []string) bool { 
 for _, vv := range sl {    
 if vv == v {      
 return true   
  }  
  }  
  return false 
  }

该方法是用来判断字符串v是不是在字符串切片sl里面。

此处判断方法名是不是在exceptMethod里面。

下面是exceptMethod的内容：

exceptMethod = []string{"Init", "Prepare", "Finish", "Render", "RenderString",    
"RenderBytes", "Redirect", "Abort", "StopRun", "UrlFor", "ServeJSON", "ServeJSONP",    
"ServeYAML", "ServeXML", "Input", "ParseForm", "GetString", "GetStrings", "GetInt", "GetBool",    
"GetFloat", "GetFile", "SaveToFile", "StartSession", "SetSession", "GetSession",    
"DelSession", "SessionRegenerateID", "DestroySession", "IsAjax", "GetSecureCookie",    
"SetSecureCookie", "XsrfToken", "CheckXsrfCookie", "XsrfFormHtml",    
"GetControllerAndAction", "ServeFormatted"}

接下来创建了一个结构体，记录了controller的信息，下面几行代码就生成了每个方法对应的controller信息。

controller的pattern这里生成了4个模式：

• prefix/全小写的controllerName/全小写的方法名/*

• prefix/controllerName/方法名/*

• prefix/全小写的controllerName/全小写的方法名

• prefix/controllerName/方法名

然后对每一种HTTP方法：

都使用addToRouter方法用四种模式执行一遍。

下面看看addToRouter。

func (p *ControllerRegister) addToRouter(method, pattern string, r *ControllerInfo) { 
if !p.cfg.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 
} 
}

• 如果RouterCaseSensitive为true，那么AutoRouter就会注册两个路由，其中一个是/ReganYue/HelloWorld/*，另一个是/reganyue/helloworld/*。

• 如果RouterCaseSensitive为false，那么AutoRouter只会注册一个路由，即/reganyue/helloworld/*。

然后将method传给ControllerRegister，看是不是注册成功。

成功就执行：t.AddRouter(pattern, r)添加路由。

否则就执行：

t := NewTree() t.AddRouter(pattern, r) p.routers[method] = t

那就到此为止吧,

再爱就不礼貌了...