Go第三方框架--gin框架（二）

fengzhuzhigu

已于 2024-03-25 21:58:04 修改

阅读量1.2k

点赞数 16

分类专栏： go 文章标签： golang gin 开发语言

于 2024-03-25 21:19:48 首次发布

本文链接：https://blog.csdn.net/u013915286/article/details/136734886

版权

go 专栏收录该内容

23 篇文章 0 订阅

订阅专栏

4. gin框架源码–Engine引擎和压缩前缀树的建立

讲了这么多到标题4才开始介绍源码，主要原因还是想先在头脑中构建起一个大体的框架然后再填肉这样不容易得脑血栓。标题四主要涉及标题2.3的步骤一
也就是标题2.3中的粗线框中的内容

4.1 Engine 引擎的建立

见 TestGin的第一行我们按图索骥一步步深入看看只需关注我中文注释的属性或代码就行

	r := gin.Default() // 建立一个默认的 gin 引擎实例

其中函数 Default() 代码如下：

// Default returns an Engine instance with the Logger and Recovery middleware already attached.
func Default() *Engine {
	debugPrintWARNINGDefault()  // 打印 警告信息
	engine := New()  // 建立 engine 实例
	engine.Use(Logger(), Recovery()) // 添加中间件 函数 包括 日志和panic恢复函数
	return engine
}

其中 New()函数代码如下（只关注我中文解释的参数就行）：

// New 返回一个不带任何中间件函数的新的engine实例
func New() *Engine {
	debugPrintWARNINGNew()
	engine := &Engine{
		RouterGroup: RouterGroup{        // 建立默认根路由组 也就是说 所有的 路由 都需要经过本 在前面加上 “/”  后续路由（使用Group(...)函数创建） 会在其基础上 不断叠加更新 basePath和Handlers 但其功能还是一样的
			Handlers: nil,
			basePath: "/",
			root:     true,
		},
		FuncMap:                template.FuncMap{},
		RedirectTrailingSlash:  true,
		RedirectFixedPath:      false,
		HandleMethodNotAllowed: false,
		ForwardedByClientIP:    true,
		RemoteIPHeaders:        []string{"X-Forwarded-For", "X-Real-IP"},
		TrustedPlatform:        defaultPlatform,
		UseRawPath:             false,
		RemoveExtraSlash:       false,
		UnescapePathValues:     true,
		MaxMultipartMemory:     defaultMultipartMemory
		trees:                  make(methodTrees, 0, 9),   // 初始化 方法树的 列表 包括 Get/Post/Delete等九中方法
		delims:                 render.Delims{Left: "{{", Right: "}}"},
		secureJSONPrefix:       "while(1);",
		trustedProxies:         []string{"0.0.0.0/0", "::/0"},
		trustedCIDRs:           defaultTrustedCIDRs,
	}
	engine.RouterGroup.engine = engine   // 将新建的 本 engine 索引付给 engine.RouterGroup.engine 方便 路由组引用 本engine的 addRoute()方法 
	engine.pool.New = func() any {                // 初始化context池 因为涉及到大量客户端连接，所以将context池化 减少对象的创建和回收次数 可以节省内存 减少垃圾回收时间 提高效率
		return engine.allocateContext(engine.maxParams)
	}
	return engine
}

其中 engine.Use(Logger(), Recovery()) 中 Use()函数如下

func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
	engine.RouterGroup.Use(middleware...)  // 将中间件函数 加入到 RouterGroup的参数 Handlers 列表中 作为本路由组的整体的中间函数  
	engine.rebuild404Handlers() 
	engine.rebuild405Handlers()
	return engine
}

到这里 r := gin.Default() 这行代码就讲解完毕了比较粗略因为这部分源码不太难主要是完成了两件事
1：创建了一个默认路由组，主要来存放根路径 “/” 和全局中间函数包括对日志和panic的处理
2：初始化了一个 methodTrees 结构体用来保存 get/post等9种方法树的根节点还有其他初始参数跟本文讲解的内容关系不大不做讲解感兴趣的可以自己谷歌上百度两下。
到这里默认引擎就建立起来了。

4.2 GET方法路由节点树的逐步建立

4.2.1 树初始化和第一个路由节点的建立

见 TestGin的第二行，代码如下

	r.GET("/aa/bb", func(c *gin.Context) { c.JSON(200, gin.H{"route path ": "/aa/bb"}) })

第一次建立路由树时，树是空的，所以需要经过判断建立根节点和直接将路由和函数挂到树上。
树建立后的结构如下(handler也就是注册的函数在路径插入时插入，故不在图中展示，只在有特殊情况时说明。)：
在这里插入图片描述
知道了结果，现在我们来梳理下代码：
从 r.Get 追踪下来可见如图代码


func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {
	absolutePath := group.calculateAbsolutePath(relativePath)   // 组的根路径（/）+用户路径（/aa/bb）
	handlers = group.combineHandlers(handlers)  // 组的根方法组（日志相关+panic相关）+用户注册方法（c.Json......）
	group.engine.addRoute(httpMethod, absolutePath, handlers)   // 构造路由树核心函数 将 absolutePath 和 handler 添加到 httpMathod 方法（Get）对应的 路由树上
	return group.returnObj()   // 没看懂 不过不影响 哦 不对 主逻辑 ps: 不是能力不行 写这篇代码时 有点困 没深究呢
}

接着追踪 group.engine.addRoute(httpMethod, absolutePath, handlers)

func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
 	// 隐藏无关代码
 		
	root := engine.trees.get(method)
	if root == nil {       // 第一次 建立路由 会走这里 主要是 初始化 路由树的 根节点，将根节点挂载到 engine的 trees 列表中
		root = new(node)
		root.fullPath = "/"
		engine.trees = append(engine.trees, methodTree{method: method, root: root})
	}
	root.addRoute(path, handlers) // 构造路由树核心函数，将 路径（/aa/b） 和 方法(3个) 添加到路由树上 根节点是（root）

		// 隐藏无关代码
}

接着追踪 root.addRoute(path, handlers)

func (n *node) addRoute(path string, handlers HandlersChain) {
	fullPath := path
	n.priority++  // priority 可以理解 以n为根节点的孩子节点的总个数 主要作用是 用来对 其第一层孩子节点进行重排，按照值大小倒序排列。为什么这么做呢，因为孩子节点多，说明通过这个节点的路由就多 访问就越频繁 在for循环寻找路由时 排在前面的经常被访问的节点 可以快速找到 从而可以提高效率。后续会讲解 如果有疑惑 先放着

	// Empty tree
	if len(n.path) == 0 && len(n.children) == 0 {  // n 是上面代码中的 root ，可以看到 只有 fullPath有值，path和children都是 零值（其含义见3.3），
		n.insertChild(path, fullPath, handlers)   // 为root根节点补充完整参数。因为其没有孩子节点 path也为空 则可以判断是空树 所以 root节点就是第一个节点 只需补充完整其参数就行
		n.nType = root
		return
	}

	parentFullPathIndex := 0
	// 以下代码是 gin框架构造路由树核心，只是初始构造路由树用不到，先排除干扰
}

接着追踪 n.insertChild(path, fullPath, handlers)

func (n *node) insertChild(path string, fullPath string, handlers HandlersChain) {
	for {
		// Find prefix until first wildcard
		wildcard, i, valid := findWildcard(path)  // 寻找通配符 本文暂时只介绍 gin框架 精髓 无通配符路由节点建立  
		if i < 0 { // No wildcard found  //i==-1 break
			break
		}

		// 隐藏无关代码
		}

	// If no wildcard was found, simply insert the path and handle 没有通配符 简单的插入 路径和handler
	n.path = path // （/aa/bb）
	n.handlers = handlers  // 3个  （日志相关+panic相关）+用户注册方法（c.Json......）
	n.fullPath = fullPath // (/aa/bb)
}

至此第一个节点便建立起来了，TestGin的第二行执行完毕后，其engine结构如下图，可以看到root节点确实如分析的一般。
在这里插入图片描述

4.2.2 第2个路由路径插入

代码如图
在这里插入图片描述
这行代码执行完毕后得到的树如图：

下面我们来具体分析下代码
通过代码追踪可以看到第二个节点建立时跳过了 root节点初始化和第一个节点建立的代码，来到了 addRoute函数的核心部分
接着追踪 root.addRoute(path, handlers)

func (n *node) addRoute(path string, handlers HandlersChain) {
	fullPath := path
	n.priority++   
	// 隐藏无关代码
	
	parentFullPathIndex := 0

walk:
	for {
		// Find the longest common prefix.
		// This also implies that the common prefix contains no ':' or '*'
		// since the existing key can't contain those chars.
		i := longestCommonPrefix(path, n.path)   // n是4.2.1形成的第一个节点 则 n.path =/aa/bb path==/aa/bd longestCommonPrefix 函数是寻找两个字符串第一个不相同的字符的 索引 这里可以算出来 是 5。
		                                         // 这个函数的作用决定父节点是否需要被拆分, 当n.path是path的子节点时 不被拆分，否则就需要被拆分。

		// Split edge
		if i < len(n.path) {   // 5<6 走这里 ，拆分父节点为两部分 /aa/b（根节点） 和 b（第一个孩子节点）  ，下面具体讲解
			child := node{     //  b 孩子节点的创建 
				path:      n.path[i:], // 将 b赋值给 path
				wildChild: n.wildChild,
				nType:     static,
				indices:   n.indices,    // child继承了 n的主要参数和功能
				children:  n.children,  // 将其孩子节点赋值给 其 分裂的前缀节点
				handlers:  n.handlers,
				priority:  n.priority - 1, // 没看懂
				fullPath:  n.fullPath, // 全路径不变 还是/aa/bb
			}

			n.children = []*node{&child}  // 初始化n节点，并且将 child加入到n的孩子节点中，这样 就形成了 n-->n.children-->n.children.children这样三层节点结构
			// []byte for proper unicode char conversion, see #65
			n.indices = bytesconv.BytesToString([]byte{n.path[i]})  // 下面是 重新给n的属性赋值
			n.path = path[:i]
			n.handlers = nil
			n.wildChild = false
			n.fullPath = fullPath[:parentFullPathIndex+i]
		}

		// Make new node a child of this node   // 将n 的第二个节点d插入进去
		if i < len(path) {  // 5<6 将 新节点 d插入进去
			path = path[i:]  //新节点的 path参数是是 d
			c := path[0] // 获取path第一个 字符，用于快速定位应该从哪一个节点向下匹配。

			// '/' after param

			// todo 没看懂
			if n.nType == param && c == '/' && len(n.children) == 1 {
			// 隐藏无关代码
			}

			// Otherwise insert it
			if c != ':' && c != '*' && n.nType != catchAll {
				// []byte for proper unicode char conversion, see #65
				n.indices += bytesconv.BytesToString([]byte{c})  // 将 n的新孩子节点前缀字符加入到 indices 中
				child := &node{
					fullPath: fullPath,
				}
				n.addChild(child)  // 将孩子节点添加到 n的孩子节点数组中
				n.incrementChildPrio(len(n.indices) - 1) // 这里比较重要 用到了我们所说的 priority， 按照 其值 大小进行子节点倒序排序。原因前文讲过了，请自行查看。
				n = child  // 将 child地址 赋值给 n。
			} else if n.wildChild {
			// 这里是对通配符的处理，本文暂不涉及，略过。
			}

			n.insertChild(path, fullPath, handlers)  // 完善n（child）的 path，fullPath,handlers ,insertChild函数其实就是给节点n的几个属性赋值，所以感觉起得名字有点误导。
			return  // 返回 到这里 第二个节点就创建好了 
		}

		// Otherwise add handle to current node
		if n.handlers != nil {
			panic("handlers are already registered for path '" + fullPath + "'")
		}  // 如果i>=len(path) 就可能是情况 n.path==/aa/bb path==/aa/b 。则分类后 一共 两个节点 没有 d节点。 则需要将 handler和fullPath 赋值当前n节点。
		n.handlers = handlers
		n.fullPath = fullPath
		return  返回
	}
}

到这里第二个路由节点就插入进去了。
我们看下 debugger的结果
在这里插入图片描述
可以看到跟我们分析的是一致的。

4.2.3 第3-5个路由路径的插入

由于其执行的动作跟 4.2.2一致，所以略过。其构建树的过程如下图
在这里插入图片描述

4.2.4 第6个路由的插入

4.2.1–4.2.3是正常路由的插入，一次循环就能完成。没有涉及到 addRoute() 函数的关键字 walk: 接下来我们再引入一个路由来触发 for 循环，添加的路由如下图
在这里插入图片描述
这行代码执行完毕后得到的树如图：

下面我们来分析下具体的代码执行还是直接分析 root.addRoute(path, handlers)
第1层循环

func (n *node) addRoute(path string, handlers HandlersChain) {
	fullPath := path
	n.priority++

	// Empty tree
	// 隐藏无关代码

	parentFullPathIndex := 0
// 循环第一层 沿着 树节点 向下找 则n节点 是4.2.3最右边的图  以下 n的参数都可以参考这个图来获取
walk:
	for {
		// Find the longest common prefix.
		// This also implies that the common prefix contains no ':' or '*'
		// since the existing key can't contain those chars.
		i := longestCommonPrefix(path, n.path)  // n.path == "/" path=="/aa/be" 如此i==1

		// Split edge
		if i < len(n.path) {  // 不符合 跳过
			// 隐藏无关代码
		}

		// Make new node a child of this node
		if i < len(path) {  // 符合
			path = path[i:] // 获取 除了根节点（“/”）的 剩余部分 aa/be
			c := path[0]   // 将 aa/be 的 第一个字符 a 提取出来 为了 快速在 n的孩子节点定位和将c插入n的 indices中（如果没有匹配n的子节点）

			// '/' after param
 
			if n.nType == param && c == '/' && len(n.children) == 1 {
					// 隐藏无关代码
			}

			// Check if a child with the next path byte exists
			for i, max := 0, len(n.indices); i < max; i++ {  // n.indices=={a,e}
				if c == n.indices[i] {        // 因为c==rune("a") 所以 走下面代码
					parentFullPathIndex += len(n.path)  // 下一个循环 中 节点的 fullPath在 全局全路径 中出现的索引。
					i = n.incrementChildPrio(i)  // 因为接下来的 新节点 要加入到  包含 n.children[i]节点的后续子节点中 所以其 孩子几点数（priority） 要增1，然后返回排序后的 原始的n.children[i]节点的新的索引 给 i
					n = n.children[i] // 将孩子节点赋值给 n 
					continue walk  // 从 新节点开始继续循环 见  4.2.3最右边节点的第2层最左边节点
				}
			}

			// 隐藏无关代码
	}
}

第2-3层循环跟上面代码原理相同可参考 4.2.3最右边节点的第2-3层
第4层循环时 n.path==“b” path==“be”
其执行逻辑可以按照 4.2.3执行请自行验证
至此树节点的建立就梳理完毕了，注意只是梳理了不带通配符的路由处理逻辑，关于通配符例如：* 等特殊字符请自行梳理。

梳理了这么多知识点都是属于 1.3 的圆圈1，下面我们改建立起tcp监听了。

5. net/http框架源码-- 多路复用的实现

这块核心功能对应 1.3 的圆圈2，所属代码如下图：
在这里插入图片描述
未完待续…

6. gin框架源码–路由匹配（压缩前缀树的查找）

7. 收尾

ps: 本人菜鸟不太专业如果有错还请各位大侠指出；免责声明：凡是按照本八股文去面试被怼的，本人概不承担责任；面试通过，请自行心理默念几遍博主最帅。
参考文章
https://juejin.cn/post/7263826380889915453

fengzhuzhigu

关注

16
点赞
踩
15

收藏

觉得还不错? 一键收藏
0
评论
Go第三方框架--gin框架（二）

通过代码追踪可以看到第二个节点建立时跳过了 root节点初始化和第一个节点建立的代码，来到了 addRoute函数的核心部分。至此第一个节点便建立起来了，TestGin的第二行执行完毕后，其engine结构如下图，可以看到root节点确实如分析的一般。至此树节点的建立就梳理完毕了，注意只是梳理了不带通配符的路由处理逻辑，关于通配符例如：* 等特殊字符请自行梳理。建立后树的结构如下(handler也就是注册的函数在路径插入时插入，故不在图中展示，只在有特殊情况时说明。
复制链接

扫一扫