自定义路由的实现

Author: astaxie

13.3.md

@@ -1,4 +1,258 @@
-# 13.3 自定义路由器设计
+# 13.3 自定义路由器设计
+
+## HTTP路由
+HTTP路由组件负责将HTTP请求交到对应的函数处理(或者是一个struct的方法)，如前面小节所描述的结构图，路由在框架中相当于一个事件处理器，而这个事件包括：
+
+- 用户请求的路径(例如:/user/123,/article/123)，当然还有查询串信息(例如?id=11)
+- HTTP的请求method(GET、POST、PUT、DELETE、PATCH等)
+
+路由器就是根据用户请求的这个信息定位到相应的处理函数。
+## 默认的路由实现
+在3.4小节有过介绍Go的http包的详解，里面介绍了Go的http包如何设计和实现路由，这里继续以一个例子来说明：
+
+	func fooHandler(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
+	}
+
+	http.Handle("/foo", fooHandler)
+
+	http.HandleFunc("/bar", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "Hello, %q", html.EscapeString(r.URL.Path))
+	})
+
+	log.Fatal(http.ListenAndServe(":8080", nil))
+	
+上面的例子调用了http默认的DefaultServeMux来添加路由，两个参数，第一个参数是前面所讲的用户请求的路径(Go中保存在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进行比对查询注册的处理函数，这样就实现了上面所说的第二点。
+
+	for k, v := range mux.m {
+		if !pathMatch(k, path) {
+			continue
+		}
+		if h == nil || len(k) > n {
+			n = len(k)
+			h = v.h
+		}
+	}
+
+
+## beego框架路由实现
+目前几乎所有的Web应用路由实现都是基于http默认的路由器，但是默认的路由器有几个限制点：
+
+- 不支持参数设定，例如/user/:uid 这种泛类型匹配
+- 无法很好的支持REST模式，无法限制访问的方法，例如上面的例子中，用户访问/foo，可以用GET、POST、DELETE、HEAD等方式访问
+- 默认的路由规则太多了，我前面自己开发了一个API的应用，路由规则有三十几条，这种路由多了之后其实可以进一步简化，通过struct的方法进行一种简化
+
+beego框架的路由器基于上面的几点限制考虑设计了一种REST方式的路由实现，路由设计也是基于上面的默认设计的两点来考虑：存储路由和转发路由
+
+### 存储路由
+针对前面所说的限制点，我们首先要解决参数支持就需要用到正则，第二和第三点我们通过一种变通的方法来解决，REST的方法对应到struct的方法中去，然后路由到struct而不是函数，这样在转发路由的时候就可以根据method来执行不同的方法。
+
+根据上面的思路，我们设计了两个数据类型controllerInfo(保存路径和对应的struct，这里是一个reflect.Type类型)和ControllerRegistor(routers是一个slice用来保存用户添加的路由信息，已经beego框架的信息)
+
+	type controllerInfo struct {
+		regex          *regexp.Regexp
+		params         map[int]string
+		controllerType reflect.Type
+	}
+
+	type ControllerRegistor struct {
+		routers     []*controllerInfo
+		Application *App
+	}
+	
+
+ControllerRegistor对外的接口函数有
+
+	func (p *ControllerRegistor) Add(pattern string, c ControllerInterface)
+
+详细的实现如下所示：
+
+		func (p *ControllerRegistor) Add(pattern string, c ControllerInterface) {
+		parts := strings.Split(pattern, "/")
+	
+		j := 0
+		params := make(map[int]string)
+		for i, part := range parts {
+			if strings.HasPrefix(part, ":") {
+				expr := "([^/]+)"
+				//a user may choose to override the defult expression
+				// similar to expressjs: ‘/user/:id([0-9]+)’ 
+				if index := strings.Index(part, "("); index != -1 {
+					expr = part[index:]
+					part = part[:index]
+				}
+				params[j] = part
+				parts[i] = expr
+				j++
+			}
+		}
+	
+		//recreate the url pattern, with parameters replaced
+		//by regular expressions. then compile the regex
+		pattern = strings.Join(parts, "/")
+		regex, regexErr := regexp.Compile(pattern)
+		if regexErr != nil {
+			//TODO add error handling here to avoid panic
+			panic(regexErr)
+			return
+		}
+	
+		//now create the Route
+		t := reflect.Indirect(reflect.ValueOf(c)).Type()
+		route := &controllerInfo{}
+		route.regex = regex
+		route.params = params
+		route.controllerType = t
+	
+		p.routers = append(p.routers, route)
+	
+	}
+	
+### 静态路由实现
+上面我们实现的动态路由的实现，Go的http包默认支持静态文件处理FileServer，由于我们实现了自定义的路由器，那么静态文件也需要自己设定，beego的静态文件夹保存在全局变量StaticDir中，StaticDir是一个map类型，实现如下：
+
+	func (app *App) SetStaticPath(url string, path string) *App {
+		StaticDir[url] = path
+		return app
+	}
+
+应用中设置静态路径可以使用如下方式实现：
+
+	beego.SetStaticPath("/img","/static/img")
+	
+
+### 转发路由
+转发路由是基于ControllerRegistor的路由信息来进行转发的，详细的实现如下代码所示：
+
+	// AutoRoute
+	func (p *ControllerRegistor) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+		defer func() {
+			if err := recover(); err != nil {
+				if !RecoverPanic {
+					// go back to panic
+					panic(err)
+				} else {
+					Critical("Handler crashed with error", err)
+					for i := 1; ; i += 1 {
+						_, file, line, ok := runtime.Caller(i)
+						if !ok {
+							break
+						}
+						Critical(file, line)
+					}
+				}
+			}
+		}()
+		var started bool
+		for prefix, staticDir := range StaticDir {
+			if strings.HasPrefix(r.URL.Path, prefix) {
+				file := staticDir + r.URL.Path[len(prefix):]
+				http.ServeFile(w, r, file)
+				started = true
+				return
+			}
+		}
+		requestPath := r.URL.Path
+	
+		//find a matching Route
+		for _, route := range p.routers {
+	
+			//check if Route pattern matches url
+			if !route.regex.MatchString(requestPath) {
+				continue
+			}
+	
+			//get submatches (params)
+			matches := route.regex.FindStringSubmatch(requestPath)
+	
+			//double check that the Route matches the URL pattern.
+			if len(matches[0]) != len(requestPath) {
+				continue
+			}
+	
+			params := make(map[string]string)
+			if len(route.params) > 0 {
+				//add url parameters to the query param map
+				values := r.URL.Query()
+				for i, match := range matches[1:] {
+					values.Add(route.params[i], match)
+					params[route.params[i]] = match
+				}
+	
+				//reassemble query params and add to RawQuery
+				r.URL.RawQuery = url.Values(values).Encode() + "&" + r.URL.RawQuery
+				//r.URL.RawQuery = url.Values(values).Encode()
+			}
+			//Invoke the request handler
+			vc := reflect.New(route.controllerType)
+			init := vc.MethodByName("Init")
+			in := make([]reflect.Value, 2)
+			ct := &Context{ResponseWriter: w, Request: r, Params: params}
+			in[0] = reflect.ValueOf(ct)
+			in[1] = reflect.ValueOf(route.controllerType.Name())
+			init.Call(in)
+			in = make([]reflect.Value, 0)
+			method := vc.MethodByName("Prepare")
+			method.Call(in)
+			if r.Method == "GET" {
+				method = vc.MethodByName("Get")
+				method.Call(in)
+			} else if r.Method == "POST" {
+				method = vc.MethodByName("Post")
+				method.Call(in)
+			} else if r.Method == "HEAD" {
+				method = vc.MethodByName("Head")
+				method.Call(in)
+			} else if r.Method == "DELETE" {
+				method = vc.MethodByName("Delete")
+				method.Call(in)
+			} else if r.Method == "PUT" {
+				method = vc.MethodByName("Put")
+				method.Call(in)
+			} else if r.Method == "PATCH" {
+				method = vc.MethodByName("Patch")
+				method.Call(in)
+			} else if r.Method == "OPTIONS" {
+				method = vc.MethodByName("Options")
+				method.Call(in)
+			}
+			if AutoRender {
+				method = vc.MethodByName("Render")
+				method.Call(in)
+			}
+			method = vc.MethodByName("Finish")
+			method.Call(in)
+			started = true
+			break
+		}
+	
+		//if no matches to url, throw a not found exception
+		if started == false {
+			http.NotFound(w, r)
+		}
+	}
+
+### 使用入门
+基于这样的路由设计之后就可以解决前面所说的三个限制点，使用的方式如下所示：
+
+基本的使用注册路由：
+
+	beego.BeeApp.RegisterController("/", &controllers.MainController{})
+	
+参数注册：
+
+	beego.BeeApp.RegisterController("/:param", &controllers.UserController{})
+	
+正则匹配：
+
+	beego.BeeApp.RegisterController("/users/:uid([0-9]+)", &controllers.UserController{})
 
 ## links
    * [目录](<preface.md>)