Gin源码阅读与分析

很典型的一个web框架

先看简单的demo：

package main

import "github.com/gin-gonic/gin"

func main() {
        r := gin.Default()
        r.GET("/ping", func(c *gin.Context) {
                c.JSON(200, gin.H{
                        "message": "pong",
                })
        })
        r.Run() // listen and serve on 0.0.0.0:8080
}

  • 先看 gin.Default:

    // Default returns an Engine instance with the Logger and Recovery middleware already attached.
func Default() *Engine {
    debugPrintWARNINGDefault()
    engine := New()
    engine.Use(Logger(), Recovery())
    return engine
}

  • 看 engine := New() 所返回的结构体：

    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
}

  • 看 engine.Use:

    func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
    engine.RouterGroup.Use(middleware...)
    engine.rebuild404Handlers()
    engine.rebuild405Handlers()
    return engine
}

engine.RouterGroup.Use:

func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
        group.Handlers = append(group.Handlers, middleware...)
        return group.returnObj()
    }

  • 接下来回到demo，看 r.Run():

    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
}

看过 net/http 的同学应该知道，在Go里只要实现 ServeHTTP 就可以，所以我们找一下：

func (engine *Engine) ServeHTTP(w http.ResponseWriter, req *http.Request) {
        c := engine.pool.Get().(*Context)
        c.writermem.reset(w)
        c.Request = req
        c.reset()

        engine.handleHTTPRequest(c)

        engine.pool.Put(c)
}

这就是处理流程，请求来了，从 engine.pool 里拿一个空的context，丢到 engine.handleHTTPRequest 处理，然后回收。

  • 看 engine.handleHTTPRequest:

    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
    }

    // Find root of the tree for the given HTTP method
    t := engine.trees
    for i, tl := 0, len(t); i < tl; i++ {
            if t[i].method == httpMethod {
                    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 {
                            if handlers, _, _ := tree.root.getValue(path, nil, unescape); handlers != nil {
                                    c.handlers = engine.allNoMethod
                                    serveError(c, 405, default405Body)
                                    return
                            }
                    }
            }
    }
    c.handlers = engine.allNoRoute
    serveError(c, 404, default404Body)
}

大致的流程就是从路由里找出handler，然后进行处理。其中路由使用 httprouter 实现，使用的数据结构是基数树(radix tree)。

  • 看 c.Next():

    func (c *Context) Next() {
    c.index++
    for s := int8(len(c.handlers)); c.index < s; c.index++ {
            c.handlers[c.index](c)
    }
}

最开始的时候 c.index 为0值，所以会执行 c.handlers 里面的第一个handler，然后一个个执行下去。

  • 我们来看看中间件的原理。先看demo：

    package main

import (
	"fmt"
	"os"
	"time"

	"github.com/gin-gonic/contrib/ginrus"
	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
)

func main() {
	r := gin.New()

	r.Use(ginrus.Ginrus(logrus.StandardLogger(), time.RFC3339, true))

	// Example ping request.
	r.GET("/ping", func(c *gin.Context) {
		c.String(200, "pong "+fmt.Sprint(time.Now().Unix()))
	})

	// Listen and Server in 0.0.0.0:8080
	r.Run(":8080")
}

来看一下 r.Use:

func (engine *Engine) Use(middleware ...HandlerFunc) IRoutes {
        engine.RouterGroup.Use(middleware...)
        engine.rebuild404Handlers()
        engine.rebuild405Handlers()
        return engine
}

继续追:

func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
        group.Handlers = append(group.Handlers, middleware...)
        return group.returnObj()
}

然后发现没有然后了，那么当我们调用 r.GET 的时候发生了什么呢？追一下发现其实就是调用了 RouterGroup.GET

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

继续：

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()
}

这里会把绝对路由算出来，然后加到树里。里面有一步 handlers = group.combineHandlers(handlers):

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
}

看到了 group.Handlers 嘛？上面的 Use 也有用到。所以其实 Use 和 GET, POST 等是一样的。 而中间件则是通过 c.Next 先执行接下来的handlers，然后返回再执行当前的。比如 Ginrus:


ckage ginrus

import (
	"time"

	"github.com/gin-gonic/gin"
	"github.com/sirupsen/logrus"
)

type loggerEntryWithFields interface {
	WithFields(fields logrus.Fields) *logrus.Entry
}

// Ginrus returns a gin.HandlerFunc (middleware) that logs requests using logrus.
//
// Requests with errors are logged using logrus.Error().
// Requests without errors are logged using logrus.Info().
//
// It receives:
//   1. A time package format string (e.g. time.RFC3339).
//   2. A boolean stating whether to use UTC time zone or local.
func Ginrus(logger loggerEntryWithFields, timeFormat string, utc bool) gin.HandlerFunc {
	return func(c *gin.Context) {
		start := time.Now()
		// some evil middlewares modify this values
		path := c.Request.URL.Path
		c.Next()

		end := time.Now()
		latency := end.Sub(start)
		if utc {
			end = end.UTC()
		}

		entry := logger.WithFields(logrus.Fields{
			"status":     c.Writer.Status(),
			"method":     c.Request.Method,
			"path":       path,
			"ip":         c.ClientIP(),
			"latency":    latency,
			"user-agent": c.Request.UserAgent(),
			"time":       end.Format(timeFormat),
		})

		if len(c.Errors) > 0 {
			// Append error field if this is an erroneous request.
			entry.Error(c.Errors.String())
		} else {
			entry.Info()
		}
	}
}

到此，Over :)

更多文章
  • 尤克里里
  • 学习使用Bootstrap4的栅格系统
  • 利用Github的WebHook完成自动部署
  • 使用Tornado和rst来写博客
  • Haskell do notation
  • foldl 和 foldr 的变换
  • Haskell TypeClass 笔记
  • 重新捡起你那吃灰的树莓派
  • Tornado 源码阅读
  • JavaScript权威指南笔记
  • Python零碎知识汇总
  • C语言的位操作
  • 分治
  • 关于python的decorator和descriptor
  • 程序设计实践笔记

    • 本站热门