通过阅读gin框架的源码来探究gin框架路由与中间件的秘密。

gin框架路由详解

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

Radix Tree

基数树（Radix Tree）又称为PAT位树（Patricia Trie or crit bit tree），是一种更节省空间的前缀树（Trie Tree）。对于基数树的每个节点，如果该节点是唯一的子树的话，就和父节点合并。下图为一个基数树示例：
gin框架源码解析 - 图1
Radix Tree可以被认为是一棵简洁版的前缀树。我们注册路由的过程就是构造前缀树的过程，具有公共前缀的节点也共享一个公共父节点。假设我们现在注册有以下路由信息：

  1. r := gin.Default()
  2. r.GET("/", func1)
  3. r.GET("/search/", func2)
  4. r.GET("/support/", func3)
  5. r.GET("/blog/", func4)
  6. r.GET("/blog/:post/", func5)
  7. r.GET("/about-us/", func6)
  8. r.GET("/about-us/team/", func7)
  9. r.GET("/contact/", func8)

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

  1. Priority   Path             Handle
  2. 9          \                *<1>
  3. 3          ├s               nil
  4. 2          |├earch\         *<2>
  5. 1          |└upport\        *<3>
  6. 2          ├blog\           *<4>
  7. 1          |    └:post      nil
  8. 1          |         └\     *<5>
  9. 2          ├about-us\       *<6>
  10. 1          |        └team\  *<7>
  11. 1          └contact\        *<8>

上面最右边那一列每个*<数字>表示Handle处理函数的内存地址(一个指针)。从根节点遍历到叶子节点我们就能得到完整的路由表。
例如：blog/:post其中:post只是实际文章名称的占位符(参数)。与hash-maps不同，这种树结构还允许我们使用像:post参数这种动态部分，因为我们实际上是根据路由模式进行匹配，而不仅仅是比较哈希值。
由于URL路径具有层次结构，并且只使用有限的一组字符(字节值)，所以很可能有许多常见的前缀。这使我们可以很容易地将路由简化为更小的问题。此外，路由器为每个请求方法管理一棵单独的树。一方面，它比在每个节点中都保存一个method-> handle map更加节省空间，它还使我们甚至可以在开始在前缀树中查找之前大大减少路由问题。
为了获得更好的可伸缩性，每个树级别上的子节点都按Priority(优先级)排序，其中优先级（最左列）就是在子节点(子节点、子子节点等等)中注册的句柄的数量。这样做有两个好处:

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

  2. 类似于成本补偿。最长的路径可以被优先匹配，补偿体现在最长的路径需要花费更长的时间来定位，如果最长路径的节点能被优先匹配（即每次拿子节点都命中），那么路由匹配所花的时间不一定比短路径的路由长。下面展示了节点（每个-可以看做一个节点）匹配的路径：从左到右，从上到下。

    1. ├------------
    2. ├---------
    3. ├-----
    4. ├----
    5. ├--
    6. ├--
    7. └-

    路由树节点

    路由树是由一个个节点构成的，gin框架路由树的节点由node结构体表示，它有以下字段：

    1. // tree.go
    2. type node struct {
    3. // 节点路径，比如上面的s，earch，和upport
    4.  path      string
    5.  // 和children字段对应, 保存的是分裂的分支的第一个字符
    6.  // 例如search和support, 那么s节点的indices对应的"eu"
    7.  // 代表有两个分支, 分支的首字母分别是e和u
    8.  indices   string
    9.  // 儿子节点
    10.  children  []*node
    11.  // 处理函数链条（切片）
    12.  handlers  HandlersChain
    13.  // 优先级，子节点、子子节点等注册的handler数量
    14.  priority  uint32
    15.  // 节点类型，包括static, root, param, catchAll
    16.  // static: 静态节点（默认），比如上面的s，earch等节点
    17.  // root: 树的根节点
    18.  // catchAll: 有*匹配的节点
    19.  // param: 参数节点
    20.  nType     nodeType
    21.  // 路径上最大参数个数
    22.  maxParams uint8
    23.  // 节点是否是参数节点，比如上面的:post
    24.  wildChild bool
    25.  // 完整路径
    26.  fullPath  string
    27. }

    请求方法树

    在gin的路由中，每一个HTTP Method(GET、POST、PUT、DELETE…)都对应了一棵 radix tree，我们注册路由的时候会调用下面的addRoute函数：

    1. // gin.go
    2. func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
    3. // liwenzhou.com...
    5. // 获取请求方法对应的树
    6.  root := engine.trees.get(method)
    7.  if root == nil {
    9.     // 如果没有就创建一个
    10.      root = new(node)
    11.      root.fullPath = "/"
    12.      engine.trees = append(engine.trees, methodTree{method: method, root: root})
    13.  }
    14.  root.addRoute(path, handlers)
    15. }

    从上面的代码中我们可以看到在注册路由的时候都是先根据请求方法获取对应的树，也就是gin框架会为每一个请求方法创建一棵对应的树。只不过需要注意到一个细节是gin框架中保存请求方法对应树关系并不是使用的map而是使用的切片，engine.trees的类型是methodTrees，其定义如下：

    1. type methodTree struct {
    2.  method string
    3.  root   *node
    4. }
    5. type methodTrees []methodTree  // slice

    而获取请求方法对应树的get方法定义如下：

    1. func (trees methodTrees) get(method string) *node {
    2.  for _, tree := range trees {
    3.      if tree.method == method {
    4.          return tree.root
    5.      }
    6.  }
    7.  return nil
    8. }

    为什么使用切片而不是map来存储请求方法->树的结构呢？我猜是出于节省内存的考虑吧，毕竟HTTP请求方法的数量是固定的，而且常用的就那几种，所以即使使用切片存储查询起来效率也足够了。顺着这个思路，我们可以看一下gin框架中engine的初始化方法中，确实对tress字段做了一次内存申请：

    1. func New() *Engine {
    2.  debugPrintWARNINGNew()
    3.  engine := &Engine{
    4.      RouterGroup: RouterGroup{
    5.          Handlers: nil,
    6.          basePath: "/",
    7.          root:     true,
    8.      },
    9.      // liwenzhou.com ...
    10.      // 初始化容量为9的切片（HTTP1.1请求方法共9种）
    11.      trees:                  make(methodTrees, 0, 9),
    12.      // liwenzhou.com...
    13.  }
    14.  engine.RouterGroup.engine = engine
    15.  engine.pool.New = func() interface{} {
    16.      return engine.allocateContext()
    17.  }
    18.  return engine
    19. }

    注册路由

    注册路由的逻辑主要有addRoute函数和insertChild方法。

    addRoute

    1. // tree.go
    2. // addRoute 将具有给定句柄的节点添加到路径中。
    3. // 不是并发安全的
    4. func (n *node) addRoute(path string, handlers HandlersChain) {
    5.  fullPath := path
    6.  n.priority++
    7.  numParams := countParams(path)  // 数一下参数个数
    8.  // 空树就直接插入当前节点
    9.  if len(n.path) == 0 && len(n.children) == 0 {
    10.      n.insertChild(numParams, path, fullPath, handlers)
    11.      n.nType = root
    12.      return
    13.  }
    14.  parentFullPathIndex := 0
    15. walk:
    16.  for {
    17.      // 更新当前节点的最大参数个数
    18.      if numParams > n.maxParams {
    19.          n.maxParams = numParams
    20.      }
    21.      // 找到最长的通用前缀
    22.      // 这也意味着公共前缀不包含“:”"或“*” /
    23.      // 因为现有键不能包含这些字符。
    24.      i := longestCommonPrefix(path, n.path)
    25.      // 分裂边缘（此处分裂的是当前树节点）
    26.      // 例如一开始path是search，新加入support，s是他们通用的最长前缀部分
    27.      // 那么会将s拿出来作为parent节点，增加earch和upport作为child节点
    28.      if i < len(n.path) {
    29.          child := node{
    30.              path:      n.path[i:],  // 公共前缀后的部分作为子节点
    31.              wildChild: n.wildChild,
    32.              indices:   n.indices,
    33.              children:  n.children,
    34.              handlers:  n.handlers,
    35.              priority:  n.priority - 1, //子节点优先级-1
    36.              fullPath:  n.fullPath,
    37.          }
    38.          // Update maxParams (max of all children)
    39.          for _, v := range child.children {
    40.              if v.maxParams > child.maxParams {
    41.                  child.maxParams = v.maxParams
    42.              }
    43.          }
    44.          n.children = []*node{&child}
    45.          // []byte for proper unicode char conversion, see #65
    46.          n.indices = string([]byte{n.path[i]})
    47.          n.path = path[:i]
    48.          n.handlers = nil
    49.          n.wildChild = false
    50.          n.fullPath = fullPath[:parentFullPathIndex+i]
    51.      }
    52.      // 将新来的节点插入新的parent节点作为子节点
    53.      if i < len(path) {
    54.          path = path[i:]
    55.          if n.wildChild {  // 如果是参数节点
    56.              parentFullPathIndex += len(n.path)
    57.              n = n.children[0]
    58.              n.priority++
    59.              // Update maxParams of the child node
    60.              if numParams > n.maxParams {
    61.                  n.maxParams = numParams
    62.              }
    63.              numParams--
    64.              // 检查通配符是否匹配
    65.              if len(path) >= len(n.path) && n.path == path[:len(n.path)] {
    66.                  // 检查更长的通配符, 例如 :name and :names
    67.                  if len(n.path) >= len(path) || path[len(n.path)] == '/' {
    68.                      continue walk
    69.                  }
    70.              }
    71.              pathSeg := path
    72.              if n.nType != catchAll {
    73.                  pathSeg = strings.SplitN(path, "/", 2)[0]
    74.              }
    75.              prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
    76.              panic("'" + pathSeg +
    77.                  "' in new path '" + fullPath +
    78.                  "' conflicts with existing wildcard '" + n.path +
    79.                  "' in existing prefix '" + prefix +
    80.                  "'")
    81.          }
    82.          // 取path首字母，用来与indices做比较
    83.          c := path[0]
    84.          // 处理参数后加斜线情况
    85.          if n.nType == param && c == '/' && len(n.children) == 1 {
    86.              parentFullPathIndex += len(n.path)
    87.              n = n.children[0]
    88.              n.priority++
    89.              continue walk
    90.          }
    91.          // 检查路path下一个字节的子节点是否存在
    92.          // 比如s的子节点现在是earch和upport，indices为eu
    93.          // 如果新加一个路由为super，那么就是和upport有匹配的部分u，将继续分列现在的upport节点
    94.          for i, max := 0, len(n.indices); i < max; i++ {
    95.              if c == n.indices[i] {
    96.                  parentFullPathIndex += len(n.path)
    97.                  i = n.incrementChildPrio(i)
    98.                  n = n.children[i]
    99.                  continue walk
    100.              }
    101.          }
    102.          // 否则就插入
    103.          if c != ':' && c != '*' {
    104.              // []byte for proper unicode char conversion, see #65
    105.              // 注意这里是直接拼接第一个字符到n.indices
    106.              n.indices += string([]byte{c})
    107.              child := &node{
    108.                  maxParams: numParams,
    109.                  fullPath:  fullPath,
    110.              }
    111.              // 追加子节点
    112.              n.children = append(n.children, child)
    113.              n.incrementChildPrio(len(n.indices) - 1)
    114.              n = child
    115.          }
    116.          n.insertChild(numParams, path, fullPath, handlers)
    117.          return
    118.      }
    119.      // 已经注册过的节点
    120.      if n.handlers != nil {
    121.          panic("handlers are already registered for path '" + fullPath + "'")
    122.      }
    123.      n.handlers = handlers
    124.      return
    125.  }
    126. }

    其实上面的代码很好理解，大家可以参照动画尝试将以下情形代入上面的代码逻辑，体味整个路由树构造的详细过程：

  3. 第一次注册路由，例如注册search

  4. 继续注册一条没有公共前缀的路由，例如blog
  5. 注册一条与先前注册的路由有公共前缀的路由，例如support

gin框架源码解析 - 图2

insertChild

  1. // tree.go
  2. func (n *node) insertChild(numParams uint8, path string, fullPath string, handlers HandlersChain) {
  3.   // 找到所有的参数
  4.     for numParams > 0 {
  5.         // 查找前缀直到第一个通配符
  6.         wildcard, i, valid := findWildcard(path)
  7.         if i < 0 { // 没有发现通配符
  8.             break
  9.         }
  10.         // 通配符的名称必须包含':' 和 '*'
  11.         if !valid {
  12.             panic("only one wildcard per path segment is allowed, has: '" +
  13.                 wildcard + "' in path '" + fullPath + "'")
  14.         }
  15.         // 检查通配符是否有名称
  16.         if len(wildcard) < 2 {
  17.             panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
  18.         }
  19.         // 检查这个节点是否有已经存在的子节点
  20.         // 如果我们在这里插入通配符，这些子节点将无法访问
  21.         if len(n.children) > 0 {
  22.             panic("wildcard segment '" + wildcard +
  23.                 "' conflicts with existing children in path '" + fullPath + "'")
  24.         }
  25.         if wildcard[0] == ':' { // param
  26.             if i > 0 {
  27.                 // 在当前通配符之前插入前缀
  28.                 n.path = path[:i]
  29.                 path = path[i:]
  30.             }
  31.             n.wildChild = true
  32.             child := &node{
  33.                 nType:     param,
  34.                 path:      wildcard,
  35.                 maxParams: numParams,
  36.                 fullPath:  fullPath,
  37.             }
  38.             n.children = []*node{child}
  39.             n = child
  40.             n.priority++
  41.             numParams--
  42.             // 如果路径没有以通配符结束
  43.             // 那么将有另一个以'/'开始的非通配符子路径。
  44.             if len(wildcard) < len(path) {
  45.                 path = path[len(wildcard):]
  46.                 child := &node{
  47.                     maxParams: numParams,
  48.                     priority:  1,
  49.                     fullPath:  fullPath,
  50.                 }
  51.                 n.children = []*node{child}
  52.                 n = child  // 继续下一轮循环
  53.                 continue
  54.             }
  55.             // 否则我们就完成了。将处理函数插入新叶子中
  56.             n.handlers = handlers
  57.             return
  58.         }
  59.         // catchAll
  60.         if i+len(wildcard) != len(path) || numParams > 1 {
  61.             panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
  62.         }
  63.         if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
  64.             panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
  65.         }
  66.         // currently fixed width 1 for '/'
  67.         i--
  68.         if path[i] != '/' {
  69.             panic("no / before catch-all in path '" + fullPath + "'")
  70.         }
  71.         n.path = path[:i]
  73.         // 第一个节点:路径为空的catchAll节点
  74.         child := &node{
  75.             wildChild: true,
  76.             nType:     catchAll,
  77.             maxParams: 1,
  78.             fullPath:  fullPath,
  79.         }
  80.         // 更新父节点的maxParams
  81.         if n.maxParams < 1 {
  82.             n.maxParams = 1
  83.         }
  84.         n.children = []*node{child}
  85.         n.indices = string('/')
  86.         n = child
  87.         n.priority++
  88.         // 第二个节点:保存变量的节点
  89.         child = &node{
  90.             path:      path[i:],
  91.             nType:     catchAll,
  92.             maxParams: 1,
  93.             handlers:  handlers,
  94.             priority:  1,
  95.             fullPath:  fullPath,
  96.         }
  97.         n.children = []*node{child}
  98.         return
  99.     }
  100.     // 如果没有找到通配符，只需插入路径和句柄
  101.     n.path = path
  102.     n.handlers = handlers
  103.     n.fullPath = fullPath
  104. }

insertChild函数是根据path本身进行分割，将/分开的部分分别作为节点保存，形成一棵树结构。参数匹配中的:和*的区别是，前者是匹配一个字段而后者是匹配后面所有的路径。

路由匹配

我们先来看gin框架处理请求的入口函数ServeHTTP：

  1. // gin.go
  2. func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
  3.   // 这里使用了对象池
  4.     c := engine.pool.Get().(*Context)
  5.   // 这里有一个细节就是Get对象后做初始化
  6.     c.writermem.reset(w)
  7.     c.Request = req
  8.     c.reset()
  9.     engine.handleHTTPRequest(c)  // 我们要找的处理HTTP请求的函数
  10.     engine.pool.Put(c)  // 处理完请求后将对象放回池子
  11. }

函数很长，这里省略了部分代码，只保留相关逻辑代码：

  1. // gin.go
  2. func (engine *Engine) handleHTTPRequest(c *Context) {
  3.     // liwenzhou.com...
  4.     // 根据请求方法找到对应的路由树
  5.     t := engine.trees
  6.     for i, tl := 0, len(t); i < tl; i++ {
  7.         if t[i].method != httpMethod {
  8.             continue
  9.         }
  10.         root := t[i].root
  11.         // 在路由树中根据path查找
  12.         value := root.getValue(rPath, c.Params, unescape)
  13.         if value.handlers != nil {
  14.             c.handlers = value.handlers
  15.             c.Params = value.params
  16.             c.fullPath = value.fullPath
  17.             c.Next()  // 执行函数链条
  18.             c.writermem.WriteHeaderNow()
  19.             return
  20.         }
  22.     // liwenzhou.com...
  23.     c.handlers = engine.allNoRoute
  24.     serveError(c, http.StatusNotFound, default404Body)
  25. }

路由匹配是由节点的 getValue方法实现的。getValue根据给定的路径(键)返回nodeValue值，保存注册的处理函数和匹配到的路径参数数据。
如果找不到任何处理函数，则会尝试TSR(尾随斜杠重定向)。
代码虽然很长，但还算比较工整。大家可以借助注释看一下路由查找及参数匹配的逻辑。

  1. // tree.go
  2. type nodeValue struct {
  3.     handlers HandlersChain
  4.     params   Params  // []Param
  5.     tsr      bool
  6.     fullPath string
  7. }
  8. // liwenzhou.com...
  9. func (n *node) getValue(path string, po Params, unescape bool) (value nodeValue) {
  10.     value.params = po
  11. walk: // Outer loop for walking the tree
  12.     for {
  13.         prefix := n.path
  14.         if path == prefix {
  15.             // 我们应该已经到达包含处理函数的节点。
  16.             // 检查该节点是否注册有处理函数
  17.             if value.handlers = n.handlers; value.handlers != nil {
  18.                 value.fullPath = n.fullPath
  19.                 return
  20.             }
  21.             if path == "/" && n.wildChild && n.nType != root {
  22.                 value.tsr = true
  23.                 return
  24.             }
  25.             // 没有找到处理函数 检查这个路径末尾+/ 是否存在注册函数
  26.             indices := n.indices
  27.             for i, max := 0, len(indices); i < max; i++ {
  28.                 if indices[i] == '/' {
  29.                     n = n.children[i]
  30.                     value.tsr = (len(n.path) == 1 && n.handlers != nil) ||
  31.                         (n.nType == catchAll && n.children[0].handlers != nil)
  32.                     return
  33.                 }
  34.             }
  35.             return
  36.         }
  37.         if len(path) > len(prefix) && path[:len(prefix)] == prefix {
  38.             path = path[len(prefix):]
  39.             // 如果该节点没有通配符(param或catchAll)子节点
  40.             // 我们可以继续查找下一个子节点
  41.             if !n.wildChild {
  42.                 c := path[0]
  43.                 indices := n.indices
  44.                 for i, max := 0, len(indices); i < max; i++ {
  45.                     if c == indices[i] {
  46.                         n = n.children[i] // 遍历树
  47.                         continue walk
  48.                     }
  49.                 }
  50.                 // 没找到
  51.                 // 如果存在一个相同的URL但没有末尾/的叶子节点
  52.                 // 我们可以建议重定向到那里
  53.                 value.tsr = path == "/" && n.handlers != nil
  54.                 return
  55.             }
  56.             // 根据节点类型处理通配符子节点
  57.             n = n.children[0]
  58.             switch n.nType {
  59.             case param:
  60.                 // find param end (either '/' or path end)
  61.                 end := 0
  62.                 for end < len(path) && path[end] != '/' {
  63.                     end++
  64.                 }
  65.                 // 保存通配符的值
  66.                 if cap(value.params) < int(n.maxParams) {
  67.                     value.params = make(Params, 0, n.maxParams)
  68.                 }
  69.                 i := len(value.params)
  70.                 value.params = value.params[:i+1] // 在预先分配的容量内扩展slice
  71.                 value.params[i].Key = n.path[1:]
  72.                 val := path[:end]
  73.                 if unescape {
  74.                     var err error
  75.                     if value.params[i].Value, err = url.QueryUnescape(val); err != nil {
  76.                         value.params[i].Value = val // fallback, in case of error
  77.                     }
  78.                 } else {
  79.                     value.params[i].Value = val
  80.                 }
  81.                 // 继续向下查询
  82.                 if end < len(path) {
  83.                     if len(n.children) > 0 {
  84.                         path = path[end:]
  85.                         n = n.children[0]
  86.                         continue walk
  87.                     }
  88.                     // ... but we can't
  89.                     value.tsr = len(path) == end+1
  90.                     return
  91.                 }
  92.                 if value.handlers = n.handlers; value.handlers != nil {
  93.                     value.fullPath = n.fullPath
  94.                     return
  95.                 }
  96.                 if len(n.children) == 1 {
  97.                     // 没有找到处理函数. 检查此路径末尾加/的路由是否存在注册函数
  98.                     // 用于 TSR 推荐
  99.                     n = n.children[0]
  100.                     value.tsr = n.path == "/" && n.handlers != nil
  101.                 }
  102.                 return
  103.             case catchAll:
  104.                 // 保存通配符的值
  105.                 if cap(value.params) < int(n.maxParams) {
  106.                     value.params = make(Params, 0, n.maxParams)
  107.                 }
  108.                 i := len(value.params)
  109.                 value.params = value.params[:i+1] // 在预先分配的容量内扩展slice
  110.                 value.params[i].Key = n.path[2:]
  111.                 if unescape {
  112.                     var err error
  113.                     if value.params[i].Value, err = url.QueryUnescape(path); err != nil {
  114.                         value.params[i].Value = path // fallback, in case of error
  115.                     }
  116.                 } else {
  117.                     value.params[i].Value = path
  118.                 }
  119.                 value.handlers = n.handlers
  120.                 value.fullPath = n.fullPath
  121.                 return
  122.             default:
  123.                 panic("invalid node type")
  124.             }
  125.         }
  126.         // 找不到，如果存在一个在当前路径最后添加/的路由
  127.         // 我们会建议重定向到那里
  128.         value.tsr = (path == "/") ||
  129.             (len(prefix) == len(path)+1 && prefix[len(path)] == '/' &&
  130.                 path == prefix[:len(prefix)-1] && n.handlers != nil)
  131.         return
  132.     }
  133. }

gin框架中间件详解

gin框架涉及中间件相关有4个常用的方法，它们分别是c.Next()、c.Abort()、c.Set()、c.Get()。

中间件的注册

gin框架中的中间件设计很巧妙，我们可以首先从我们最常用的r := gin.Default()的Default函数开始看，它内部构造一个新的engine之后就通过Use()函数注册了Logger中间件和Recovery中间件：

  1. func Default() *Engine {
  2.     debugPrintWARNINGDefault()
  3.     engine := New()
  4.     engine.Use(Logger(), Recovery())  // 默认注册的两个中间件
  5.     return engine
  6. }

继续往下查看一下Use()函数的代码：

  1. func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
  2.     engine.RouterGroup.Use(middleware...)  // 实际上还是调用的RouterGroup的Use函数
  3.     engine.rebuild404Handlers()
  4.     engine.rebuild405Handlers()
  5.     return engine
  6. }

从下方的代码可以看出，注册中间件其实就是将中间件函数追加到group.Handlers中：

  1. func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
  2.     group.Handlers = append(group.Handlers, middleware...)
  3.     return group.returnObj()
  4. }

而我们注册路由时会将对应路由的函数和之前的中间件函数结合到一起：

  1. func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
  2.     absolutePath := group.calculateAbsolutePath(relativePath)
  3.     handlers = group.combineHandlers(handlers)  // 将处理请求的函数与中间件函数结合
  4.     group.engine.addRoute(httpMethod, absolutePath, handlers)
  5.     return group.returnObj()
  6. }

其中结合操作的函数内容如下，注意观察这里是如何实现拼接两个切片得到一个新切片的。

  1. const abortIndex int8 = math.MaxInt8 / 2
  2. func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
  3.     finalSize := len(group.Handlers) + len(handlers)
  4.     if finalSize >= int(abortIndex) {  // 这里有一个最大限制
  5.         panic("too many handlers")
  6.     }
  7.     mergedHandlers := make(HandlersChain, finalSize)
  8.     copy(mergedHandlers, group.Handlers)
  9.     copy(mergedHandlers[len(group.Handlers):], handlers)
  10.     return mergedHandlers
  11. }

也就是说，我们会将一个路由的中间件函数和处理函数结合到一起组成一条处理函数链条HandlersChain，而它本质上就是一个由HandlerFunc组成的切片：

  1. type HandlersChain []HandlerFunc

中间件的执行

我们在上面路由匹配的时候见过如下逻辑：

  1. value := root.getValue(rPath, c.Params, unescape)
  2. if value.handlers != nil {
  3.   c.handlers = value.handlers
  4.   c.Params = value.params
  5.   c.fullPath = value.fullPath
  6.   c.Next()  // 执行函数链条
  7.   c.writermem.WriteHeaderNow()
  8.   return
  9. }

其中c.Next()就是很关键的一步，它的代码很简单：

  1. func (c *Context) Next() {
  2.     c.index++
  3.     for c.index < int8(len(c.handlers)) {
  4.         c.handlers[c.index](c)
  5.         c.index++
  6.     }
  7. }

从上面的代码可以看到，这里通过索引遍历HandlersChain链条，从而实现依次调用该路由的每一个函数（中间件或处理请求的函数）。
gin框架源码解析 - 图3
我们可以在中间件函数中通过再次调用c.Next()实现嵌套调用（func1中调用func2；func2中调用func3），
gin框架源码解析 - 图4
或者通过调用c.Abort()中断整个调用链条，从当前函数返回。

  1. func (c *Context) Abort() {
  2.     c.index = abortIndex  // 直接将索引置为最大限制值，从而退出循环
  3. }

c.Set()/c.Get()

c.Set()和c.Get()这两个方法多用于在多个函数之间通过c传递数据的，比如我们可以在认证中间件中获取当前请求的相关信息（userID等）通过c.Set()存入c，然后在后续处理业务逻辑的函数中通过c.Get()来获取当前请求的用户。c就像是一根绳子，将该次请求相关的所有的函数都串起来了。gin框架源码解析 - 图5

总结

  1. gin框架路由使用前缀树，路由注册的过程是构造前缀树的过程，路由匹配的过程就是查找前缀树的过程。
  2. gin框架的中间件函数和处理函数是以切片形式的调用链条存在的，我们可以顺序调用也可以借助c.Next()方法实现嵌套调用。
  3. 借助c.Set()和c.Get()方法我们能够在不同的中间件函数中传递数据。