看看Gin框架是如何实现的

基本使用

gin是一个高性能的golang web框架，它的代码其实很少，相对于spring来说，搞懂gin真是砍瓜切菜

先来看一下gin的基础用法

import "github.com/gin-gonic/gin"func Init() {r := gin.Default()initRoute(r)r.Run()
}func initRoute(r *gin.Engine) {r.GET("ping", handler)
}func handler(ctx *gin.Context) {ctx.String(200, "Hello World!")
}

这个例子里，我们启动了一个简单的web服务，使用gin.Default创建一个Engine对象，Engine是Gin核心中的核心，我们后面会具体讲解。之后通过initRoute注册一个路由，当访问localhost:8080/ping的时候，就会返回Hello World!。

最后调用r.run让服务启动。只需要很少的几行代码，就能通过gin启动一个web服务。我们主要探索它的实现原理，关于gin更多的语言特性和用法这里就不细说了，更多例子可以前往Gin Examples.

Engine

官网解释：Engine是框架的实例，它包含了复用器、中间件和各类配置。

type Engine struct {// 路由组RouterGroup// 如果设置为true，如果/foo/没有匹配到路由，自动重定向到/fooRedirectTrailingSlash bool// 和RedirectTrailingSlash类似，对path做一些修正RedirectFixedPath boolHandleMethodNotAllowed boolForwardedByClientIP bool// DEPRECATEDAppEngine bool// 是否通过url.RawPath来获取参数UseRawPath bool// If true, the path value will be unescaped.// If UseRawPath is false (by default), the UnescapePathValues effectively is true,// as url.Path gonna be used, which is already unescaped.UnescapePathValues boolRemoveExtraSlash bool// List of headers used to obtain the client IP when// `(*gin.Engine).ForwardedByClientIP` is `true` and// `(*gin.Context).Request.RemoteAddr` is matched by at least one of the// network origins of list defined by `(*gin.Engine).SetTrustedProxies()`.RemoteIPHeaders []string// If set to a constant of value gin.Platform*, trusts the headers set by// that platform, for example to determine the client IPTrustedPlatform string// Value of 'maxMemory' param that is given to http.Request's ParseMultipartForm// method call.MaxMultipartMemory int64delims           render.DelimssecureJSONPrefix stringHTMLRender       render.HTMLRenderFuncMap          template.FuncMapallNoRoute       HandlersChainallNoMethod      HandlersChainnoRoute          HandlersChainnoMethod         HandlersChainpool             sync.Pooltrees            methodTreesmaxParams        uint16maxSections      uint16trustedProxies   []stringtrustedCIDRs     []*net.IPNet
}

Engine里面这么多字段，还有很多方法没往这贴呢，不用着急，我们一点一点的抽丝剥茧，揭开gin的真面目

简单的看，一个gin服务对应一个Engine实例。r = gin.Default()实际上就是创建了一个Engine对象，它的源码也不复杂

func Default() *Engine {engine := New()// 注册中间件engine.Use(Logger(), Recovery())return engine
}func New() *Engine {engine := &Engine{RouterGroup: RouterGroup{Handlers: nil,basePath: "/",root:     true,},FuncMap:                template.FuncMap{},RedirectTrailingSlash:  true,......}engine.RouterGroup.engine = engine// pool存放context对象engine.pool.New = func() interface{} {return engine.allocateContext()}return engine
}

首先New一个Engine出来，初始化一些基础结构，然后通过Use方法注入两个中间件logger和recovery，它们的类型是HandlerFunc，logger打日志用的，recovery用来在服务panic是recover掉，然后返回500，避免服务直接崩溃。

有意思的是engine里面有一个字段pool，类型是sync.pool，在创建Engine的时候，我们也对pool进行了初始化，关于sync.pool可以看我的另一片文章【todo】，可以看到pool的New方法创建并返回了一个context，而context是每一个请求都有的，携带上下文信息的对象，可以想象context是非常重的，如果每一个请求都创建并销毁一个context对象，GC肯定撑不住了啊，还怎么成为一个高性能的wen服务器？所以Gin通过sync.pool来达成对context的复用，优化GC。

路由

不管web服务框架是如何实现的，它最基础的功能就是路由，简单来说就是解析url，然后分派不同的handler来处理对应请求。

在创建Engine后，我们还的告诉它，如何处理路由信息。注册路由非常简单，Engine支持RESTful的6种方法。

func initRoute(r *gin.Engine) {r.GET("ping", pingHandler)
}

实际上Engine是通过继承了RouterGroup（可以在Engine的结构体里找到）来实现路由处理的，所有的路由处理都在RouterGroup中完成，以Get源码为例

func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {return group.handle(http.MethodGet, relativePath, handlers)
}

当我们通过GET注册路由后，会得到一个IRoutes对象，IRoutes本身是一个interface，定义了一系列方法，其中就包含GET，POST…等，不难发现RouterGroup实现了IRoutes。另外注册路由时，对一个path，不只可以穿入一个处理方法，源码里三个点代表我们可以传入多个handler，之后在请求到达时会逐个被调用。而GET直接调用了内部的group.handle，这里面又是如何实现的呢

func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {absolutePath := group.calculateAbsolutePath(relativePath)handlers = group.combineHandlers(handlers)group.engine.addRoute(httpMethod, absolutePath, handlers)return group.returnObj()
}

一共有三步

1、计算绝对路径

func (group *RouterGroup) calculateAbsolutePath(relativePath string) string {return joinPaths(group.basePath, relativePath)
}

其实就是字符串join一下，用basePath和当前注册的path组合。哪里来的basePath，以及为什么要join呢？

我们在创建Engine的时候，其实就注册了一个path，它就是"/"，其他后续所有注册的path都挂在它下面，如果把它看成一颗树的root节点，在它下面还有更多的子节点，而一个完整的path，就是从根节点到子节点中间经过的所有Path的组合。实际上Gin对于路由的管理就用到了树的结构，这个后面再讲。

2、添加handlers

当前传进去的handlers是path的，但人家basePath也有handlers，basePath是path的前缀，当你发起请求的时候，是不是所有basePath的handlers都应该过一遍呢。添加的过程也并不负责，就是重新开辟一个数组空间，然后把basePath和path的handlers都拷贝到这里，然后返回数组地址。

3、关联绝对路径和handlers

这一步比较重要，逻辑也比较复杂了，先看看最外层的代码，滤去一些无关痛痒的代码

func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {......root := engine.trees.get(method)if root == nil {root = new(node)root.fullPath = "/"engine.trees = append(engine.trees, methodTree{method: method, root: root})}root.addRoute(path, handlers)......
}

首先根据method获取根节点，metod有哪些？GET, POST, PUT, DELETE…

如果根节点不存在，就创建一个，然后加入到entine.trees里，entine.trees是methodTrees，methodTrees的定义是[]methodTree，所以entine.trees就是一个methedTree数组。抽丝剥茧，methedTree又是什么玩意儿？

type methodTree struct {method stringroot   *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
}

链路稍微有点长了，画个图更清晰些

未完待续…