gin框架是基于Golang的一个web框架，由于比较简单容易上手的开源框架
github地址：https://github.com/gin-gonic/gin
中文文档:https://gin-gonic.com/zh-cn/

1.特性

快速
基于 Radix 树的路由，小内存占用。没有反射。可预测的 API 性能。
支持中间件
传入的 HTTP 请求可以由一系列中间件和最终操作来处理。 例如：Logger，Authorization，GZIP，最终操作 DB。
Crash 处理
Gin 可以 catch 一个发生在 HTTP 请求中的 panic 并 recover 它。这样，你的服务器将始终可用。例如，你可以向 Sentry 报告这个 panic！
JSON 验证
Gin 可以解析并验证请求的 JSON，例如检查所需值的存在。
路由组
更好地组织路由。是否需要授权，不同的 API 版本…… 此外，这些组可以无限制地嵌套而不会降低性能。
错误管理
Gin 提供了一种方便的方法来收集 HTTP 请求期间发生的所有错误。最终，中间件可以将它们写入日志文件，数据库并通过网络发送。
内置渲染
Gin 为 JSON，XML 和 HTML 渲染提供了易于使用的 API。

2.具体使用

初始化与路由设置

  1. router := gin.New()               //new方法需要手动加载 Recovery 和 Logger 中间件
  2. router = gin.Default()            //Default 使用 Logger 和 Recovery 中间件
  4. router.Use(middleware...)         //注册全局中间件
  5. userGroup := router.Group("/user")
  6. userGroup.Use(middleware...)      //注册路由组中间件
  7. userGroup.Get("/detail",userController.Detail)//http://localhost:8088/user/detail

创建一个get的API接口

  1. func main() {
  2.     r := gin.Default()
  3.     r.GET("/testApi/print", func(c *gin.Context) {
  4.         c.JSON(http.StatusOK, gin.H{
  5.             "data": "hello world!",
  6.         })
  7.     })
  8.     r.Run() // 监听并在 0.0.0.0:8080 上启动服务
  9. }

获取http请求的参数

  1. c := gin.Context
  2. userName := c.Query("userName")//获取get参数
  3. form := c.PostForm("userName")//获取post参数
  4. file,header,err := c.Request.FormFile("file")//以io流的形式获取文件，可以不用保存到本地
  5. err = c.Bind(formStruct)//获取表单，推荐；formStruct是你想要的数据的结构体
  7. type formStruct struct{
  8.     UserName string `json:"userName"`
  9.     PassWord string `json:"passWord"`
  10. }

设置结束函数

gin.Context.Next()与gin.Context.Abort()通常放在函数的末尾，分别代表加载下一个和结束

  1. //gin.Context.Next()
  2. func (c *Context) Next() {
  3.     c.index++
  4.     for c.index < int8(len(c.handlers)) {
  5.         c.handlers[c.index](c)
  6.         c.index++
  7.     }
  8. }
  11. //gin.Context.Abort()
  12. const abortIndex int8 = math.MaxInt8 / 2
  13. func (c *Context) Abort() {
  14.     c.index = abortIndex
  15. }

关闭http服务

  1. func main() {
  2.     router := gin.Default()
  3.     router.GET("/", func(c *gin.Context) {
  4.         time.Sleep(5 * time.Second)
  5.         c.String(http.StatusOK, "Welcome Gin Server")
  6.     })
  8.     srv := &http.Server{
  9.         Addr:    ":8080",
  10.         Handler: router,
  11.     }
  13.     go func() {
  14.         // 服务连接
  15.         if err := srv.ListenAndServe(); err != nil && err != http.ErrServerClosed {
  16.             log.Fatalf("listen: %s\n", err)
  17.         }
  18.     }()
  20.     // 等待中断信号以优雅地关闭服务器（设置 5 秒的超时时间）
  21.     quit := make(chan os.Signal)
  22.     signal.Notify(quit, os.Interrupt)
  23.     <-quit
  24.     log.Println("Shutdown Server ...")
  26.     ctx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
  27.     defer cancel()
  28.     if err := srv.Shutdown(ctx); err != nil {
  29.         log.Fatal("Server Shutdown:", err)
  30.     }
  31.     log.Println("Server exiting")
  32. }

3.底层代码分析

Engine 容器对象,整个框架的基础
Engine.trees 负责存储路由和handle方法的映射,采用类似字典树的结构，go的每种方法（GET，POST，DELETE等）都有自己单独的树
Engine.RouterGroup,其中的Handlers存储着所有中间件
Context上下文对象,负责处理请求和回应,其中的handlers是存储处理请求时中间件和处理方法的

开启http处理及路由匹配

可以看出底层还是使用了go自带的http包来进行处理，通过实现ServeHTTP方法来实现gin自己的http处理
go自带的处理函数虽然已经实现了基本功能，但是路由匹配功能过于简单（处理http请求是单独开启gorouti）

  1. func (engine *Engine) Run(addr ...string) (err error) {
  2.     //省略部分代码...
  3.     address := resolveAddress(addr)
  4.     debugPrint("Listening and serving HTTP on %s\n", address)
  5.     err = http.ListenAndServe(address, engine)
  6.     return
  7. }
  1. func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
  2.     c := engine.pool.Get().(*Context)//pool是一个sync.pool结构
  3.     // Get对象后做初始化
  4.     c.writermem.reset(w)
  5.     c.Request = req
  6.     c.reset()//重置所有参数
  8.     engine.handleHTTPRequest(c)
  10.     engine.pool.Put(c)
  11. }
  1. // gin.go
  2. func (engine *Engine) handleHTTPRequest(c *Context) {
  3.     // ...
  5.     // 根据请求方法找到对应的路由树
  6.     t := engine.trees
  7.     for i, tl := 0, len(t); i < tl; i++ {
  8.         if t[i].method != httpMethod {
  9.             continue
  10.         }
  11.         root := t[i].root
  12.         // Find route in tree
  13.         value := root.getValue(rPath, c.params, c.skippedNodes, unescape)
  14.         if value.params != nil {
  15.             c.Params = *value.params
  16.         }
  17.         if value.handlers != nil {
  18.             c.handlers = value.handlers
  19.             c.fullPath = value.fullPath
  20.             c.Next() // 执行函数链条
  21.             c.writermem.WriteHeaderNow()
  22.             return
  23.         }
  24.         //...
  25.     }
  26.     // ...
  27.     c.handlers = engine.allNoRoute
  28.     serveError(c, http.StatusNotFound, default404Body)
  29. }
  1. // tree.go
  2. type nodeValue struct {
  3.     handlers HandlersChain
  4.     params   *Params //[]Param  key->value
  5.     tsr      bool
  6.     fullPath string
  7. }
  10. func (n *node) getValue(path string, params *Params, skippedNodes *[]skippedNode, unescape bool) (value nodeValue) {
  11.     var globalParamsCount int16
  13. walk: // Outer loop for walking the tree
  14.     for {
  15.         prefix := n.path
  16.         if len(path) > len(prefix) {
  17.             if path[:len(prefix)] == prefix {
  18.                 path = path[len(prefix):]
  20.                 // Try all the non-wildcard children first by matching the indices
  21.                 idxc := path[0]
  22.                 for i, c := range []byte(n.indices) {
  23.                     if c == idxc {
  24. //  strings.HasPrefix(n.children[len(n.children)-1].path, ":") == n.wildChild
  25.                         if n.wildChild {
  26.                             index := len(*skippedNodes)
  27.                             *skippedNodes = (*skippedNodes)[:index+1]
  28.                             (*skippedNodes)[index] = skippedNode{
  29.                                 path: prefix + path,
  30.                                 node: &node{
  31.                                     path:      n.path,
  32.                                     wildChild: n.wildChild,
  33.                                     nType:     n.nType,
  34.                                     priority:  n.priority,
  35.                                     children:  n.children,
  36.                                     handlers:  n.handlers,
  37.                                     fullPath:  n.fullPath,
  38.                                 },
  39.                                 paramsCount: globalParamsCount,
  40.                             }
  41.                         }
  43.                         n = n.children[i]
  44.                         continue walk
  45.                     }
  46.                 }
  48.                 if !n.wildChild {
  49.                     // If the path at the end of the loop is not equal to '/' and the current node has no child nodes
  50.                     // the current node needs to roll back to last vaild skippedNode
  51.                     if path != "/" {
  52.                         for l := len(*skippedNodes); l > 0; {
  53.                             skippedNode := (*skippedNodes)[l-1]
  54.                             *skippedNodes = (*skippedNodes)[:l-1]
  55.                             if strings.HasSuffix(skippedNode.path, path) {
  56.                                 path = skippedNode.path
  57.                                 n = skippedNode.node
  58.                                 if value.params != nil {
  59.                                     *value.params = (*value.params)[:skippedNode.paramsCount]
  60.                                 }
  61.                                 globalParamsCount = skippedNode.paramsCount
  62.                                 continue walk
  63.                             }
  64.                         }
  65.                     }
  67.                     // Nothing found.
  68.                     // We can recommend to redirect to the same URL without a
  69.                     // trailing slash if a leaf exists for that path.
  70.                     value.tsr = path == "/" && n.handlers != nil
  71.                     return
  72.                 }
  74.                 // Handle wildcard child, which is always at the end of the array
  75.                 n = n.children[len(n.children)-1]
  76.                 globalParamsCount++
  78.                 switch n.nType {
  79.                 case param:
  80.                     // fix truncate the parameter
  81.                     // tree_test.go  line: 204
  83.                     // Find param end (either '/' or path end)
  84.                     end := 0
  85.                     for end < len(path) && path[end] != '/' {
  86.                         end++
  87.                     }
  89.                     // Save param value
  90.                     if params != nil && cap(*params) > 0 {
  91.                         if value.params == nil {
  92.                             value.params = params
  93.                         }
  94.                         // Expand slice within preallocated capacity
  95.                         i := len(*value.params)
  96.                         *value.params = (*value.params)[:i+1]
  97.                         val := path[:end]
  98.                         if unescape {
  99.                             if v, err := url.QueryUnescape(val); err == nil {
  100.                                 val = v
  101.                             }
  102.                         }
  103.                         (*value.params)[i] = Param{
  104.                             Key:   n.path[1:],
  105.                             Value: val,
  106.                         }
  107.                     }
  109.                     // we need to go deeper!
  110.                     if end < len(path) {
  111.                         if len(n.children) > 0 {
  112.                             path = path[end:]
  113.                             n = n.children[0]
  114.                             continue walk
  115.                         }
  117.                         // ... but we can't
  118.                         value.tsr = len(path) == end+1
  119.                         return
  120.                     }
  122.                     if value.handlers = n.handlers; value.handlers != nil {
  123.                         value.fullPath = n.fullPath
  124.                         return
  125.                     }
  126.                     if len(n.children) == 1 {
  127.                         // No handle found. Check if a handle for this path + a
  128.                         // trailing slash exists for TSR recommendation
  129.                         n = n.children[0]
  130.                         value.tsr = n.path == "/" && n.handlers != nil
  131.                     }
  132.                     return
  134.                 case catchAll:
  135.                     // Save param value
  136.                     if params != nil {
  137.                         if value.params == nil {
  138.                             value.params = params
  139.                         }
  140.                         // Expand slice within preallocated capacity
  141.                         i := len(*value.params)
  142.                         *value.params = (*value.params)[:i+1]
  143.                         val := path
  144.                         if unescape {
  145.                             if v, err := url.QueryUnescape(path); err == nil {
  146.                                 val = v
  147.                             }
  148.                         }
  149.                         (*value.params)[i] = Param{
  150.                             Key:   n.path[2:],
  151.                             Value: val,
  152.                         }
  153.                     }
  155.                     value.handlers = n.handlers
  156.                     value.fullPath = n.fullPath
  157.                     return
  159.                 default:
  160.                     panic("invalid node type")
  161.                 }
  162.             }
  163.         }
  165.         if path == prefix {
  166.             // If the current path does not equal '/' and the node does not have a registered handle and the most recently matched node has a child node
  167.             // the current node needs to roll back to last vaild skippedNode
  168.             if n.handlers == nil && path != "/" {
  169.                 for l := len(*skippedNodes); l > 0; {
  170.                     skippedNode := (*skippedNodes)[l-1]
  171.                     *skippedNodes = (*skippedNodes)[:l-1]
  172.                     if strings.HasSuffix(skippedNode.path, path) {
  173.                         path = skippedNode.path
  174.                         n = skippedNode.node
  175.                         if value.params != nil {
  176.                             *value.params = (*value.params)[:skippedNode.paramsCount]
  177.                         }
  178.                         globalParamsCount = skippedNode.paramsCount
  179.                         continue walk
  180.                     }
  181.                 }
  182.                 //    n = latestNode.children[len(latestNode.children)-1]
  183.             }
  184.             // We should have reached the node containing the handle.
  185.             // Check if this node has a handle registered.
  186.             if value.handlers = n.handlers; value.handlers != nil {
  187.                 value.fullPath = n.fullPath
  188.                 return
  189.             }
  191.             // If there is no handle for this route, but this route has a
  192.             // wildcard child, there must be a handle for this path with an
  193.             // additional trailing slash
  194.             if path == "/" && n.wildChild && n.nType != root {
  195.                 value.tsr = true
  196.                 return
  197.             }
  199.             // No handle found. Check if a handle for this path + a
  200.             // trailing slash exists for trailing slash recommendation
  201.             for i, c := range []byte(n.indices) {
  202.                 if c == '/' {
  203.                     n = n.children[i]
  204.                     value.tsr = (len(n.path) == 1 && n.handlers != nil) ||
  205.                         (n.nType == catchAll && n.children[0].handlers != nil)
  206.                     return
  207.                 }
  208.             }
  210.             return
  211.         }
  213.         // Nothing found. We can recommend to redirect to the same URL with an
  214.         // extra trailing slash if a leaf exists for that path
  215.         value.tsr = path == "/" ||
  216.             (len(prefix) == len(path)+1 && prefix[len(path)] == '/' &&
  217.                 path == prefix[:len(prefix)-1] && n.handlers != nil)
  219.         // roll back to last valid skippedNode
  220.         if !value.tsr && path != "/" {
  221.             for l := len(*skippedNodes); l > 0; {
  222.                 skippedNode := (*skippedNodes)[l-1]
  223.                 *skippedNodes = (*skippedNodes)[:l-1]
  224.                 if strings.HasSuffix(skippedNode.path, path) {
  225.                     path = skippedNode.path
  226.                     n = skippedNode.node
  227.                     if value.params != nil {
  228.                         *value.params = (*value.params)[:skippedNode.paramsCount]
  229.                     }
  230.                     globalParamsCount = skippedNode.paramsCount
  231.                     continue walk
  232.                 }
  233.             }
  234.         }
  236.         return
  237.     }
  238. }

总体来说，就是遍历整个前缀树，直到找到有handler方法的节点

  1. // Next should be used only inside middleware.
  2. // It executes the pending handlers in the chain inside the calling handler.
  3. func (c *Context) Next() {
  4.     c.index++
  5.     for c.index < int8(len(c.handlers)) {
  6.         c.handlers[c.index](c)
  7.         c.index++
  8.     }
  9. }

注意next方法要在中间件中使用，类似嵌套关系，使用next()代表执行完next()所在行之前的方法后就先加载链路后面的内容，否则就先执行本节点后面的内容

路由注册

在我们使用GET，POST等方法后，都会调用handle方法，只不过httpMethod对应的不同

  1. func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
  2.     //拼接绝对路径，将之前可能有的和新输入的进行拼接,源码看下面
  3.     absolutePath := group.calculateAbsolutePath(relativePath)
  4.     //方法拼接
  5.     handlers = group.combineHandlers(handlers)
  6.     group.engine.addRoute(httpMethod, absolutePath, handlers)
  7.     return group.returnObj()
  8. }
  10. func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
  11.     //省略判断路由格式代码...
  13.     //trees是一个methodTree切片，包含method和root，root是一个*node，method是GET，POST等
  14.     root := engine.trees.get(method)
  15.     if root == nil {
  16.         root = new(node)
  17.         root.fullPath = "/"
  18.         engine.trees = append(engine.trees, methodTree{method: method, root: root})
  19.     }
  20.     root.addRoute(path, handlers)//更新前缀树
  22.     // Update maxParams...
  23. }
  1. type node struct {
  2.    // 当前节点路径
  3.     path      string
  4.     // 和children字段对应, 保存的是分裂的分支的第一个字符
  5.     // 例如search和support, 那么s节点的indices对应的"eu"
  6.     // 代表有两个分支, 分支的首字母分别是e和u
  7.     indices   string
  8.     // 儿子节点
  9.     children  []*node
  10.     // 处理函数链条（切片）
  11.     handlers  HandlersChain
  12.     // 优先级，子节点、子子节点等注册的handler数量
  13.     priority  uint32
  14.     // 节点类型，包括static, root, param, catchAll
  15.     // static: 静态节点（默认），比如上面的s，earch等节点
  16.     // root: 树的根节点
  17.     // catchAll: 有*匹配的节点
  18.     // param: 参数节点
  19.     nType     nodeType
  20.     // 路径上最大参数个数
  21.     maxParams uint8
  22.     // 节点是否是参数节点，比如上面的:post
  23.     wildChild bool
  24.     // 完整路径
  25.     fullPath  string
  26. }

不论是Group（）还是Handle（）都使用了calculateAbsolutePath和combineHandlers这两个方法，保存在RouterGroup这个指针对象中

  1. //计算路由
  2. func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {
  3.     return joinPaths(group.basePath, relativePath)
  4. }
  6. func joinPaths(absolutePath, relativePath string) string {
  7.     if relativePath == "" {
  8.         return absolutePath
  9.     }
  11.     finalPath := path.Join(absolutePath, relativePath)
  12.     if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
  13.         return finalPath + "/"
  14.     }
  15.     return finalPath
  16. }
  17. //方法拼接
  18. func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
  19.     finalSize := len(group.Handlers) + len(handlers)
  20.     if finalSize >= int(abortIndex) {
  21.         panic("too many handlers")
  22.     }
  23.     mergedHandlers := make(HandlersChain, finalSize)
  24.     copy(mergedHandlers, group.Handlers)
  25.     copy(mergedHandlers[len(group.Handlers):], handlers)
  26.     return mergedHandlers
  27. }
  1. // tree.go
  3. // addRoute 将具有给定句柄的节点添加到路径中。
  4. // 不是并发安全的
  5. func (n *node) addRoute(path string, handlers HandlersChain) {
  6.     fullPath := path
  7.     n.priority++
  9.     // 空树就直接插入当前节点
  10.     if len(n.path) == 0 && len(n.children) == 0 {
  11.         n.insertChild(path, fullPath, handlers)
  12.         n.nType = root
  13.         return
  14.     }
  16.     parentFullPathIndex := 0
  18. walk:
  19.     for {
  20.         // 找到最长的通用前缀
  21.         // 这也意味着公共前缀不包含“:”"或“*” /
  22.         // 因为现有键不能包含这些字符。
  23.         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.             }
  39.             n.children = []*node{&child}
  40.             // []byte for proper unicode char conversion, see #65
  41.             n.indices = bytesconv.BytesToString([]byte{n.path[i]})
  42.             n.path = path[:i]
  43.             n.handlers = nil
  44.             n.wildChild = false
  45.             n.fullPath = fullPath[:parentFullPathIndex+i]
  46.         }
  48.         // 将新来的节点插入新的parent节点作为子节点
  49.         if i < len(path) {
  50.             path = path[i:]
  51.             // 取path首字母，用来与indices做比较
  52.             c := path[0]
  54.             // 处理参数后加斜线情况
  55.             if n.nType == param && c == '/' && len(n.children) == 1 {
  56.                 parentFullPathIndex += len(n.path)
  57.                 n = n.children[0]
  58.                 n.priority++
  59.                 continue walk
  60.             }
  62.             // 检查路path下一个字节的子节点是否存在
  63.             // 比如s的子节点现在是earch和upport，indices为eu
  64.             // 如果新加一个路由为super，那么就是和upport有匹配的部分u，将继续分列现在的upport节点
  65.             for i, max := 0, len(n.indices); i < max; i++ {
  66.                 if c == n.indices[i] {
  67.                     parentFullPathIndex += len(n.path)
  68.                     i = n.incrementChildPrio(i)
  69.                     n = n.children[i]
  70.                     continue walk
  71.                 }
  72.             }
  74.             // 否则就插入
  75.             if c != ':' && c != '*' && n.nType != catchAll {
  76.                 // []byte for proper unicode char conversion, see #65
  77.                 // 注意这里是直接拼接第一个字符到n.indices
  78.                 n.indices += bytesconv.BytesToString([]byte{c})
  79.                 child := &node{
  80.                     fullPath:  fullPath,
  81.                 }
  82.                 // 追加子节点
  83.                 n.children = append(n.children, child)
  84.                 n.incrementChildPrio(len(n.indices) - 1)
  85.                 n = child
  86.             }else if n.wildChild {// 如果是参数节点
  87.                 n = n.children[len(n.children)-1]
  88.                 n.priority++
  90.                // 检查通配符是否匹配
  91.                 if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
  92.                     // Adding a child to a catchAll is not possible
  93.                     n.nType != catchAll &&
  94.                     // 检查更长的通配符, 例如 :name and :names
  95.                     (len(n.path) >= len(path) || path[len(n.path)] == '/') {
  96.                     continue walk
  97.                 }
  99.                 // Wildcard conflict
  100.                 pathSeg := path
  101.                 if n.nType != catchAll {
  102.                     pathSeg = strings.SplitN(pathSeg, "/", 2)[0]
  103.                 }
  104.                 prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
  105.                 panic("'" + pathSeg +
  106.                     "' in new path '" + fullPath +
  107.                     "' conflicts with existing wildcard '" + n.path +
  108.                     "' in existing prefix '" + prefix +
  109.                     "'")
  110.             }
  111.             n.insertChild(path, fullPath, handlers)
  112.             return
  113.         }
  115.         // 已经注册过的节点
  116.         if n.handlers != nil {
  117.             panic("handlers are already registered for path '" + fullPath + "'")
  118.         }
  119.         n.handlers = handlers
  120.         return
  121.     }
  122. }
  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.         }
  11.         // 通配符的名称必须不包含':' 和 '*'
  12.         if !valid {
  13.             panic("only one wildcard per path segment is allowed, has: '" +
  14.                 wildcard + "' in path '" + fullPath + "'")
  15.         }
  17.         // 检查通配符是否有名称
  18.         if len(wildcard) < 2 {
  19.             panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
  20.         }
  22.         // 检查这个节点是否有已经存在的子节点
  23.         // 如果我们在这里插入通配符，这些子节点将无法访问
  24.         if len(n.children) > 0 {
  25.             panic("wildcard segment '" + wildcard +
  26.                 "' conflicts with existing children in path '" + fullPath + "'")
  27.         }
  29.         if wildcard[0] == ':' { // param
  30.             if i > 0 {
  31.                 // 在当前通配符之前插入前缀
  32.                 n.path = path[:i]
  33.                 path = path[i:]
  34.             }
  36.             n.wildChild = true
  37.             child := &node{
  38.                 nType:     param,
  39.                 path:      wildcard,
  40.                 maxParams: numParams,
  41.                 fullPath:  fullPath,
  42.             }
  43.             n.children = []*node{child}
  44.             n = child
  45.             n.priority++
  46.             numParams--
  48.             // 如果路径没有以通配符结束
  49.             // 那么将有另一个以'/'开始的非通配符子路径。
  50.             if len(wildcard) < len(path) {
  51.                 path = path[len(wildcard):]
  53.                 child := &node{
  54.                     maxParams: numParams,
  55.                     priority:  1,
  56.                     fullPath:  fullPath,
  57.                 }
  58.                 n.children = []*node{child}
  59.                 n = child  // 继续下一轮循环
  60.                 continue
  61.             }
  63.             // 否则我们就完成了。将处理函数插入新叶子中
  64.             n.handlers = handlers
  65.             return
  66.         }
  68.         // catchAll
  69.         if i+len(wildcard) != len(path) || numParams > 1 {
  70.             panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
  71.         }
  73.         if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
  74.             panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
  75.         }
  77.         // currently fixed width 1 for '/'
  78.         i--
  79.         if path[i] != '/' {
  80.             panic("no / before catch-all in path '" + fullPath + "'")
  81.         }
  83.         n.path = path[:i]
  85.         // 第一个节点:路径为空的catchAll节点
  86.         child := &node{
  87.             wildChild: true,
  88.             nType:     catchAll,
  89.             maxParams: 1,
  90.             fullPath:  fullPath,
  91.         }
  92.         // 更新父节点的maxParams
  93.         if n.maxParams < 1 {
  94.             n.maxParams = 1
  95.         }
  96.         n.children = []*node{child}
  97.         n.indices = string('/')
  98.         n = child
  99.         n.priority++
  101.         // 第二个节点:保存变量的节点
  102.         child = &node{
  103.             path:      path[i:],
  104.             nType:     catchAll,
  105.             maxParams: 1,
  106.             handlers:  handlers,
  107.             priority:  1,
  108.             fullPath:  fullPath,
  109.         }
  110.         n.children = []*node{child}
  112.         return
  113.     }
  115.     // 如果没有找到通配符，只需插入路径和句柄
  116.     n.path = path
  117.     n.handlers = handlers
  118.     n.fullPath = fullPath
  119. }

注册中间件

  1. // Use adds middleware to the group, see example code in GitHub.
  2. func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
  3.     group.Handlers = append(group.Handlers, middleware...)
  4.     return group.returnObj()
  5. }
  7. type RouterGroup struct {
  8.     Handlers HandlersChain //type HandlersChain []HandlerFunc
  9.     basePath string
  10.     engine   *Engine
  11.     root     bool
  12. }

之前提到gin.Default()和gin.New()的不同在于是否需要自己加载log和reovery中间件

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

参考

https://baijiahao.baidu.com/s?id=1716852044736696668&wfr=spider&for=pc
https://blog.csdn.net/luo1324574369/article/details/108310032
https://blog.csdn.net/weixin_45961841/article/details/113722686
https://blog.csdn.net/qq_37767455/article/details/104712028