gin框架源码学习笔记(二)中间件

秒速五厘米 2021-12-17 02:37 439阅读 1赞

# gin框架源码学习笔记(二)中间件 #

gin 默认时使用了logger和recovery两个中间件。

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

Use()接口会将Logger和Recover()的处理函数追加到Handlers的后面

// Logger instances a Logger middleware that will write the logs to gin.DefaultWriter.
    // By default gin.DefaultWriter = os.Stdout.
    func Logger() HandlerFunc {
        
    	return LoggerWithConfig(LoggerConfig{
        })
    }

// Use adds middleware to the group, see example code in GitHub.
    func (group *RouterGroup) Use(middleware ...HandlerFunc) IRoutes {
        
    	group.Handlers = append(group.Handlers, middleware...)
    	return group.returnObj()
    }

这样每个方法便有了一条handers链 :  
假设这是一个Get方法  
![\[外链图片转存失败(img-XeeQiHP5-1562421537137)(./1562419512149.png)\]][img-XeeQiHP5-1562421537137_._1562419512149.png]

现在看看日志的处理函数做些什么

// LoggerWithConfig instance a Logger middleware with config.
    
    	return func(c *Context) {
        
    		// Start timer
    		start := time.Now()
    		path := c.Request.URL.Path
    		raw := c.Request.URL.RawQuery
    
    		// Process request
    		c.Next()
    
    		// Log only when path is not being skipped
    		if _, ok := skip[path]; !ok {
        
    			param := LogFormatterParams{
        
    				Request: c.Request,
    				isTerm:  isTerm,
    				Keys:    c.Keys,
    			}
    
    			// Stop timer
    			param.TimeStamp = time.Now()
    			param.Latency = param.TimeStamp.Sub(start)
    
    			param.ClientIP = c.ClientIP()
    			param.Method = c.Request.Method
    			param.StatusCode = c.Writer.Status()
    			param.ErrorMessage = c.Errors.ByType(ErrorTypePrivate).String()
    
    			param.BodySize = c.Writer.Size()
    
    			if raw != "" {
        
    				path = path + "?" + raw
    			}
    
    			param.Path = path
    
    			fmt.Fprint(out, formatter(param))
    		}
    	}

可以看到 先是记录了一个开始时间，然后处理`c.Next()` 处理完c.Next() 记录结束时间然后 计算 该条请求消耗的时间，及一些其他客户信息打印到终端 . 那说明c.Next() 会处理我们注册的处理函数， 看看c.Next()

// Next should be used only inside middleware.
    // It executes the pending handlers in the chain inside the calling handler.
    // See example in GitHub.
    func (c *Context) Next() {
        
    	c.index++
    	for c.index < int8(len(c.handlers)) {
        
    		c.handlers[c.index](c)
    		c.index++
    	}
    }

c.Next()会调用handlers中的其他handler， 我们知道他的下一条handler 是 Recover 的，再看看Recover的handler

return func(c *Context) {
        
    		defer func() {
        
    			if err := recover(); err != nil {
        
    				// Check for a broken connection, as it is not really a
    				// condition that warrants a panic stack trace.
    				var brokenPipe bool
    				if ne, ok := err.(*net.OpError); ok {
        
    					if se, ok := ne.Err.(*os.SyscallError); ok {
        
    						if strings.Contains(strings.ToLower(se.Error()), "broken pipe") || strings.Contains(strings.ToLower(se.Error()), "connection reset by peer") {
        
    							brokenPipe = true
    						}
    					}
    				}
    				if logger != nil {
        
    					stack := stack(3)
    					httpRequest, _ := httputil.DumpRequest(c.Request, false)
    					headers := strings.Split(string(httpRequest), "\r\n")
    					for idx, header := range headers {
        
    						current := strings.Split(header, ":")
    						if current[0] == "Authorization" {
        
    							headers[idx] = current[0] + ": *"
    						}
    					}
    					if brokenPipe {
        
    						logger.Printf("%s\n%s%s", err, string(httpRequest), reset)
    					} else if IsDebugging() {
        
    						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s\n%s%s",
    							timeFormat(time.Now()), strings.Join(headers, "\r\n"), err, stack, reset)
    					} else {
        
    						logger.Printf("[Recovery] %s panic recovered:\n%s\n%s%s",
    							timeFormat(time.Now()), err, stack, reset)
    					}
    				}
    
    				// If the connection is dead, we can't write a status to it.
    				if brokenPipe {
        
    					c.Error(err.(error)) // nolint: errcheck
    					c.Abort()
    				} else {
        
    					c.AbortWithStatus(http.StatusInternalServerError)
    				}
    			}
    		}()
    		c.Next()
    	}

可以看到有个defer, recover()应该先通过c.Next()处理了用户的的handler() 如果用户handler()崩溃了，就进行恢复，不会因为一个请求导致服务器挂掉以影响其他请求的处理。

也就是说它最后的调用的顺序会是这样的，

![\[外链图片转存失败(img-V2HRWBq0-1562421537139)(./1562421317783.png)\]][img-V2HRWBq0-1562421537139_._1562421317783.png]

gin框架还是很灵活的，这样我们也能定制自己的中间件进行扩展了。

[img-XeeQiHP5-1562421537137_._1562419512149.png]: /images/20211214/3da642d8ec8247bda7c138f0ebdf23c6.png
[img-V2HRWBq0-1562421537139_._1562421317783.png]: /images/20211214/bffd551c55044ce49c4d4cbbfec3fe62.png