Gin框架路由详解

gin框架使用的是定制版的httprouter，其路由的原理是大量使用公共前缀的树结构，它基本上是一个紧凑的Trie tree（或者只是Radix Tree）。具有公共前缀的节点也共享一个公共父节点。

Radix Tree

​ 基数树（Radix Tree）又称为PAT位树（Patricia Trie or crit bit tree），是一种更节省空间的前缀树（Trie Tree）。对于基数树的每个节点，如果该节点是唯一的子树的话，就和父节点合并。

​ Radix Tree可以被认为是一颗简洁版的前缀树。我们注册路由的过程就是构造前缀树的过程，具有公共前缀的节点也共享一个公共父节点。假设我们现在注册有一下路由信息：

r := gin.Default()

r.Get("/",func1)
r.GET("/search/",func2)
r.GET("/support/",func3)
r.GET("/blog/",func4)
r.GET("/blog/:post/",func5)
r.GET("about-us",func6)
r.GET("about-us/team/",func7)
r.GET("/contact/",func8)

那么我们会得到一个GET方法对应的路由树，具体结构如下：

• 最右边一列每个*<数字>表示Handle处理函数的内存地址（一个指针）。从根节点遍历到叶子节点我们就能得到完整的路由表

• 由于URL路径具有层次结构，并且只使用有限的一组字符（字节值），所以很可能有许多常见的前缀。这使我们可以很容易地将路由简化位=为更小的问题。

​ 此外，路由器为每个请求方法管理一颗单独的树。一方面，它比在每个节点中都保存一个method->handle map更加节省空间，它还使我们甚至可以在开始在前缀树中查找之前大大减少路由问题。

​ 为了获得更好的可伸缩性，每个树级别上的子节点都按Priority（优先级）排序，其中优先级（最左列）就是在子节点中注册的句柄的数量。这样做有两个好处：

​ 1.首先优先匹配被大多数路由路径包含的节点。这样可以让尽可能多的路由快速被定位。

​ 2.类似于成本补偿。最长的路径可以被优先匹配，补偿体现在最长的路径需要花费更长的时间来定位，如果最长路径的节点能被优先匹配（即每次拿节点都命中），那么路由匹配所花时间不一定比短路径的路由长。

请求处理

下面是一个Gin的小例子

import (
	"github.com/gin-gonic/gin"
	"net/http"
)

func main() {
	r := gin.Default()

	r.GET("/", func(c *gin.Context) {
		c.String(http.StatusOK, "ok")
	})
	r.Run()
}

我们从它的Run方法看起

进入到Run方法后我们可以看到，该方法的核心就是调用了net.http包中的ListenAndServe()方法

func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}

而在ListenAndServe()方法中我们需要传入两个参数：address和engine

err = http.ListenAndServe(address, engine)

这里的addr指的是路径，handler是一个接口

type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}

若想将engine作为参数传入ListenAndServe方法，则说明engine已经实现了ServeHTTP()

这里ServeHTTP的方法传递的两个参数，一个是Request，一个是ResponseWriter，Engine中的ServeHTTP的方法就是要对这两个对象进行读取或者写入操作。而且这两个对象往往是需要同时存在的，为了避免很多函数都需要写这两个参数，我们不如封装一个结构来把这两个对象放在里面：Context

type Context struct {
  writermem responseWriter
	Request   *http.Request
	Writer    ResponseWriter
  ...
}

type responseWriter struct {
	http.ResponseWriter
	size   int
	status int
}

下面代码中我们可以看到在ServeHTTP()中使用到了一个engine.pool，即go语言中的对象池。对象池的作用就是为了减少内存申请的频率。context就是某个请求的上下文结构，但是如果需要重复使用而队context进行重复的申请和销毁的话，未免有些不太妥当，此时就可以使用一个对象池来进行优化。

需要注意的是，这里的对象池并不是所谓的固定对象池，而是临时对象池，里面的对象个数不能指定，对象存储时间也不能指定，只是增加了对象复用的概率而已。

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	c := engine.pool.Get().(*Context)
	c.writermem.reset(w)
	c.Request = req
	c.reset()
 
	engine.handleHTTPRequest(c)
 
	engine.pool.Put(c)
}

中间的handleHTTPRequest()，如其名，便是处理HTTP请求的方法，也就是chulihttp请求的核心代码

		httpMethod := c.Request.Method	

		···

// Find root of the tree for the given HTTP method
	t := engine.trees
	for i, tl := 0, len(t); i < tl; i++ {
		if t[i].method != httpMethod {
			continue
		}
		root := t[i].root
		// Find route in tree
		value := root.getValue(rPath, c.params, c.skippedNodes, unescape)
		if value.params != nil {
			c.Params = *value.params
		}
		if value.handlers != nil {
			c.handlers = value.handlers
			c.fullPath = value.fullPath
			c.Next()
			c.writermem.WriteHeaderNow()
			return
		}
		if httpMethod != http.MethodConnect && rPath != "/" {
			if value.tsr && engine.RedirectTrailingSlash {
				redirectTrailingSlash(c)
				return
			}
			if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {
				return
			}
		}
		break
	}

我们可以看到我们先拿到了先前保存到c中的请求方法，将t遍历后，与我们拿到的请求方法进行对比，如果没有得到相同的请求方法，则直接结束当前循环。

那么这个engine.trees是个什么东西呢？我们接着点进去看一下

type Engine struct {
	RouterGroup
	···
	trees            methodTrees
	···
}


type methodTree struct {
	method string
	root   *node
}

type methodTrees []methodTree

func (trees methodTrees) get(method string) *node {
	for _, tree := range trees {
		if tree.method == method {
			return tree.root
		}
	}
	return nil
}

我们可以看到这个trees就是在Engine结构体中声明的一个methodTree类型的变量，而methodTree又是一个容量为9的切片，里面储存http获取请求的9个方法。