go 语言 Gin Web 框架的实现原理探究

Gin 是一个用 Go (Golang) 编写的 Web 框架，性能极优，具有快速、支持中心件、crash处理、json验证、路由组、错误管理、内存渲染、可扩展性等特点。
官网地址：https://gin-gonic.com/
源码地址：https://github.com/gin-gonic/gin/tree/v1.10.0
参考视频：gin框架底层技能原理分析_哔哩哔哩_bilibili

一、net/http 及 gin 使用示例

• 使用 net/http 创建 web 服务
  

1. package main
3. import (
4.         "net/http"
5. )
7. func main() {
8.         // 使用 net/http 创建 web 服务
9.         // 注册路由
10.         http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
11.                 w.Write([]byte("Hello World!"))
12.         })
14.         // 启动监听
15.         http.ListenAndServe(":8080", nil)
16. }

复制代码

• 使用 gin 创建 web 服务
  

1. package main
3. import (
4.         "net/http"
6.         "github.com/gin-gonic/gin"
7. )
9. func main() {
10.         // 初始化 engine
11.         r := gin.Default()
13.         // 注册路由
14.         r.GET("/ping", func(c *gin.Context) {
15.                 c.JSON(http.StatusOK, gin.H{
16.                         "message": "pong",
17.                 })
18.         })
20.         // 启动服务
21.         r.Run()
22. }

复制代码

二、gin.Engine数据结构

1. type Engine struct {
2.         RouterGroup  // 路由组
4.         RedirectTrailingSlash bool
6.         RedirectFixedPath bool
8.         HandleMethodNotAllowed bool
10.         ForwardedByClientIP bool
12.         AppEngine bool
14.         UseRawPath bool
16.         UnescapePathValues bool
18.         RemoveExtraSlash bool
20.         RemoteIPHeaders []string
22.         TrustedPlatform string
24.         MaxMultipartMemory int64
26.         // UseH2C enable h2c support.
27.         UseH2C bool
29.         ContextWithFallback bool
31.         delims           render.Delims
32.         secureJSONPrefix string
33.         HTMLRender       render.HTMLRender
34.         FuncMap          template.FuncMap
35.         allNoRoute       HandlersChain
36.         allNoMethod      HandlersChain
37.         noRoute          HandlersChain
38.         noMethod         HandlersChain
40.     // 对象池，用来复用gin.Context
41.         pool             sync.Pool
43.     // 路由树，根据不同的httpmethod，以及不同的路由，拆分http请求及处理函数
44.         trees            methodTrees     
45.         maxParams        uint16
46.         maxSections      uint16
47.         trustedProxies   []string
48.         trustedCIDRs     []*net.IPNet
49. }
51. type RouterGroup struct {
52.         Handlers HandlersChain
53.         basePath string
54.         engine   *Engine
55.         root     bool
56. }
58. type Pool struct {
59.         noCopy noCopy
61.         local     unsafe.Pointer // local fixed-size per-P pool, actual type is [P]poolLocal
62.         localSize uintptr        // size of the local array
64.         victim     unsafe.Pointer // local from previous cycle
65.         victimSize uintptr        // size of victims array
67.         // New optionally specifies a function to generate
68.         // a value when Get would otherwise return nil.
69.         // It may not be changed concurrently with calls to Get.
70.         New func() any
71. }
73. type methodTree struct {
74.         method string
75.         root   *node
76. }
78. type methodTrees []methodTree
80. type node struct {
81.         path      string
82.         indices   string
83.         wildChild bool
84.         nType     nodeType
85.         priority  uint32
86.         children  []*node // child nodes, at most 1 :param style node at the end of the array
87.         handlers  HandlersChain
88.         fullPath  string
89. }
91. type HandlersChain []HandlerFunc

复制代码

1. // src/net/http/method.go
3. // http method
4. const (
5.         MethodGet     = "GET"
6.         MethodHead    = "HEAD"
7.         MethodPost    = "POST"
8.         MethodPut     = "PUT"
9.         MethodPatch   = "PATCH" // RFC 5789
10.         MethodDelete  = "DELETE"
11.         MethodConnect = "CONNECT"
12.         MethodOptions = "OPTIONS"
13.         MethodTrace   = "TRACE"
14. )

复制代码

三、gin 注册路由流程

• 创建engine
  

1. func Default(opts ...OptionFunc) *Engine {
2.         debugPrintWARNINGDefault()
3.         engine := New()
4.         engine.Use(Logger(), Recovery())
5.         return engine.With(opts...)
6. }
8. func New(opts ...OptionFunc) *Engine {
9.         debugPrintWARNINGNew()
10.         engine := &Engine{
11.                 RouterGroup: RouterGroup{
12.                         Handlers: nil,
13.                         basePath: "/",
14.                         root:     true,
15.                 },
16.                 FuncMap:                template.FuncMap{},
17.                 RedirectTrailingSlash:  true,
18.                 RedirectFixedPath:      false,
19.                 HandleMethodNotAllowed: false,
20.                 ForwardedByClientIP:    true,
21.                 RemoteIPHeaders:        []string{"X-Forwarded-For", "X-Real-IP"},
22.                 TrustedPlatform:        defaultPlatform,
23.                 UseRawPath:             false,
24.                 RemoveExtraSlash:       false,
25.                 UnescapePathValues:     true,
26.                 MaxMultipartMemory:     defaultMultipartMemory,
27.                 // 9 棵路由压缩前缀树，对应 http 的 9 种方法
28.         trees:                  make(methodTrees, 0, 9),
29.                 delims:                 render.Delims{Left: "{{", Right: "}}"},
30.                 secureJSONPrefix:       "while(1);",
31.                 trustedProxies:         []string{"0.0.0.0/0", "::/0"},
32.                 trustedCIDRs:           defaultTrustedCIDRs,
33.         }
34.         engine.RouterGroup.engine = engine
35.         engine.pool.New = func() any {
36.                 return engine.allocateContext(engine.maxParams)
37.         }
38.         return engine.With(opts...)
39. }

复制代码

• 注册MiddleWare
  

1. func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
2.         engine.RouterGroup.Use(middleware...)
3.         engine.rebuild404Handlers()
4.         engine.rebuild405Handlers()
5.         return engine
6. }
8. func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
9.         group.Handlers = append(group.Handlers, middleware...)
10.         return group.returnObj()
11. }

复制代码

• 注册handler
  

   以 http post 方法为例，注册 handler 方法调用顺序为 RouterGroup.POST -> RouterGroup.handle：
  

• 拼接出待注册方法的完整路径 absolutePath
  
• 拼接出待注册方法的完整函数处理链 handlers
  
• 以 absolutePath 和 handlers 组成kv对添加到路由树中
  

2. func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
3.         return group.handle(http.MethodPost, relativePath, handlers)
4. }
6. func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
7.         absolutePath := group.calculateAbsolutePath(relativePath)
8.         handlers = group.combineHandlers(handlers)
9.         group.engine.addRoute(httpMethod, absolutePath, handlers)
10.         return group.returnObj()
11. }
13. func joinPaths(absolutePath, relativePath string) string {
14.         if relativePath == "" {
15.                 return absolutePath
16.         }
18.         finalPath := path.Join(absolutePath, relativePath)
19.         if lastChar(relativePath) == '/' && lastChar(finalPath) != '/' {
20.                 return finalPath + "/"
21.         }
22.         return finalPath
23. }
25. func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {
26.         finalSize := len(group.Handlers) + len(handlers)
27.         assert1(finalSize < int(abortIndex), "too many handlers")
28.         mergedHandlers := make(HandlersChain, finalSize)
29.         copy(mergedHandlers, group.Handlers)
30.         copy(mergedHandlers[len(group.Handlers):], handlers)
31.         return mergedHandlers
32. }
34. func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
35.         assert1(path[0] == '/', "path must begin with '/'")
36.         assert1(method != "", "HTTP method can not be empty")
37.         assert1(len(handlers) > 0, "there must be at least one handler")
39.         debugPrintRoute(method, path, handlers)
41.         root := engine.trees.get(method)
42.         if root == nil {
43.                 root = new(node)
44.                 root.fullPath = "/"
45.                 engine.trees = append(engine.trees, methodTree{method: method, root: root})
46.         }
47.         root.addRoute(path, handlers)
49.         if paramsCount := countParams(path); paramsCount > engine.maxParams {
50.                 engine.maxParams = paramsCount
51.         }
53.         if sectionsCount := countSections(path); sectionsCount > engine.maxSections {
54.                 engine.maxSections = sectionsCount
55.         }
56. }
58. func (n *node) addRoute(path string, handlers HandlersChain) {
59.         fullPath := path
60.         n.priority++
62.         // Empty tree
63.         if len(n.path) == 0 && len(n.children) == 0 {
64.                 n.insertChild(path, fullPath, handlers)
65.                 n.nType = root
66.                 return
67.         }
69.         parentFullPathIndex := 0
71. walk:
72.         for {
73.                 // Find the longest common prefix.
74.                 // This also implies that the common prefix contains no ':' or '*'
75.                 // since the existing key can't contain those chars.
76.                 i := longestCommonPrefix(path, n.path)
78.                 // Split edge
79.                 if i < len(n.path) {
80.                         child := node{
81.                                 path:      n.path[i:],
82.                                 wildChild: n.wildChild,
83.                                 nType:     static,
84.                                 indices:   n.indices,
85.                                 children:  n.children,
86.                                 handlers:  n.handlers,
87.                                 priority:  n.priority - 1,
88.                                 fullPath:  n.fullPath,
89.                         }
91.                         n.children = []*node{&child}
92.                         // []byte for proper unicode char conversion, see #65
93.                         n.indices = bytesconv.BytesToString([]byte{n.path[i]})
94.                         n.path = path[:i]
95.                         n.handlers = nil
96.                         n.wildChild = false
97.                         n.fullPath = fullPath[:parentFullPathIndex+i]
98.                 }
100.                 // Make new node a child of this node
101.                 if i < len(path) {
102.                         path = path[i:]
103.                         c := path[0]
105.                         // '/' after param
106.                         if n.nType == param && c == '/' && len(n.children) == 1 {
107.                                 parentFullPathIndex += len(n.path)
108.                                 n = n.children[0]
109.                                 n.priority++
110.                                 continue walk
111.                         }
113.                         // Check if a child with the next path byte exists
114.                         for i, max := 0, len(n.indices); i < max; i++ {
115.                                 if c == n.indices[i] {
116.                                         parentFullPathIndex += len(n.path)
117.                                         i = n.incrementChildPrio(i)
118.                                         n = n.children[i]
119.                                         continue walk
120.                                 }
121.                         }
123.                         // Otherwise insert it
124.                         if c != ':' && c != '*' && n.nType != catchAll {
125.                                 // []byte for proper unicode char conversion, see #65
126.                                 n.indices += bytesconv.BytesToString([]byte{c})
127.                                 child := &node{
128.                                         fullPath: fullPath,
129.                                 }
130.                                 n.addChild(child)
131.                                 n.incrementChildPrio(len(n.indices) - 1)
132.                                 n = child
133.                         } else if n.wildChild {
134.                                 // inserting a wildcard node, need to check if it conflicts with the existing wildcard
135.                                 n = n.children[len(n.children)-1]
136.                                 n.priority++
138.                                 // Check if the wildcard matches
139.                                 if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
140.                                         // Adding a child to a catchAll is not possible
141.                                         n.nType != catchAll &&
142.                                         // Check for longer wildcard, e.g. :name and :names
143.                                         (len(n.path) >= len(path) || path[len(n.path)] == '/') {
144.                                         continue walk
145.                                 }
147.                                 // Wildcard conflict
148.                                 pathSeg := path
149.                                 if n.nType != catchAll {
150.                                         pathSeg = strings.SplitN(pathSeg, "/", 2)[0]
151.                                 }
152.                                 prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
153.                                 panic("'" + pathSeg +
154.                                         "' in new path '" + fullPath +
155.                                         "' conflicts with existing wildcard '" + n.path +
156.                                         "' in existing prefix '" + prefix +
157.                                         "'")
158.                         }
160.                         n.insertChild(path, fullPath, handlers)
161.                         return
162.                 }
164.                 // Otherwise add handle to current node
165.                 if n.handlers != nil {
166.                         panic("handlers are already registered for path '" + fullPath + "'")
167.                 }
168.                 n.handlers = handlers
169.                 n.fullPath = fullPath
170.                 return
171.         }
172. }

复制代码

四、gin 服务启动流程

   调用 *Engine.Run() 方法，底层会把 gin.Engine 本身作为 net/http 包下的 handler 接口的实现类，并调用 http.ListenAndServe 方法启动服务。

1. func (engine *Engine) Run(addr ...string) (err error) {
2.         defer func() { debugPrintError(err) }()
4.         if engine.isUnsafeTrustedProxies() {
5.                 debugPrint("[WARNING] You trusted all proxies, this is NOT safe. We recommend you to set a value.\n" +
6.                         "Please check https://pkg.go.dev/github.com/gin-gonic/gin#readme-don-t-trust-all-proxies for details.")
7.         }
9.         address := resolveAddress(addr)
10.         debugPrint("Listening and serving HTTP on %s\n", address)
11.         err = http.ListenAndServe(address, engine.Handler())
12.         return
13. }
15. func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
16.     // 从对象池获取一个 context
17.         c := engine.pool.Get().(*Context)
19.     // 重置或初始化 context
20.         c.writermem.reset(w)
21.         c.Request = req
22.         c.reset()
23.    
24.     // 处理 http 请求
25.         engine.handleHTTPRequest(c)
27.     // 把 context 放回对象池
28.         engine.pool.Put(c)
29. }
31. func (engine *Engine) handleHTTPRequest(c *Context) {
32.         httpMethod := c.Request.Method
33.         rPath := c.Request.URL.Path
34.         unescape := false
35.         if engine.UseRawPath && len(c.Request.URL.RawPath) > 0 {
36.                 rPath = c.Request.URL.RawPath
37.                 unescape = engine.UnescapePathValues
38.         }
40.         if engine.RemoveExtraSlash {
41.                 rPath = cleanPath(rPath)
42.         }
44.         // Find root of the tree for the given HTTP method
45.         t := engine.trees
46.         for i, tl := 0, len(t); i < tl; i++ {
47.                 if t[i].method != httpMethod {
48.                         continue
49.                 }
50.                 root := t[i].root
51.                 // Find route in tree
52.                 value := root.getValue(rPath, c.params, c.skippedNodes, unescape)
53.                 if value.params != nil {
54.                         c.Params = *value.params
55.                 }
56.                 if value.handlers != nil {
57.                         c.handlers = value.handlers
58.                         c.fullPath = value.fullPath
59.                         c.Next()
60.                         c.writermem.WriteHeaderNow()
61.                         return
62.                 }
63.                 if httpMethod != http.MethodConnect && rPath != "/" {
64.                         if value.tsr && engine.RedirectTrailingSlash {
65.                                 redirectTrailingSlash(c)
66.                                 return
67.                         }
68.                         if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {
69.                                 return
70.                         }
71.                 }
72.                 break
73.         }
75.         if engine.HandleMethodNotAllowed {
76.                 // According to RFC 7231 section 6.5.5, MUST generate an Allow header field in response
77.                 // containing a list of the target resource's currently supported methods.
78.                 allowed := make([]string, 0, len(t)-1)
79.                 for _, tree := range engine.trees {
80.                         if tree.method == httpMethod {
81.                                 continue
82.                         }
83.                         if value := tree.root.getValue(rPath, nil, c.skippedNodes, unescape); value.handlers != nil {
84.                                 allowed = append(allowed, tree.method)
85.                         }
86.                 }
87.                 if len(allowed) > 0 {
88.                         c.handlers = engine.allNoMethod
89.                         c.writermem.Header().Set("Allow", strings.Join(allowed, ", "))
90.                         serveError(c, http.StatusMethodNotAllowed, default405Body)
91.                         return
92.                 }
93.         }
95.         c.handlers = engine.allNoRoute
96.         serveError(c, http.StatusNotFound, default404Body)
97. }

复制代码

  Engine.handleHTTPRequest 处理 http 哀求的流程：
  

• 根据 http method 取得对应的 methodTree
  
• 根据 path 从 methodTree 中取得对应的 handlers 链
  
• 将 handlers 链注入到 gin.context 中, 通过 context.Next() 方法遍历获取 handler
  

  

五、路由树原理

   1、前缀树
  又称Trie树、字典树或键树，是一种树形数据结构，主要用于高效地存储和查询字符串。
  其特点为：
  

• 根节点不包含字符，除根节点外每一个节点都只包含一个字符。
  
• 从根节点到某一节点，路径上颠末的字符连接起来，为该节点对应的字符串。
  
• 每个节点的所有子节点包含的字符都不相同。
  

  

  
  2、压缩前缀树
  压缩前缀树是一种高效处理字符串聚集的数据结构，通过归并共享的前缀来节省存储空间并提高检索效率。它在网络路由、编译器符号表和字符串检索等领域有广泛应用。
  

  
  3、路由树的数据结构
  gin路由管理采取压缩前缀树的数据结构，相较于map数据结构，压缩前缀树可用于暗昧匹配，并且在数据量不大的情况下，压缩树的性能并不比map差。gin框架中采取补偿策略，将挂载的路径越多的子节点越往左排列，以便查询时优先被访问到。

1. type methodTree struct {
2.         method string
3.         root   *node
4. }
6. type methodTrees []methodTree
8. type node struct {
9.         path      string
10.     // 每个 indice 字符对应一个孩子节点路径的首字母
11.         indices   string
12.         wildChild bool
13.         nType     nodeType
14.     // 后续节点数量
15.         priority  uint32
16.     // 孩子节点列表
17.         children  []*node // child nodes, at most 1 :param style node at the end of the array
18.     // 处理函数链
19.         handlers  HandlersChain
20.         fullPath  string
21. }
23. type HandlersChain []HandlerFunc

复制代码

4、注册路由

1. func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
2.         assert1(path[0] == '/', "path must begin with '/'")
3.         assert1(method != "", "HTTP method can not be empty")
4.         assert1(len(handlers) > 0, "there must be at least one handler")
6.         debugPrintRoute(method, path, handlers)
8.         root := engine.trees.get(method)
9.         if root == nil {
10.                 root = new(node)
11.                 root.fullPath = "/"
12.                 engine.trees = append(engine.trees, methodTree{method: method, root: root})
13.         }
14.         root.addRoute(path, handlers)
16.         if paramsCount := countParams(path); paramsCount > engine.maxParams {
17.                 engine.maxParams = paramsCount
18.         }
20.         if sectionsCount := countSections(path); sectionsCount > engine.maxSections {
21.                 engine.maxSections = sectionsCount
22.         }
23. }
25. func (n *node) addRoute(path string, handlers HandlersChain) {
26.         fullPath := path
27.         n.priority++
29.         // Empty tree
30.         if len(n.path) == 0 && len(n.children) == 0 {
31.                 n.insertChild(path, fullPath, handlers)
32.                 n.nType = root
33.                 return
34.         }
36.         parentFullPathIndex := 0
38. walk:
39.         for {
40.                 // Find the longest common prefix.
41.                 // This also implies that the common prefix contains no ':' or '*'
42.                 // since the existing key can't contain those chars.
43.                 i := longestCommonPrefix(path, n.path)
45.                 // Split edge
46.                 if i < len(n.path) {
47.                         child := node{
48.                                 path:      n.path[i:],
49.                                 wildChild: n.wildChild,
50.                                 nType:     static,
51.                                 indices:   n.indices,
52.                                 children:  n.children,
53.                                 handlers:  n.handlers,
54.                                 priority:  n.priority - 1,
55.                                 fullPath:  n.fullPath,
56.                         }
58.                         n.children = []*node{&child}
59.                         // []byte for proper unicode char conversion, see #65
60.                         n.indices = bytesconv.BytesToString([]byte{n.path[i]})
61.                         n.path = path[:i]
62.                         n.handlers = nil
63.                         n.wildChild = false
64.                         n.fullPath = fullPath[:parentFullPathIndex+i]
65.                 }
67.                 // Make new node a child of this node
68.                 if i < len(path) {
69.                         path = path[i:]
70.                         c := path[0]
72.                         // '/' after param
73.                         if n.nType == param && c == '/' && len(n.children) == 1 {
74.                                 parentFullPathIndex += len(n.path)
75.                                 n = n.children[0]
76.                                 n.priority++
77.                                 continue walk
78.                         }
80.                         // Check if a child with the next path byte exists
81.                         for i, max := 0, len(n.indices); i < max; i++ {
82.                                 if c == n.indices[i] {
83.                                         parentFullPathIndex += len(n.path)
84.                                         i = n.incrementChildPrio(i)
85.                                         n = n.children[i]
86.                                         continue walk
87.                                 }
88.                         }
90.                         // Otherwise insert it
91.                         if c != ':' && c != '*' && n.nType != catchAll {
92.                                 // []byte for proper unicode char conversion, see #65
93.                                 n.indices += bytesconv.BytesToString([]byte{c})
94.                                 child := &node{
95.                                         fullPath: fullPath,
96.                                 }
97.                                 n.addChild(child)
98.                                 n.incrementChildPrio(len(n.indices) - 1)
99.                                 n = child
100.                         } else if n.wildChild {
101.                                 // inserting a wildcard node, need to check if it conflicts with the existing wildcard
102.                                 n = n.children[len(n.children)-1]
103.                                 n.priority++
105.                                 // Check if the wildcard matches
106.                                 if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
107.                                         // Adding a child to a catchAll is not possible
108.                                         n.nType != catchAll &&
109.                                         // Check for longer wildcard, e.g. :name and :names
110.                                         (len(n.path) >= len(path) || path[len(n.path)] == '/') {
111.                                         continue walk
112.                                 }
114.                                 // Wildcard conflict
115.                                 pathSeg := path
116.                                 if n.nType != catchAll {
117.                                         pathSeg = strings.SplitN(pathSeg, "/", 2)[0]
118.                                 }
119.                                 prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
120.                                 panic("'" + pathSeg +
121.                                         "' in new path '" + fullPath +
122.                                         "' conflicts with existing wildcard '" + n.path +
123.                                         "' in existing prefix '" + prefix +
124.                                         "'")
125.                         }
127.                         n.insertChild(path, fullPath, handlers)
128.                         return
129.                 }
131.                 // Otherwise add handle to current node
132.                 if n.handlers != nil {
133.                         panic("handlers are already registered for path '" + fullPath + "'")
134.                 }
135.                 n.handlers = handlers
136.                 n.fullPath = fullPath
137.                 return
138.         }
139. }

复制代码

  5、检索路由

1. type nodeValue struct {
2.         handlers HandlersChain
3.         params   *Params
4.         tsr      bool
5.         fullPath string
6. }
8. type skippedNode struct {
9.         path        string
10.         node        *node
11.         paramsCount int16
12. }
14. func (n *node) getValue(path string, params *Params, skippedNodes *[]skippedNode, unescape bool) (value nodeValue) {
15.         var globalParamsCount int16
17. walk: // Outer loop for walking the tree
18.         for {
19.                 prefix := n.path
20.                 if len(path) > len(prefix) {
21.                         if path[:len(prefix)] == prefix {
22.                                 path = path[len(prefix):]
24.                                 // Try all the non-wildcard children first by matching the indices
25.                                 idxc := path[0]
26.                                 for i, c := range []byte(n.indices) {
27.                                         if c == idxc {
28.                                                 //  strings.HasPrefix(n.children[len(n.children)-1].path, ":") == n.wildChild
29.                                                 if n.wildChild {
30.                                                         index := len(*skippedNodes)
31.                                                         *skippedNodes = (*skippedNodes)[:index+1]
32.                                                         (*skippedNodes)[index] = skippedNode{
33.                                                                 path: prefix + path,
34.                                                                 node: &node{
35.                                                                         path:      n.path,
36.                                                                         wildChild: n.wildChild,
37.                                                                         nType:     n.nType,
38.                                                                         priority:  n.priority,
39.                                                                         children:  n.children,
40.                                                                         handlers:  n.handlers,
41.                                                                         fullPath:  n.fullPath,
42.                                                                 },
43.                                                                 paramsCount: globalParamsCount,
44.                                                         }
45.                                                 }
47.                                                 n = n.children[i]
48.                                                 continue walk
49.                                         }
50.                                 }
52.                                 if !n.wildChild {
53.                                         // If the path at the end of the loop is not equal to '/' and the current node has no child nodes
54.                                         // the current node needs to roll back to last valid skippedNode
55.                                         if path != "/" {
56.                                                 for length := len(*skippedNodes); length > 0; length-- {
57.                                                         skippedNode := (*skippedNodes)[length-1]
58.                                                         *skippedNodes = (*skippedNodes)[:length-1]
59.                                                         if strings.HasSuffix(skippedNode.path, path) {
60.                                                                 path = skippedNode.path
61.                                                                 n = skippedNode.node
62.                                                                 if value.params != nil {
63.                                                                         *value.params = (*value.params)[:skippedNode.paramsCount]
64.                                                                 }
65.                                                                 globalParamsCount = skippedNode.paramsCount
66.                                                                 continue walk
67.                                                         }
68.                                                 }
69.                                         }
71.                                         // Nothing found.
72.                                         // We can recommend to redirect to the same URL without a
73.                                         // trailing slash if a leaf exists for that path.
74.                                         value.tsr = path == "/" && n.handlers != nil
75.                                         return value
76.                                 }
78.                                 // Handle wildcard child, which is always at the end of the array
79.                                 n = n.children[len(n.children)-1]
80.                                 globalParamsCount++
82.                                 switch n.nType {
83.                                 case param:
84.                                         // fix truncate the parameter
85.                                         // tree_test.go  line: 204
87.                                         // Find param end (either '/' or path end)
88.                                         end := 0
89.                                         for end < len(path) && path[end] != '/' {
90.                                                 end++
91.                                         }
93.                                         // Save param value
94.                                         if params != nil {
95.                                                 // Preallocate capacity if necessary
96.                                                 if cap(*params) < int(globalParamsCount) {
97.                                                         newParams := make(Params, len(*params), globalParamsCount)
98.                                                         copy(newParams, *params)
99.                                                         *params = newParams
100.                                                 }
102.                                                 if value.params == nil {
103.                                                         value.params = params
104.                                                 }
105.                                                 // Expand slice within preallocated capacity
106.                                                 i := len(*value.params)
107.                                                 *value.params = (*value.params)[:i+1]
108.                                                 val := path[:end]
109.                                                 if unescape {
110.                                                         if v, err := url.QueryUnescape(val); err == nil {
111.                                                                 val = v
112.                                                         }
113.                                                 }
114.                                                 (*value.params)[i] = Param{
115.                                                         Key:   n.path[1:],
116.                                                         Value: val,
117.                                                 }
118.                                         }
120.                                         // we need to go deeper!
121.                                         if end < len(path) {
122.                                                 if len(n.children) > 0 {
123.                                                         path = path[end:]
124.                                                         n = n.children[0]
125.                                                         continue walk
126.                                                 }
128.                                                 // ... but we can't
129.                                                 value.tsr = len(path) == end+1
130.                                                 return value
131.                                         }
133.                                         if value.handlers = n.handlers; value.handlers != nil {
134.                                                 value.fullPath = n.fullPath
135.                                                 return value
136.                                         }
137.                                         if len(n.children) == 1 {
138.                                                 // No handle found. Check if a handle for this path + a
139.                                                 // trailing slash exists for TSR recommendation
140.                                                 n = n.children[0]
141.                                                 value.tsr = (n.path == "/" && n.handlers != nil) || (n.path == "" && n.indices == "/")
142.                                         }
143.                                         return value
145.                                 case catchAll:
146.                                         // Save param value
147.                                         if params != nil {
148.                                                 // Preallocate capacity if necessary
149.                                                 if cap(*params) < int(globalParamsCount) {
150.                                                         newParams := make(Params, len(*params), globalParamsCount)
151.                                                         copy(newParams, *params)
152.                                                         *params = newParams
153.                                                 }
155.                                                 if value.params == nil {
156.                                                         value.params = params
157.                                                 }
158.                                                 // Expand slice within preallocated capacity
159.                                                 i := len(*value.params)
160.                                                 *value.params = (*value.params)[:i+1]
161.                                                 val := path
162.                                                 if unescape {
163.                                                         if v, err := url.QueryUnescape(path); err == nil {
164.                                                                 val = v
165.                                                         }
166.                                                 }
167.                                                 (*value.params)[i] = Param{
168.                                                         Key:   n.path[2:],
169.                                                         Value: val,
170.                                                 }
171.                                         }
173.                                         value.handlers = n.handlers
174.                                         value.fullPath = n.fullPath
175.                                         return value
177.                                 default:
178.                                         panic("invalid node type")
179.                                 }
180.                         }
181.                 }
183.                 if path == prefix {
184.                         // 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
185.                         // the current node needs to roll back to last valid skippedNode
186.                         if n.handlers == nil && path != "/" {
187.                                 for length := len(*skippedNodes); length > 0; length-- {
188.                                         skippedNode := (*skippedNodes)[length-1]
189.                                         *skippedNodes = (*skippedNodes)[:length-1]
190.                                         if strings.HasSuffix(skippedNode.path, path) {
191.                                                 path = skippedNode.path
192.                                                 n = skippedNode.node
193.                                                 if value.params != nil {
194.                                                         *value.params = (*value.params)[:skippedNode.paramsCount]
195.                                                 }
196.                                                 globalParamsCount = skippedNode.paramsCount
197.                                                 continue walk
198.                                         }
199.                                 }
200.                                 //        n = latestNode.children[len(latestNode.children)-1]
201.                         }
202.                         // We should have reached the node containing the handle.
203.                         // Check if this node has a handle registered.
204.                         if value.handlers = n.handlers; value.handlers != nil {
205.                                 value.fullPath = n.fullPath
206.                                 return value
207.                         }
209.                         // If there is no handle for this route, but this route has a
210.                         // wildcard child, there must be a handle for this path with an
211.                         // additional trailing slash
212.                         if path == "/" && n.wildChild && n.nType != root {
213.                                 value.tsr = true
214.                                 return value
215.                         }
217.                         if path == "/" && n.nType == static {
218.                                 value.tsr = true
219.                                 return value
220.                         }
222.                         // No handle found. Check if a handle for this path + a
223.                         // trailing slash exists for trailing slash recommendation
224.                         for i, c := range []byte(n.indices) {
225.                                 if c == '/' {
226.                                         n = n.children[i]
227.                                         value.tsr = (len(n.path) == 1 && n.handlers != nil) ||
228.                                                 (n.nType == catchAll && n.children[0].handlers != nil)
229.                                         return value
230.                                 }
231.                         }
233.                         return value
234.                 }
236.                 // Nothing found. We can recommend to redirect to the same URL with an
237.                 // extra trailing slash if a leaf exists for that path
238.                 value.tsr = path == "/" ||
239.                         (len(prefix) == len(path)+1 && prefix[len(path)] == '/' &&
240.                                 path == prefix[:len(prefix)-1] && n.handlers != nil)
242.                 // roll back to last valid skippedNode
243.                 if !value.tsr && path != "/" {
244.                         for length := len(*skippedNodes); length > 0; length-- {
245.                                 skippedNode := (*skippedNodes)[length-1]
246.                                 *skippedNodes = (*skippedNodes)[:length-1]
247.                                 if strings.HasSuffix(skippedNode.path, path) {
248.                                         path = skippedNode.path
249.                                         n = skippedNode.node
250.                                         if value.params != nil {
251.                                                 *value.params = (*value.params)[:skippedNode.paramsCount]
252.                                         }
253.                                         globalParamsCount = skippedNode.paramsCount
254.                                         continue walk
255.                                 }
256.                         }
257.                 }
259.                 return value
260.         }
261. }

复制代码

  六、gin.Context数据结构

1. type Context struct {
2.         writermem responseWriter
3.         Request   *http.Request
4.         Writer    ResponseWriter
6.         Params   Params
7.         handlers HandlersChain
8.         index    int8
9.         fullPath string
11.         engine       *Engine
12.         params       *Params
13.         skippedNodes *[]skippedNode
15.         // This mutex protects Keys map.
16.         mu sync.RWMutex
18.         // Keys is a key/value pair exclusively for the context of each request.
19.         Keys map[string]any
21.         // Errors is a list of errors attached to all the handlers/middlewares who used this context.
22.         Errors errorMsgs
24.         // Accepted defines a list of manually accepted formats for content negotiation.
25.         Accepted []string
27.         // queryCache caches the query result from c.Request.URL.Query().
28.         queryCache url.Values
30.         // formCache caches c.Request.PostForm, which contains the parsed form data from POST, PATCH,
31.         // or PUT body parameters.
32.         formCache url.Values
34.         // SameSite allows a server to define a cookie attribute making it impossible for
35.         // the browser to send this cookie along with cross-site requests.
36.         sameSite http.SameSite
37. }

复制代码

  gin.Context 作为处理 http 哀求的通用数据结构，不可克制地会被频仍创建和销毁。为了缓解GC 压力，gin 中采取对象池sync.Pool进行Context 的缓存复用，处理流程如下：
  

• http 哀求到达时，从 pool 中获取 Context，倘若池子已空，通过 pool.New 方法构造新的 Context补上空缺
  
• http 哀求处理完成后，将Context 放回 pool 中，用以后续复用
  

1. func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
2.     // 从对象池获取一个 context
3.         c := engine.pool.Get().(*Context)
5.     // 重置或初始化 context
6.         c.writermem.reset(w)
7.         c.Request = req
8.         c.reset()
9.    
10.     // 处理 http 请求
11.         engine.handleHTTPRequest(c)
13.     // 把 context 放回对象池
14.         engine.pool.Put(c)
15. }

复制代码

 
七、总结

   

• gin 将 Engine 作为 http.Handler 的实现类进行注入，从而融入 Golang net/http 标准库的框架之内
  
• gin 中基于 handler 链的方式实现中心件和处理函数的协调使用
  
• gin 中基于压缩前缀树的方式作为路由树的数据结构，对应于9种 http 方法共有 9 棵树
  
• gin 中基于 gin.Context 作为一次 http 哀求贯穿整条 handler chain 的核心数据结构
  
• gin.Context 是一种会被频仍创建销毁的资源对象，因此使用对象池 sync.Pool 进行缓存复用
  

  

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。