之前，我们用了一个非常简单的map结构存储了路由表，使用map存储键值对，索引非常高效，但是有一个弊端，键值对的存储的方式，只能用来索引静态路由。那如果我们想支持类似于/hello/:name这样的动态路由怎么办呢？所谓动态路由，即一条路由规则可以匹配某一类型而非某一条固定的路由。例如/hello/:name，可以匹配/hello/geektutu、hello/jack等。
所以今天我们的任务就是：
- 使用 Tire 树实现动态路由(dynamic route)解析
- 支持两种模式:name和*filepath
接下来我们实现的动态路由具备以下两个功能：
- 参数匹配":"，例如 /p/:lang/doc，可以匹配 /p/c/doc 和 /p/go/doc
- 通配"*"，例如 /static/*filepath，可以匹配/static/fav.ico，也可以匹配/static/js/jQuery.js，这种模式常用于静态服务器，能够递归地匹配子路径
Tire树实现
首先我们需要设计树节点上应该存储那些信息，其中pattern表示当前节点可以匹配的路由；part表示当前节点对应的路由某一部分的内容；children则存储当前节点的子节点，即后续可匹配路由；isWild 则表示当前节点是否是模糊匹配。与普通的树不同，为了实现动态路由匹配，加上了isWild这个参数。即当我们匹配/p/go/doc/这个路由时，第一层节点，p精准匹配到了p，第二层节点，go模糊匹配到:lang，那么将会把lang这个参数赋值为go，继续下一层匹配。我们将匹配的逻辑，包装为一个辅助函数。
type node struct {
pattern string // 待匹配路由，例如 /p/:lang
part string // 路由中的一部分，例如 :lang
children []*node // 子节点，例如 [doc, tutorial, intro]
isWild bool // 是否精确匹配，part 含有 : 或 * 时为true
}接下来就是定义node对象对应的方法，首先是两个匹配方法
- 查找子树中第一个匹配：遍历当前节点对象的所有子节点，遇到第一个 part 部分可匹配的节点即返回
// 找到匹配的子节点，场景是用在插入时使用，找到1个匹配的就立即返回
func (n *node) matchChild(part string) *node {
// 遍历n节点的所有子节点，看是否能找到匹配的子节点，将其返回
for _, child := range n.children {
// 如果有模糊匹配的也会成功匹配上
if child.part == part || child.isWild {
return child
}
}
return nil
}
- 查找子树中所有可能的匹配：遍历当前节点对象的所有子节点，将所有可匹配的节点放入 slice 中，遍历所有节点后，返回 slice
// 找到匹配的子节点，场景是用在插入时使用，找到1个匹配的就立即返回
func (n *node) matchChild(part string) *node {
// 遍历n节点的所有子节点，看是否能找到匹配的子节点，将其返回
for _, child := range n.children {
// 如果有模糊匹配的也会成功匹配上
if child.part == part || child.isWild {
return child
}
}
return nil
}
对于路由来说，最重要的当然是注册与匹配。开发服务时，注册路由规则，映射handler；访问时，匹配路由规则，查找到对应的handler。
因此，Trie 树需要支持节点的插入与查询。插入功能对应路由中的注册过程，根据目标路由内容，在当前节点的子树中找第一个可匹配的节点。如果可匹配的节点不存在，根据目标路由内容，构建新的节点，并将该新节点插入到当前节点的子树中，然后再根据完整路由，插入下一个路由内容，递归完成整个路由内容的节点插入，即完成路由的注册。有一点需要注意，/p/:lang/doc只有遍历到第三层节点，即doc节点，pattern才会设置为/p/:lang/doc。p和:lang节点的pattern属性皆为空。因此，当匹配结束时，我们可以使用n.pattern == ""来判断路由规则是否匹配成功。例如，/p/python虽能成功匹配到:lang，但:lang的pattern值为空，因此匹配失败。
// 一边匹配一边插入的方法
//r.roots[method].insert(pattern, parts, 0)
//parts = [] parts = [hello] parts = [hello :name] parts = [assets *filepath]
//pattren= / ```/hello ```/hello/:name ```/assets/*filepath
func (n *node) insert(pattern string, parts []string, height int) {
if len(parts) == height {
// 如果已经匹配完了，那么将pattern赋值给该node，表示它是一个完整的url
// 这是递归的终止条件
n.pattern = pattern
return
}
part := parts[height]
child := n.matchChild(part)
if child == nil {
// 没有匹配上，那么进行生成，放到n节点的子列表中
child = &node{part: part, isWild: part[0] == ':' || part[0] == '*'}
n.children = append(n.children, child)
}
// 接着插入下一个part节点
child.insert(pattern, parts, height+1)
}
查询功能对应路由中的注册过程，根据已有的trie树，查找所给的路由对应的树节点。当查找到最后一个节点或者当前节点包含*通配符，证明路由成功匹配，返回当前节点。否则查找子树中所有可以匹配的节点，遍历这些节点，递归查找下一层是否匹配，直至找到完全匹配路由的叶子节点，并将该叶子节点返回。
//n := root.search(searchParts, 0)
//[] [hello] [hello :name] [assets *filepath]
func (n *node) search(parts []string, height int) *node {
if len(parts) == height || strings.HasPrefix(n.part, "*") {
// 递归终止条件，找到末尾了或者通配符
if n.pattern == "" {
// pattern为空字符串表示它不是一个完整的url，匹配失败
return nil
}
return n
}
part := parts[height]
// 获取所有可能的子路径
children := n.matchChildren(part)
for _, child := range children {
// 对于每条路径接着用下一part去查找
result := child.search(parts, height+1)
if result != nil {
// 找到了即返回
return result
}
}
return nil
}// 查找所有完整的url，保存到列表中
func (n *node) travel(list *([]*node)) {
if n.pattern != "" {
// 递归终止条件
*list = append(*list, n)
}
for _, child := range n.children {
// 一层一层的递归找pattern是非空的节点
child.travel(list)
}
}
Router路由实现
- 数据结构
Trie 树的插入与查找都成功实现后，接下来我们将Tire树放到router.go中，其中，roots 是请求的路由对应的树根节点，用于判断路由是否匹配，起始的树节点为 GET/POST等请求类型节点（key eg, roots['GET'] roots['POST']）；handlers存储对应的响应处理函数，键值通常为 “请求类型-完整路由” 例如 handlers['GET-/p/:lang/doc'], handlers['POST-/p/book']。
将router.go中的router结构体和newRouter方法改为如下
type router struct {
roots map[string]*node // 请求的路由对应的树根节点，用于判断路由是否匹配（key eg, roots['GET'] roots['POST']）
handlers map[string]HandlerFunc // 对应的处理函数（key eg, handlers['GET-/p/:lang/doc'], handlers['POST-/p/book']）
}
// ---构造函数
func newRouter() *router {
return &router{
roots: make(map[string]*node),
handlers: make(map[string]HandlerFunc),
}
}- 路由解析
根据”/“对路由进行划分，将其拆分成可作为node.part的各个部分，注意：理由中只能有一个*，*后的所有内容均被视为文件路径。getRoute 函数中，还解析了:和*两种匹配符的参数，返回一个 map 。例如/p/go/doc匹配到/p/:lang/doc，解析结果为：{lang: "go"}，/static/css/geektutu.css匹配到/static/*filepath，解析结果为{filepath: "css/geektutu.css"}。
func parsePattern(pattern string) []string {
vs := strings.Split(pattern, "/") // 使用 ’/‘ 对字符串进行分割
parts := make([]string, 0) // 初始化路由的各个部分
for _, item := range vs { // 遍历路由中每一部分
if item != "" { // 如果该部分不为空
parts = append(parts, item) // 添加路由
if item[0] == '*' {
break
}
}
}
return parts
}- Router对象对应的方法
首先是注册路由，根据所给的请求类型以及路由，构建可匹配的 trie 树。将路由拆分后依次插入到请求类型对应的子树中，同时在handlers中存储对应的响应方式。
func (r *router) addRoute(method string, pattern string, handler HandlerFunc) {
//parts = [] parts = [hello] parts = [hello :name] parts = [assets *filepath]
parts := parsePattern(pattern) // 完成对路由的分析，获取其中的各个部分
//key= GET-/ key= GET-/hello key= GET-/hello/:name key= GET-/assets/*filepath
key := method + "-" + pattern // 构建router中handlers的注册路由
//method=/ 以/为root节点
_, ok := r.roots[method]
if !ok { // 该方法还没有树根节点，添加一个空节点便于插入
r.roots[method] = &node{}
}
//pattren= / ```/hello ```/hello/:name ```/assets/*filepath
r.roots[method].insert(pattern, parts, 0) // 像树中添加该路由的各个节点
//把key= GET-/ key= GET-/hello key= GET-/hello/:name key= GET-/assets/*filepath 与回调绑定
r.handlers[key] = handler
}
然后是匹配路由，根据请求类型以及对应的路由，返回匹配的节点以及对应的参数列表（模糊匹配部分的内容）
func (r *router) getRoute(method string, path string) (*node, map[string]string) {
searchParts := parsePattern(path) // 获取待查找路由的各个部分
params := make(map[string]string) // 模糊匹配对应的匹配内容
root, ok := r.roots[method] // 获取该类型请求对应的树节点
if !ok {
return nil, nil
} // 不存在该类型请求的路由，直接返回空
n := root.search(searchParts, 0) // 查找是否存在匹配的路由节点
if n != nil { //节点匹配
parts := parsePattern(n.pattern) // 解析当前找到的节点的路由
for index, part := range parts { // 遍历路由的各个部分
if part[0] == ':' { // 遇到模糊匹配:
params[part[1:]] = searchParts[index] // key：除匹配符(:)的其余字符，value：待匹配路由的对应位置内容
}
if part[0] == '*' && len(part) > 1 { // 遇到模糊匹配*
params[part[1:]] = strings.Join(searchParts[index:], "/") // key：除匹配符(*)的其余字符，value：待匹配路由之后的内容
break // 后续可不再匹配
}
}
return n, params // 返回匹配的节点，以及模糊匹配对应的内容
}
return nil, nil // 没有匹配的节点，直接返回空
}最后根据路由给出响应，根据请求的类型以及路由找到匹配的节点后，返回对应的响应内容。比较重要的一点是，在调用匹配到的handler前，将解析出来的路由参数赋值给了c.Params。这样就能够在handler中，通过Context对象访问到具体的值了
func (r *router) handle(c *Context) {
n, params := r.getRoute(c.Method, c.Path) // 根据请求中的路由进行匹配
if n != nil { // 查找到对应的路由，返回对应的响应
c.Params = params
key := c.Method + "-" + n.pattern
r.handlers[key](c)
} else { // 未查找到对应的路由，返回未找到路由的响应
c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
}
}Context修改
在HandlerFunc中，希望能够访问到解析的参数，因此，需要对 Context 对象增加一个属性和方法，来提供对路由参数的访问。我们将解析后的参数存储到Params中，通过c.Param("lang")的方式获取到对应的值。因此对context结构进行如下修改：
- 结构体中增加 Params: make(map[string]string)，Params存储模糊匹配对应的内容（例如 param[”:lang“]=”go“），需要时可通过Param获取相应的模糊匹配参数
- 构造函数增加对Params的初始化
- 新增方法，根据所给的模糊匹配的内容，返回对应路由中的匹配内容
func (c *Context) Param(key string) string {
value, _ := c.Params[key]
return value
}