Gin框架的工作过程

package main

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

func main() {
  // 得到 engine 对象，里面含有 RouterGroup 
    r := gin.Default()
  // 往路由的radix tree里面注册路由及对应的处理方法
    r.GET("/ping", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "message": "pong",
        })
    })
  //如果run方法中没有填ip:port的话，默认会是 0.0.0.0:8080
    r.Run() // listen and serve on 0.0.0.0:8080
}

// 路由组
func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
	return &RouterGroup{
		Handlers: group.combineHandlers(handlers),
		basePath: group.calculateAbsolutePath(relativePath),
		engine:   group.engine,
	}
}

// POST 方法注册
func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodPost, relativePath, handlers)
}

// GET 方法注册
func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
	return group.handle(http.MethodGet, 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 给 加入到 要注册的路由节点
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
}

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


// 真正的注册路由方法的过程
// 先检测对应的method有没有对应的radix tree，然后再进行注册
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)

	// Update maxParams
	if paramsCount := countParams(path); paramsCount > engine.maxParams {
		engine.maxParams = paramsCount
	}
}

//func (n *node) addRoute方法是路由构建过程中最核心的地方--构建radix tree，这个算法会先计算出已有节点与将要插入的节点的共同前缀，然后根据两个节点与共同前缀的长度相比分三种情况（i < len(n.path)、i < len(path)、二者都满足），最终在radix tree中合适的位置插入该结点

// 服务启动
func (engine *Engine) Run(addr ...string) (err error) {
 defer func() { debugPrintError(err) }()

 address := resolveAddress(addr)
 debugPrint("Listening and serving HTTP on %s\n", address)
  // 当请求进来的时候，会走 engine的 ServeHTTP 方法，具体可以看一下 golang 的 http包ListenAndServe方法的解析
 err = http.ListenAndServe(address, engine)
 return
}

// 相当于流量分发，当有请求到达时，会先经过此方法
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)
}


// func (engine *Engine) handleHTTPRequest(c *Context) 方法 从 context对象中获取到请求的method和url，然后从对应method的radix tree中查找对应路径对应的 handlers,将其赋值给context的handlers，调用context.Next 方法去执行 handlers（用户自定义的逻辑代码），自定义的方法中通过调用c.JSON 来给客户端返回json数据

// 执行用户自定义的逻辑代码
func (c *Context) Next() {
	c.index++
	for c.index < int8(len(c.handlers)) {
		c.handlers[c.index](c)
		c.index++
	}
}