Gin框架的工作过程

使用

代码语言：javascript复制

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
}

工作流程

主要代码解释

路由注册：

代码语言：javascript复制

// 路由组
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中合适的位置插入该结点

服务启动 & 请求处理：

代码语言：javascript复制

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

 address := resolveAddress(addr)
 debugPrint("Listening and serving HTTP on %sn", 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  
	}
}

gin中路由使用radix tree的好处
1. 路由中可以使用类似于 :id 动态参数
2. 路径中的相同部分只会出现在一个结点上，在一定程度上可以减少对内存的占用
3. 查找效率高（虽然可能达不到map那种 O(1)的时间复杂度，查找复杂度最坏情况下是O(h),h为树高）
4. 关于radix tree（基数树）的构建及查找我个人还没完全搞明白，感兴趣的朋友可以参考下面两篇文章：路由查找之Radix Tree、Gin的基数树路由局限及最佳实践

注：总结不易，如需转载请注明出处：https://cloud.tencent.com/developer/article/1856751

gin map radix tree 最佳实践

1 人点赞