httprouter解读（continuing）

时间 2020-01-29

标签 httprouter 解读 continuing 繁體版

原文原文链接

httprouter解读

核心思想

与defaultServeMux的实现区别在于什么？采起特殊的数据结构做路由。
defaultServeMux的实现采用什么样的数据结构？
httprouter的实现采用什么样的数据结构？
router的架构图是怎样的，与server.go有何异同
一些http相关的细节
其余细节

细读源码

Router的 paramsPool？sync.Pool须要看看 done
修复重定向是代码大头，得细细解读重定向相关的协议内容 这部分先跳过吧，细节太多了
http包的server.go里面req的context里面包含了params怎么取消的。done

“server.serve => conn.serve ==>defer cancleCtx/ w.cancelCtx() ”node

所以，最要紧的就是看tree.go里面定义的数据结构。曹大的图能够帮助理解。python

tree

addRoute方法为切入口
初次阅读有几个不明白的地方，还须要回顾router.go

具体的路由规则要烂熟，由此解读node的几个类型

priority/wildchild/indices的意思和做用

test文件的测试有没有没覆盖到的状况？

node 的结构

type node struct {
    path      string
    indices   string 
    wildChild bool
    nType     nodeType
    priority  uint32
    children  []*node
    handle    Handle
}

疑难字段名

-pathgolang

一截儿path，绝非全路径，这点能够肯定。具体怎么表述？

indices

// incrementChildPrio
if newPos != pos {
  n.indices = n.indices[:newPos] +
   n.indices[pos:pos+1] +
   n.indices[newPos:pos] + n.indices[pos+1:] 
 }

可见每一个node为chidren指定惟一的一字节字符，和排好序的chidren slice一一对应。问题是怎么指定的呢？

wildchild

是什么？干吗的？

priority

干吗的？

“加”的两个重头方法 addRoute 和 insertChild

解读

事实上，在router.go中，只用到了addRoute为咱们的router添加路由以及对应的handle, insertChild为addRoute服务。

进一步的事实是，调用addRoute的老是根节点root.

咱们根据以上事实，参照代码，在脑海中模拟运行。找到点感受再更细致的分析（其实还有一个不错的方法是参照测试文件看看，找找感受）。

// router.go Handle
if root == nil {
    root = new(node)
    r.trees[method] = root
    // 其余逻辑
    ]}

// tree.go addRoute
fullpath := path
n.priority ++

//Empty tree
if len(n.path) == 0 && len(n.indices) == 0 {
    n.insertChild(path, fullpath, handle)
    n.nType == root // 常量： root
    return
}

insertChild 的逻辑是怎么样？

没有“:”“*”都好说，直接：

//insertChild
n.path = path
n.handle = handle

有呢？有点复杂。将状况简单化，若是以前是空树的话（如今要有第一个节点了），咱们想一想，有“:”“*”有什么说头？

问题一：遇到无效的wildcard怎么处理？

问题二：可能要设置wildcard冲突，怎么设置呢？

问题一已经被枪毙了

if !valid {
    panic("only one wildcard per path segment is allowed, has: '" + wildcard + "' in path '" + fullPath + "'")
}

另外还赠送了两种枪毙状况，“光杆司令” “鸠占鹊巢（初次插入时不会出现，可是很好理解，即冲突，后会说起此事）”
好了，开始好循环了吗？由于findWildCard只会找到离根部最近的那个。
param，这个简单点，先从这儿开始吧。先贴源码。

if wildcard[0] == ':' {   // param
    if i > 0 {
        // Insert prefix before the current wildcard
        n.path = path[:i]
        path = path[i:]
    }

    n.wildChild = true
    child := &node{
        nType: param,
        path: wildcard,
    }
    n.children = []*node{child}
    n = child
    n.priority++

    // If the path doesn't end with the wildcard, then there will be another non-wildcard subpath starting with '/'
    if len(wildcard) < len(path) {
        path = path[len(wildcard):]
        child := &node{
            priority: 1,
        }
        n.children = []*node{child}
        n = child
        continue
    }

    // Otherwise we're done. Insert the handle in the new leaf
    n.handle = handle
    return
}

其实很简单。当前节点n不是没children嘛（有chidren的以前已经被枪毙），我param给你当吧。别高兴的太早，你得把我爹妈照顾好，因而有了：

if i > 0 {
        n.path = path[:i]
        path = path[i:]
    }

须要注意的是这个path不是乱传的。path和fullpath和树和当前节点是有一致性的，在addRoute里会体现。咱们能够猜测一下，n.path 和参数path的关系， n.path应该是参数path脱去通配内容以后的前缀，不然以上的语句就会平白无故抹掉n.path的某种信息。设想path以":"开头的状况，也能够想通。这一点待验证。
咱们当前关注的空树插节点不须要考虑这么深刻，若“:”前有任何内容，直接给n便可，咱们集中精力处理以":"开头的一段。path在这个过程当中不断的“脱”。不管如何，如今的path以":"开头了。

n.wildchild = true

出现了，wildchild意思是，n的孩子是wildCard，并非“野孩子”。固然wildchild也必须是独子，不然，会引发冲突，果真有点野。

child := &node{
        nType: param,
        path: wildcard,
    }
    n.children = []*node{child}
    n = child
    n.priority++

注意，上面的wildcard是不包含"/"的、以“:”开头的一段内容。如愿以偿的，这个野孩子当了n的孩子，不只如此，还篡权了，成了新一代的n，接手如下的朝政工做。刚建立死后priority为0，如今为1。若是wildcard后面没有内容了，即没有“/”了，完事儿了，到头了：

n.handle = handle
    return

后面还有内容的话，必须还没完事儿，作好重走循环的准备

if len(wildcard) < len(path) {
        path = path[len(wildcard):]
        child := &node{
            priority: 1,
        }
        n.children = []*node{child}
        n = child
        continue
    }

path又开始“脱”了，path就像python（非彼python）同样一直蜕皮。这下path必定是以"/"开头的，这是从fildWildCard函数的实现中得出的结论。如今的n的类型是以前的param，形如“:xxx”的不含"/"，它建立了一个空孩子，而且这个空孩子当政成了n，重走循环。看咱们以前推测的，n.path必须是参数path的前缀，空串固然是path的前缀。
接下来是catchall状况，感受应该和param雷同，可是又有点不同。根据router.go开头的注释和测试用例，猜测一下：catchall必定是叶子节点，不以"/"结尾。

if i+len(wildcard) < len(path) {
    panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
}

果真咱们的猜测获得了验证。又赠送了一种枪毙状况。值得看一下。

if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
            panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
            }

也就是若是n.path非空，必须以"/"结尾。什么意思？什么node不以"/"结尾？好比param类型的，好比catchall类型的，还好比想通配一个，“/file/prefix_*filepath” 通通不合法了。
可是path自己会不会是“/somesubpath/*cathall”类型的呢？这样接在param类型的node后面为何是非法的？猜测：param类型的node不会直接调用insertChild方法！（等待验证）
这时候又来了下面一句：

i--
    if path[i] != '/' {
        panic("no / before catch-all in path '" + fullPath + "'")}

意思和上一条雷同。只不过非法状况来自
i--? 若是i == 0 呢？因而可知，path不会以“*”开头（等待验证）

小结一下：调用插入方法的node的path会是参数path的前缀，是空串最保险了。参数path不会以“*”开头，以“:”开头是可能的。node不会是param类型（catch也不会）。

n.path = path[:i]

// First node: catchAll node with empty path
child := &node{
    wildChild: true,
    nType:     catchAll,
    }
    n.children = []*node{child}
    n.indices = string('/')
    n = child
    n.priority++

// Second node: node holding the variable
child = &node{
    path:     path[i:],
    nType:    catchAll,
    handle:   handle,
    priority: 1,
    }
    n.children = []*node{child}

    return

path脱了后（还记得咱们的前缀论吗），进行了一波骚操做，一连插入两个catchall类型的节点。不明白为何，彷佛是做了一个保护，最后一个节点才是真正的通配符。而且这里首次出现了indices.更懵圈了。
毕竟insertChild只是一个辅助方法，使用的状况不少不少限制。

回到addRoute吧。数据结构

// Find the longest common prefix. 
//This also implies that the common prefix contains no ':' or '*' 
//since the existing key can't contain those chars.
i := longestCommonPrefix(path, n.path)

再回顾一遍insertChild方法：设想向空树插入：“/:name” , ":name", "/*catchall", 根结点不会带“:”“*”，要么空串，要么"/"。注意插入“*catchall”非法(index out of range!!!)。能够理解他的注释。

if i < len(n.path) {
    child := node{
    path:      n.path[i:],
    wildChild: n.wildChild,
    nType:     static,
    indices:   n.indices,
    children:  n.children,
    handle:    n.handle,
    priority:  n.priority - 1,
    }

    n.children = []*node{&child}
    // []byte for proper unicode char conversion, see #65
    n.indices = string([]byte{n.path[i]})
    n.path = path[:i]
    n.handle = nil
    n.wildChild = false
}

好的。i是path和n.path的最长公共前缀。最长公共前缀是要被剥离放在祖辈的。由于树生长的方向是向下，而越向下，生成的路径就会越长。这里至关于旧路径和新路径分叉了，天然要把前缀放在祖辈位置。
以上代码还有几个值得注意的细节。为何接管n.path后半段的child的priority要-1？暂时还不清楚。

-n.indices的含义。从上能够瞥见一点端倪。记得咱们说过，n.indices 和 n.children一一对应？这里n.indices就是这个child的开头字母，正如其名，起到的是索引的做用。架构

n.wildchild是false，由于咱们说了，最长前缀不含“:”"*". 有个特殊状况：path和n.path同样都是，:param 别的特殊状况也有，所以这个注释意思不明
还须要注意，n做为原n.path的子串，是没有设置handle的，你能够以后为这条路径设置。就直接走到该方法的最后：

if n.handle != nil {
    panic("a handle is already registered for path '" + fullPath + "'")
    }
    n.handle = handle

咱们继续往下走。先总览一下全貌。

if i < len(path) {
    path = path[i:]

    // 节点n的子节点是通配，杀伤力比较大，先掌权，后清洗
    if n.wildchild {
        // 1. 掌权
        // 2.清洗，生存者能够进入下一轮。
        // 思考：
        // 1. 什么样的能逃过清洗？
        // 2. 进入下一轮的初始状态是怎样的： 虚拟根结点
    }

    // 如今面临的状况：n的孩子节点没有param或catchall
    //可是n自己多是
    idxc := path[0]

    // 1. 一种简单的状况的处理 n是param，只有一个孩子
    // 那必然是“/”开头的或空串，直接重走循环

    // 2. n的某个孩子和path有公共前缀，提高priority并重走循环

    // 3.其余状况插入新的子节点，使树增加
    // 如今的情形是：  n.path 和 path 绝对并无公共前缀了
    // 3.1 等待拼接的全新path不以":" "*" 打头，须要作一点工做 
    // 插入空节点，做用不明， 保护做用？

    // 结合insertChild的状况，有个状况能够排除： 
    // 若是 idxc是“:” "*" 打头的，n必然没孩子
    // 若是n是param, path是普通字母打头的呢？按理来讲，这是个不合法现象。这在上面的判断（wildcard冲突判断中）已经枪毙。
    // 建立孩子（空串），插入此节点。
    n.insertChild(path, fullpPath, handle)
    }

}

须要注意的是，若是节点是param类型，path必然是“:”和参数名，毫不含有“/”，也侧面说明两个param类型的节点不多是父子。
若是是staitc类型，又没有“/”都是合法的，而且能够在任意位置（中间合法吗？），从上往下拼就能够了。
continue walk 的状况：

公共前缀不为空或n.path为空串

若n为param（模拟根结点没法作到的）， path必定是“:param” 或 “:param/” 或 “/”打头三种状况之一。

param子节点如有必定是独生子！！

param没孩子的话，要加一个空串“”

源码参考：app

if i < len(path) {
    path = path[i:]

    if n.wildchild {
        n = n.children[0]
        n.prority ++

    // Check if the wildcard mathes
    if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
    n.nType != catchAll &&
    (len(n.path) >= len(path) || path[len(n.path)] == "/") {
        continue walk
    } else {
        pathSeg := path
        if n.nType != cathAll {
            pathSeg = strings.SplitN(pathSeg, "/", 2)[0]
        }
        prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
        panic("'" + pathSeg +
        "' in new path '" + fullPath +
        "' conflicts with existing wildcard '" + n.path +
        "' in existing prefix '" + prefix +
        "'")
        }
    }

    idxc := path[0]

    if n.nType == param && idxc == "/" && len(n.children) == 1 {
        n = n.children[0]
        n.prority++
        continue walk
    }

    for i, c := range []byte(n.indices) {
        if c == idxc {
            i = n.incrementChildPrio(i)
            n = n.children[i]
            continue walk
        }
    }

    if idxc != ':' && idxc != '*' {
        n.indices += string([]byte{idxc})
        child := &node{}
        n.children = append(n.children, child)
        n.incrementChildPrio(len(n.indices) - 1)
        n = child
    }
    n.insertChild(path, fullpPath, handle)
}

“拿”的重要方法：getValue

做用猜测：根据树，匹配手头的path，把全部参数取出来，放在从sync.Pool里拿出临时对象[]Params，不断把解析的param加入。 catchall怎么处理？拭目以待！函数