Go-Gin源码学习一

Gin 的基本使用

Gin 是一个比较轻量级的 http 框架，主要是提供了几个便于使用的功能：

• 简单的中间件注册，可以很方便的实现通用中间件的使用注册
• 提供了比较方便和全面的路由注册，方便的实现 RESTful 接口的实现
• 提供了便捷的获取参数的方法，包括 get、post 兵可以可以把数据直接转换成对象
• 对路由的分组，Gin 可以对一组路由做统一的中间件注册等操作
• 可以手机所有错误，统一在统一的地方写日志

性能方面：

• 是路由的基础数据格式为基数树没有使用反射，所以性能方面也是比较低消耗内存低
• 上下文 context 使用了对象池，fasthttp 中也同样使用了 sync.pool

使用方便也是比较简单的，下面有一个很简单的例子

package main

import (
    "fmt"
    "github.com/gin-gonic/gin"
    "test/gin/middleware/model"
)

func main() {
    // 创建 router
    router := gin.Default()
    // 创建组
    group := router.Group("/api")
    // 为组加中间件
    group.Use(func(context *gin.Context) {fmt.Println("api group url:", context.Request.URL.String())
    })
    // 为组加路由方法
    group.GET("/test", func(context *gin.Context) {context.JSON(200, model.Message{Message:"ok"})
    })
    // 运行
    router.Run(":3333")
}

例子中是一个最简单的 Gin 框架的应用。创建了一个 engine，创建了组并且为组添加了中间件之后在这个 group 下的路由方法都将使用这个中间件，方便对 api 最系统的管理对不同的 api 做不同的处理。
在 Terminal 中访问可以看到下面的结果

curl http://localhost:3333/api/test
{"Message":"ok"}panleiMacBook-Pro:test 

主要流程的源码

首先我们先看例子中的 gin.Default() 返回的 engine 对象，这是 Gin 的主要对象。只对最主要的属性加了注释

type Engine struct {
    // 路由组
    RouterGroup
    RedirectTrailingSlash bool
    RedirectFixedPath bool
    HandleMethodNotAllowed bool
    ForwardedByClientIP    bool
    AppEngine bool
    UseRawPath bool
    UnescapePathValues bool
    MaxMultipartMemory int64
    delims           render.Delims
    secureJsonPrefix string
    HTMLRender       render.HTMLRender
    FuncMap          template.FuncMap
    allNoRoute       HandlersChain
    allNoMethod      HandlersChain
    noRoute          HandlersChain
    noMethod         HandlersChain
    // 对象池 用来创建上下文 context
    pool             sync.Pool
    // 记录路由方法的 比如 GET POST 都会是数组中的一个 每个方法对应一个基数树的一个 root 的 node
    trees            methodTrees
}

然后我们来看 Default 方法，其实很简单就是创建一个 engine 对象并且添加默认的两个中间件，一个是做 log 显示，显示每次请求可以再 console 中看到。每次创建 engine 对象的时候回默认的添加一个 routergroup 地址为默认的 ”/” 代码如下：

func Default() *Engine {debugPrintWARNINGDefault()
    engine := New()
    engine.Use(Logger(), Recovery())
    return engine
}
//new 方法中默认的 添加了 routergroup 路由“/”func New() *Engine {debugPrintWARNINGNew()
    engine := &Engine{
        RouterGroup: RouterGroup{
            Handlers: nil,
            basePath: "/",
            root:     true,
        },
        FuncMap:                template.FuncMap{},
        RedirectTrailingSlash:  true,
        RedirectFixedPath:      false,
        HandleMethodNotAllowed: false,
        ForwardedByClientIP:    true,
        AppEngine:              defaultAppEngine,
        UseRawPath:             false,
        UnescapePathValues:     true,
        MaxMultipartMemory:     defaultMultipartMemory,
        trees:                  make(methodTrees, 0, 9),
        delims:                 render.Delims{Left: "{{", Right: "}}"},
        secureJsonPrefix:       "while(1);",
    }
    engine.RouterGroup.engine = engine
    engine.pool.New = func() interface{} {return engine.allocateContext()
    }
    return engine
}

在看中间件之前还有一个重要的对象 context 上下文对象
这个对象中存放了 engine 指针、请求的 request 对象、返回的 responsewriter 对象还有一些参数等对象，这个 context 将在请求一开始就被创建一直贯穿整个执行过程，包括中间件，路由等。最后的返回值可以再 responseWriter 写，最终就会返回给客户端。

type Context struct {
    writermem responseWriter
    Request   *http.Request
    Writer    ResponseWriter

    Params   Params
    handlers HandlersChain
    index    int8

    engine *Engine

    // Keys is a key/value pair exclusively for the context of each request.
    Keys map[string]interface{}

    // 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}

接下来看得是添加中间件 use 方法

func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
    // 调用 routegroup 的 use 方法
    engine.RouterGroup.Use(middleware...)
    engine.rebuild404Handlers()
    engine.rebuild405Handlers()
    return engine
}

func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
    // 为 group 的 handlers 添加中间件 
    group.Handlers = append(group.Handlers, middleware...)
    return group.returnObj()}

添加为中间件之后就是添加正常路由，Gin 中提供了 GET、POST、DELETE 更各种方法，我们就只看 get 方法其余的都是相同的处理方式。总结下来就是把 group 和传入的 handler 合并，并且计算出路径存入到 tree 中等客户端的调用。

func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
    // 调用 get 方法
    return group.handle("GET", relativePath, handlers)
}

func (group *RouterGroup) handle(httpMethod, relativePath string, handlers HandlersChain) IRoutes {// 计算路径地址，比如 group 地址是 router.Group("/api")
    // 结果为 /api/test/ 就是最终计算出来的结果 使用 path.join 方法拼接 其中加了一些判断
    absolutePath := group.calculateAbsolutePath(relativePath)
    // 把 group 中的 handler 和传入的 handler 合并 
    handlers = group.combineHandlers(handlers)
    // 把方法 路径 和处理方法作为 node 加入到基数树种，基数树在下次单独学习分析
    group.engine.addRoute(httpMethod, absolutePath, handlers)
    return group.returnObj()}

func (group *RouterGroup) combineHandlers(handlers HandlersChain) HandlersChain {finalSize := len(group.Handlers) + len(handlers)
    if finalSize >= int(abortIndex) {panic("too many handlers")
    }
    mergedHandlers := make(HandlersChain, finalSize)
    copy(mergedHandlers, group.Handlers)
    copy(mergedHandlers[len(group.Handlers):], handlers)
    return mergedHandlers
}

最后我们需要看 run 方法，之前的都是准备工作或者说是设置路由中间件。等 run 方法执行的时候则是服务真正启动起来。代码很简单，几乎不需要注释是调用 gohttp 包的 ListenAndServe 方法把 engine 传入然后 http 包中会有一个 for 逻辑不停的监听这个端口号的所有请求。

func (engine *Engine) Run(addr ...string) (err error) {defer func() {debugPrintError(err) }()

    address := resolveAddress(addr)
    debugPrint("Listening and serving HTTP on %s\n", address)
    err = http.ListenAndServe(address, engine)
    return
}

func ListenAndServe(addr string, handler Handler) error {server := &Server{Addr: addr, Handler: handler}
    return server.ListenAndServe()}

那么客户端最终请求之后会走到那些代码，又是怎么找到路由并且调用一个个中间件的呢？其实 engine 是继承了 Handler 这个接口（可以看下面代码），我们知道如果不适用 Gin 框架直接使用 http 包我们所有的路由就是直接继承这个接口所以对这个接口我们是很熟悉的。
下面的 serveHTTP 就是 Gin 的方法 最主要流程就是从 tree 中获取到路由，然后依次执行 handler 最终处理完成返回给客户端。

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

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    // 从对象池中获取 context 对象，这就是最初我们看到的一种优化性能的一种方式
    c := engine.pool.Get().(*Context)
    // 重置 writer 中的一些值
    c.writermem.reset(w)
    把 request 放到 context 中
    c.Request = req
    c.reset()
    // 调用处理方法
    engine.handleHTTPRequest(c)
    // 处理完成把 context 对象放回到对象池
    engine.pool.Put(c)
}

func (engine *Engine) handleHTTPRequest(c *Context) {
    // 获取请求方法和路径
    httpMethod := c.Request.Method
    path := c.Request.URL.Path
    unescape := false
    if engine.UseRawPath && len(c.Request.URL.RawPath) > 0 {
        path = c.Request.URL.RawPath
        unescape = engine.UnescapePathValues
    }

    // 根据基数树的特性寻找方法发 并调用 next 方法 依次执行 handler
    t := engine.trees
    for i, tl := 0, len(t); i < tl; i++ {if t[i].method != httpMethod {continue}
        root := t[i].root
        // Find route in tree
        handlers, params, tsr := root.getValue(path, c.Params, unescape)
        if handlers != nil {
            c.handlers = handlers
            c.Params = params
            c.Next()
            c.writermem.WriteHeaderNow()
            return
        }
        if httpMethod != "CONNECT" && path != "/" {
            if tsr && engine.RedirectTrailingSlash {redirectTrailingSlash(c)
                return
            }
            if engine.RedirectFixedPath && redirectFixedPath(c, root, engine.RedirectFixedPath) {return}
        }
        break
    }

    if engine.HandleMethodNotAllowed {
        for _, tree := range engine.trees {
            if tree.method == httpMethod {continue}
            if handlers, _, _ := tree.root.getValue(path, nil, unescape); handlers != nil {
                c.handlers = engine.allNoMethod
                serveError(c, http.StatusMethodNotAllowed, default405Body)
                return
            }
        }
    }
    c.handlers = engine.allNoRoute
    serveError(c, http.StatusNotFound, default404Body)
}

总结

从上面的流程我们可以看到，其实 Gin 框架就是对 go http 包的一次封装，加入了 group 和 tree。让我们可以更简单方便的使用 http 包。其实 Gin 还有很多其他功能的源码包括参数分析 json 解析等等，这次学习的只是 Gin 的主要流程。Gin 中 tree 是一个亮点，是的它在查找路由性能方面有很大的优势，下一篇文章会主要学习 tree（基数树）。