13.2 自定义路由器设计

HTTP路由

HTTP路由组件负责将HTTP请求交到对应的函数处理(或者是一个struct的方法)，如前面小节所描述的结构图，路由在框架中相当于一个事件处理器，而这个事件包括：

  • 用户请求的路径(path)(例如:/user/123,/article/123)，当然还有查询串信息(例如?id=11)
  • HTTP的请求方法(method)(GET、POST、PUT、DELETE、PATCH等)

路由器就是根据用户请求的事件信息转发到相应的处理函数(控制层)。

默认的路由实现

在3.4小节有过介绍Go的http包的详解，里面介绍了Go的http包如何设计和实现路由，这里继续以一个例子来说明：

  2. func fooHandler(w http.ResponseWriter, r *http.Request) {
  3.     fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
  4. }
  6. http.HandleFunc("/foo", fooHandler)
  8. http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
  9.     fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
  10. })
  12. log.Fatal(http.ListenAndServe(":8080", nil))

上面的例子调用了http默认的DefaultServeMux来添加路由，需要提供两个参数，第一个参数是希望用户访问此资源的URL路径(保存在r.URL.Path)，第二参数是即将要执行的函数，以提供用户访问的资源。路由的思路主要集中在两点：

  • 添加路由信息
  • 根据用户请求转发到要执行的函数

Go默认的路由添加是通过函数http.Handle和http.HandleFunc等来添加，底层都是调用了DefaultServeMux.Handle(pattern string, handler Handler),这个函数会把路由信息存储在一个map信息中map[string]muxEntry，这就解决了上面说的第一点。

Go监听端口，然后接收到tcp连接会扔给Handler来处理，上面的例子默认nil即为http.DefaultServeMux，通过DefaultServeMux.ServeHTTP函数来进行调度，遍历之前存储的map路由信息，和用户访问的URL进行匹配，以查询对应注册的处理函数，这样就实现了上面所说的第二点。

  2. for k, v := range mux.m {
  3.     if !pathMatch(k, path) {
  4.         continue
  5.     }
  6.     if h == nil || len(k) > n {
  7.         n = len(k)
  8.         h = v.h
  9.     }
  10. }

beego框架路由实现

目前几乎所有的Web应用路由实现都是基于http默认的路由器，但是Go自带的路由器有几个限制：

  • 不支持参数设定，例如/user/:uid 这种泛类型匹配
  • 无法很好的支持REST模式，无法限制访问的方法，例如上面的例子中，用户访问/foo，可以用GET、POST、DELETE、HEAD等方式访问
  • 一般网站的路由规则太多了，编写繁琐。我前面自己开发了一个API应用，路由规则有三十几条，这种路由多了之后其实可以进一步简化，通过struct的方法进行一种简化

beego框架的路由器基于上面的几点限制考虑设计了一种REST方式的路由实现，路由设计也是基于上面Go默认设计的两点来考虑：存储路由和转发路由

存储路由

针对前面所说的限制点，我们首先要解决参数支持就需要用到正则，第二和第三点我们通过一种变通的方法来解决，REST的方法对应到struct的方法中去，然后路由到struct而不是函数，这样在转发路由的时候就可以根据method来执行不同的方法。

根据上面的思路，我们设计了两个数据类型controllerInfo(保存路径和对应的struct，这里是一个reflect.Type类型)和ControllerRegistor(routers是一个slice用来保存用户添加的路由信息，以及beego框架的应用信息)

  2. type controllerInfo struct {
  3.     regex          *regexp.Regexp
  4.     params         map[int]string
  5.     controllerType reflect.Type
  6. }
  8. type ControllerRegistor struct {
  9.     routers     []*controllerInfo
  10.     Application *App
  11. }

ControllerRegistor对外的接口函数有

  2. func (p *ControllerRegistor) Add(pattern string, c ControllerInterface)

详细的实现如下所示：

  2. func (p *ControllerRegistor) Add(pattern string, c ControllerInterface) {
  3.     parts := strings.Split(pattern, "/")
  5.     j := 0
  6.     params := make(map[int]string)
  7.     for i, part := range parts {
  8.         if strings.HasPrefix(part, ":") {
  9.             expr := "([^/]+)"
  11.             //a user may choose to override the defult expression
  12.             // similar to expressjs: ‘/user/:id([0-9]+)’
  14.             if index := strings.Index(part, "("); index != -1 {
  15.                 expr = part[index:]
  16.                 part = part[:index]
  17.             }
  18.             params[j] = part
  19.             parts[i] = expr
  20.             j++
  21.         }
  22.     }
  24.     //recreate the url pattern, with parameters replaced
  25.     //by regular expressions. then compile the regex
  27.     pattern = strings.Join(parts, "/")
  28.     regex, regexErr := regexp.Compile(pattern)
  29.     if regexErr != nil {
  31.         //TODO add error handling here to avoid panic
  32.         panic(regexErr)
  33.         return
  34.     }
  36.     //now create the Route
  37.     t := reflect.Indirect(reflect.ValueOf(c)).Type()
  38.     route := &controllerInfo{}
  39.     route.regex = regex
  40.     route.params = params
  41.     route.controllerType = t
  43.     p.routers = append(p.routers, route)
  45. }

静态路由实现

上面我们实现的动态路由的实现，Go的http包默认支持静态文件处理FileServer，由于我们实现了自定义的路由器，那么静态文件也需要自己设定，beego的静态文件夹路径保存在全局变量StaticDir中，StaticDir是一个map类型，实现如下：

  2. func (app *App) SetStaticPath(url string, path string) *App {
  3.     StaticDir[url] = path
  4.     return app
  5. }

应用中设置静态路径可以使用如下方式实现：

  2. beego.SetStaticPath("/img","/static/img")

转发路由

转发路由是基于ControllerRegistor里的路由信息来进行转发的，详细的实现如下代码所示：

  2. // AutoRoute
  3. func (p *ControllerRegistor) ServeHTTP(w http.ResponseWriter, r *http.Request) {
  4.     defer func() {
  5.         if err := recover(); err != nil {
  6.             if !RecoverPanic {
  7.                 // go back to panic
  8.                 panic(err)
  9.             } else {
  10.                 Critical("Handler crashed with error", err)
  11.                 for i := 1; ; i += 1 {
  12.                     _, file, line, ok := runtime.Caller(i)
  13.                     if !ok {
  14.                         break
  15.                     }
  16.                     Critical(file, line)
  17.                 }
  18.             }
  19.         }
  20.     }()
  21.     var started bool
  22.     for prefix, staticDir := range StaticDir {
  23.         if strings.HasPrefix(r.URL.Path, prefix) {
  24.             file := staticDir + r.URL.Path[len(prefix):]
  25.             http.ServeFile(w, r, file)
  26.             started = true
  27.             return
  28.         }
  29.     }
  30.     requestPath := r.URL.Path
  32.     //find a matching Route
  33.     for _, route := range p.routers {
  35.         //check if Route pattern matches url
  36.         if !route.regex.MatchString(requestPath) {
  37.             continue
  38.         }
  40.         //get submatches (params)
  41.         matches := route.regex.FindStringSubmatch(requestPath)
  43.         //double check that the Route matches the URL pattern.
  44.         if len(matches[0]) != len(requestPath) {
  45.             continue
  46.         }
  48.         params := make(map[string]string)
  49.         if len(route.params) > 0 {
  50.             //add url parameters to the query param map
  51.             values := r.URL.Query()
  52.             for i, match := range matches[1:] {
  53.                 values.Add(route.params[i], match)
  54.                 params[route.params[i]] = match
  55.             }
  57.             //reassemble query params and add to RawQuery
  58.             r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery
  59.             //r.URL.RawQuery = url.Values(values).Encode()
  60.         }
  61.         //Invoke the request handler
  62.         vc := reflect.New(route.controllerType)
  63.         init := vc.MethodByName("Init")
  64.         in := make([]reflect.Value, 2)
  65.         ct := &Context{ResponseWriter: w, Request: r, Params: params}
  66.         in[0] = reflect.ValueOf(ct)
  67.         in[1] = reflect.ValueOf(route.controllerType.Name())
  68.         init.Call(in)
  69.         in = make([]reflect.Value, 0)
  70.         method := vc.MethodByName("Prepare")
  71.         method.Call(in)
  72.         if r.Method == "GET" {
  73.             method = vc.MethodByName("Get")
  74.             method.Call(in)
  75.         } else if r.Method == "POST" {
  76.             method = vc.MethodByName("Post")
  77.             method.Call(in)
  78.         } else if r.Method == "HEAD" {
  79.             method = vc.MethodByName("Head")
  80.             method.Call(in)
  81.         } else if r.Method == "DELETE" {
  82.             method = vc.MethodByName("Delete")
  83.             method.Call(in)
  84.         } else if r.Method == "PUT" {
  85.             method = vc.MethodByName("Put")
  86.             method.Call(in)
  87.         } else if r.Method == "PATCH" {
  88.             method = vc.MethodByName("Patch")
  89.             method.Call(in)
  90.         } else if r.Method == "OPTIONS" {
  91.             method = vc.MethodByName("Options")
  92.             method.Call(in)
  93.         }
  94.         if AutoRender {
  95.             method = vc.MethodByName("Render")
  96.             method.Call(in)
  97.         }
  98.         method = vc.MethodByName("Finish")
  99.         method.Call(in)
  100.         started = true
  101.         break
  102.     }
  104.     //if no matches to url, throw a not found exception
  105.     if started == false {
  106.         http.NotFound(w, r)
  107.     }
  108. }

使用入门

基于这样的路由设计之后就可以解决前面所说的三个限制点，使用的方式如下所示：

基本的使用注册路由：

  2. beego.BeeApp.RegisterController("/", &controllers.MainController{})

参数注册：

  2. beego.BeeApp.RegisterController("/:param", &controllers.UserController{})

正则匹配：

  2. beego.BeeApp.RegisterController("/users/:uid([0-9]+)", &controllers.UserController{})