序言

Gin框架作为go语言使用最多的web框架，以其快速的响应速度和对复杂http路由配置的支持受到程序员和媛们的喜爱，几乎统治了web市场。但作为一名合格的程序员，要知其然更要知其所以然，不然八股文背的也没有啥意思。本着这个原则鄙人打算站在前人的大腿根上从头到尾梳理下Gin的执行流程，主要涉及两大部分：1. 服务器的建立（重点是：Gin是怎么处理和存储各种不同的路由路径和请求函数体的）；2. 客户端的连接（主要涉及根据路由寻找对应函数体来执行具体业务逻辑）

1. gn框架的诞生

1.1 go 原生web框架

go 原生的 web框架 在 net/http 包里，因不是本文重点，所以只简要介绍。
net/http 主要采用 map的原理来 存储 路径和handler 其中 key 是 路径 value 是 handler ，如下图的代码

# ServeMux是一个HTTP请求多路复用器。其中 m 保存了 其请求路径和handler的映射关系。
type ServeMux struct {mu    sync.RWMutexm     map[string]muxEntryes    []muxEntry // slice of entries sorted from longest to shortest.hosts bool       // whether any patterns contain hostnames
}
type muxEntry struct {h       Handlerpattern string
}
func TestHttp(t *testing.T) {// 创建路由器mux := http.NewServeMux()// 设置路由规则mux.HandleFunc("/hello", hello)mux.HandleFunc("/hello/hell", hello2)mux.HandleFunc("/hel/ww", hello2)mux.HandleFunc("/helw/*ww", hello2)// 创建服务器server := &http.Server{Addr:         Addr,WriteTimeout: time.Second * 3, //超时时间Handler:      mux,             //路由规则  }// 监听端口并提供服务log.Println("Starting httpserver at " + Addr)err := server.ListenAndServe()if err != nil {panic(err)return}log.Fatal()
}func hello(w http.ResponseWriter, r *http.Request) {time.Sleep(1 * time.Second)w.Write([]byte("bye bye ,this is httpServer"))
}func hello2(w http.ResponseWriter, r *http.Request) {time.Sleep(1 * time.Second)w.Write([]byte("bye bye ,this is httpServer"))
}

其 建立的 map如下：

可以看出其确实建立了一个 map来存储 路径和handler的映射关系。采用map形式 查找的速度也比较的块。但是为啥还要采用Gin框架呢。
我们来简要梳理下我们程序员在工作过程中需要啥样的web框架吧

1. 需要一个可以处理通配符的框架，比如这种： aa/dd* 虽然我（net/http）不支持但是我 速度快啊
2. 需要可以处理中间件的框架 比如 对日志的处理等 虽然我（net/http）不支持但是我 速度快啊
3. 需要 支持分组的框架 比如 v1 v2这种不同的版本 虽然我（net/http）不支持但是我 速度快啊
4. …

目前看来 net/http不适合这种复杂场景的业务逻辑 当然 Google go开发组 目的只是提供一个简小的web框架，设计目标是简单和通用。go开发组 当然也想到了 要利用开源的优势为各路大神提供大显神通的机会。问题是怎么接入呢，现实世界和虚拟世界的连接入口是 二维码。那gin框架如何接入 net/http 呢，也就是如何在重新利用它的其他功能的情况下，再进行扩展呢 你当然能想到了 这就是 interface 接口。

net/http框架中 确实是 通过实现接口来 进行 路由查找 并找到要执行的 hanlder（例如 上述代码中的hello），这样路由建立模块和路由寻址查找handler模块就可以通过不同实现来形成不同的第三方框架。建立路由模块是第三方包独自完成，而路由寻址查找模块主要是实现了 如下接口：

type Handler interface {ServeHTTP(ResponseWriter, *Request)
}

这样第三方框架 就可以复用net/http 的大部分功能（包括最重要的 epoll多路复用），并通过实现 ServeHTTP 接口 来实现自己的 路由查找模块（ps: 路由建立模块需自己建立 这块功能用不到接口） ，说完了 理论 那我们再来梳理下 net/http 从 建立连接 到 ServeHTTP的调用链，来验证下上述是否是这样的。

1.2 原生 net/http的 调用链

以 TestHttp 这个函数为例，调用入口是 server.ListenAndServe() ，其调用链为

可以看到 其最终调用到了 ServeHTTP() 这个函数，而所有第三方框架都是实现了 这个函数。这个函数包括 根据req函数中的 url获取 handler(第三方框架提供) 、处理handler和对客户端返回结果三大块的功能。
这样第三方框架就可以 实现ServeHTTP这个函数来 实现对 handler的获取（怎么建立路由结构是第三方框架自己定义）。

1.3 gin等第三方web框架和net/http关系

让我们脱离源码 来梳理下

可以看到 第三方 框架 主要是头尾两个地方跟 net/http不同 中间还是需要复用net/http代码。后续 讲解会围绕这张流程图展开，其中比较重要的是 圆圈 1、2和3，1 包括 gin 的引擎 engine 其包括建立压缩前缀树的功能并实现了 serverHttp接口 形成了 3，2主要涉及了多路复用技术。
以下的 步骤 2、3、4主要涉及圆圈1 的内容，步骤5 涉及圆圈2 的内容 ，步骤6 涉及圆圈3的内容

2. gin框架简介

2.1 gin框架发展历程

gin 框架早期版本是基于julienschmidt/httprouter 发展而来，julienschmidt/httprouter是一个高性能的http请求器。但是随着gin框架的发展 它逐渐发展出了自己的 路由实现器，实现源码也部分参考 julienschmidt/httprouter 这也就是为什么好多资料都说 gin基于julienschmidt/httprouter 但是你去看它最新的源码却没发现针对 julienschmidt/httprouter的引用。
gin框架之所以运行效率高是因为采用了一种叫 Radix Tree （压缩前缀树）的结构体来存储路由路径，其是一种例如有如下路由:

/aa/bb
/aa/bd
/aa/cc
/ac/dd
/ee/ff

建立压缩前缀树 ，请思考下其建立的树是左边还是右边呢

gin 框架的路由树的建立 就是一步一步建立如上图所示的 压缩前缀树 ps:真是的树的节点比较复杂 但是大体步骤就是如此
那么压缩前缀树 有啥优点呢 gin 为什么使用这种结构来存储器节点呢 直觉上看 我们可以想到两点 1： 这种树形结构 查找的时间复杂度是时间复杂度为 o(k) ,k是字符串的长度 2: 压缩证明其使用的空间比较少 可以看到 路径中 有 6个a 但是 我们树节点中只有 2个。这只是我们直观看出来的，对不对呢，是否还有其他优点呢？

答案： 对，当然有其他优点，这种树 也可以用来 进行通配符的匹配 例如这种 /aa/bb/* ；还可以快速建立路由分组等。这两种优势不是本文的重点，感兴趣的同学可以自行查阅资料。
既然你说gin 路由使用的是 压缩前缀树，口说无凭 我们来验证下吧 顺便看下建立的是左边还是右边的压缩前缀树

2.2 gin框架的使用

下面示例代码为（本文后续围绕下面例子展开代码讲解）：

func TestGin(t *testing.T) {// 创建一个默认的路由引擎r := gin.Default()// 当客户端以GET方法请求路径时，会执行后面的匿名函数r.GET("/aa/bb", func(c *gin.Context) { c.JSON(200, gin.H{"route path ": "/aa/bb",}) })r.GET("/aa/bd", func(c *gin.Context) { c.JSON(200, gin.H{"route path ": "/aa/bd",}) })r.GET("/aa/cc", func(c *gin.Context) { c.JSON(200, gin.H{"route path ": "/aa/cc",}) })r.GET("/ac/dd", func(c *gin.Context) { c.JSON(200, gin.H{"route path ": "/ac/dd",}) })r.GET("/ee/ff", func(c *gin.Context) { c.JSON(200, gin.H{"route path ": "/ee/ff",}) })// 以上操作 **主要 涉及 圆圈 1**// 启动HTTP服务，默认在0.0.0.0:8080启动服务  **涉及 net/http 框架处理主逻辑 内部 主要 调用 net/http 包**r.Run()}

对上述代码 debugger 可以得到 r 这个参数的 实例 实力分析如下 其中 压缩前缀树的节点node结构体的结构如下：

type node struct {path      stringindices   stringwildChild boolnType     nodeTypepriority  uint32children  []*node // child nodes, at most 1 :param style node at the end of the arrayhandlers  HandlersChainfullPath  string
}

现在只需关注node节点的 path 和 children 这两个参数 node结构体详情会在后续步骤介绍
2.2.1 父节点

可以看到 父节点 path == “/” 且有两个孩子节点

2.2.2 第二层节点

可以看到 第二层 节点 左边节点 path==“a” 孩子个数为2 ；右边节点 pah 是 “ee/ff” 这里就是将节点进行了压缩 ee 和 ff 不用再拆分了。因为 ff是ee的唯一的一个孩子节点 因为寻址路径唯一 所以可以向上合并，以便节省空间。

2.2.3 第三层节点

可以看到 左边节点 path==“a/” 孩子节点个数为2 ；右边节点 path==“c/dd”（压缩了） 孩子节点为空

2.2.4 第四层节点

可以看到 左边 节点 path=“b” ，其有两个孩子节点；右边节点 path=“cc” 其没有孩子节点

2.2.5 第五层 节点

可以看到 左边节点 path==“b” 无孩子节点 ；右边节点 path==“d” 无孩子节点

到这里我们可以看出来其确实是建立了一颗 压缩前缀树。总结下来就是： 1. 孩子节点必须大于1（否则应向上合并）2： 压缩有两层含义 第一层将 路由里面 重复的路径 进行压缩 例如 字母a 压缩后就剩2个；第二层 一个节点有一个子节点时 向上兼并 压缩空间
所以建立的前缀树是 右边的。

r.run()执行后 在浏览器输入 路径 就可以看到 对应的函数被执行（注意：默认端口是8080）结果 如图 这边主要涉及 圆圈 2–>3

2.3 gin框架的执行过程

梳理完毕 压缩前缀树的建立 那现在开始我们梳理下 整个 gin框架的流程图 其实主要是围绕 构建的压缩前缀树展开的 ，我个人比较愿意先学习框架使用，然后再进入细节，这样有一个提纲挈领的抓手，我们就知道这些细节在整体脉络中的位置，不至于陷进去失去了方向感。

通过1.3的图可以看到 gin 框架 大概 分为 三大部分

1. 创建 压缩前缀树 并且 将 路由 对应的节点 按照规则 插入树节点 ---- 步骤一（圆圈1）
2. 运行 引擎 建立 对tcp套接字的监听 这里采用多路复用技术 进行阻塞 等待链接到来 ---- 步骤二
3. 浏览器 输入 url 进行客户端请求 这时 唤醒阻塞的程序 从圆圈2 按照箭头执行顺序 一直执行到 圆圈3，然后在圆圈3 中遍历 压缩前缀树 找到对应的 handler (对于路径 ：/aa/bd 其 handler 为：func(c *gin.Context) { c.JSON(200, gin.H{"route path ": “/aa/bd”}) }) 执行后 返回结果 ---- 步骤三

3. gn框架源码–四种重要的结构体

框架一般都会采用面向对象的方式来构建，而面向对象中最重要的核心就是结构体。gin框架四种重要的结构体 分别是 Engine/RouterGroup/Node/context ，其中Engine 包含了 RouteGroup和Node 是gin框架的引擎结构体 ；Node是压缩前缀树的树节点，用来保存 压缩路径和handler，在2.2.1----2.2.5中已经做过简要介绍 ；Context 结构体官方介绍是 gin最重要的结构体 ，它允许我们在中间件之间传递变量，管理流，处理 request 请求体和 respose 响应体。可以说 gin 框架基本上是围绕着这四个结构体来操作的。

3.1 Engine 结构体

type Engine struct {RouterGroup   // 路由组 ...... //  这里为了使得文章简短 一些本文讲解没用到的 属性 没有列举 感兴趣的可以自己研究下 // UseH2C enable h2c support.UseH2C bool// ContextWithFallback enable fallback Context.Deadline(), Context.Done(), Context.Err() and Context.Value() when Context.Request.Context() is not nil.ContextWithFallback booldelims           render.DelimssecureJSONPrefix stringHTMLRender       render.HTMLRenderFuncMap          template.FuncMapallNoRoute       HandlersChainallNoMethod      HandlersChainnoRoute          HandlersChainnoMethod         HandlersChainpool             sync.Pool   // 这个池化技术 用来存储 Context结构体。 它是 gin框架很重要的结构体 主要用来 处理 request和 respose 请求trees            methodTrees   // 方法树 针对 Get/Post/Delete 等不同请求 都生成一个树 9种请求 9种树 但实现原理都是相同的 本文只介绍 Get方法，其 包含了 Node 结构体maxParams        uint16maxSections      uint16trustedProxies   []stringtrustedCIDRs     []*net.IPNet
}

Engine 结构体 是 gin 框架的入口，其包含了许多属性 但对于 我们学习jin框架核心执行逻辑来说，只需要知道 RouterGroup/pool/trees 这三个就行了

3.2 RouteGroup结构体

type RouterGroup struct {Handlers HandlersChain   // 需要处理的 handler 链，一般是 默认hanlder（例如 处理 logger和panic的handlewr）+ group组的中间件handler（例如 鉴权等）+ 用户 注册的 handlerbasePath string  // 组的基本路径engine   *Engine // gin 框架 引擎root     bool // 跟节点
}

RouterGroup 主要是用来 对路由进行操作的，包括对post/get等方法的处理。

3.3 Node 结构体

type node struct {path      string  // 节点路劲indices   string // 其子节点的 path的第一个单词 组成的 字符串 用来快速定位路径寻址时 是否走此孩子节点wildChild boolnType     nodeType // 节点类型priority  uint32  // 优先级 从左往右 越左侧 优先级越大 优先从左边开始 说明 左边的 重复的路径前缀比较多 同层其优先级越高 子节点越多 ，一般情况下 priority等于其直属孩子节点个数，且如果其直属孩子节点为一个 或者 为空，其 优先级 为 1children  []*node // child nodes, at most 1 :param style node at the end of the arrayhandlers  HandlersChain  // 处理器 存储 节点 handler 链 fullPath  string // 全路径 fullPath 
}

node 是压缩前缀树子节点，是gin框架之所以速度快的核心原因，也是我们本篇文章重点需要介绍和理解的结构体。
对于节点属性的理解 可以对照着 标题 2.21----2.2.5来理解

3.4 context 结构体

type Context struct {writermem responseWriterRequest   *http.RequestWriter    ResponseWriterParams   Paramshandlers HandlersChainindex    int8fullPath stringengine       *Engineparams       *ParamsskippedNodes *[]skippedNode// This mutex protects Keys map.mu sync.RWMutex// Keys is a key/value pair exclusively for the context of each request.Keys map[string]any// Errors is a list of errors attached to all the handlers/middlewares who used this context.Errors errorMsgs// Accepted defines a list of manually accepted formats for content negotiation.Accepted []string// queryCache caches the query result from c.Request.URL.Query().queryCache url.Values// formCache caches c.Request.PostForm, which contains the parsed form data from POST, PATCH,// or PUT body parameters.formCache url.Values// SameSite allows a server to define a cookie attribute making it impossible for// the browser to send this cookie along with cross-site requests.sameSite http.SameSite
}

context 是gin框架最重要的结构体 其包含了对 请求 和 响应的 处理逻辑，可以在中间件之间传递数据流。因不是本文的理解gin框架的需要用到的结构体，暂不做过多介绍，请自行用谷歌百度一下。