gin框架源码学习笔记(一)简单解读一个hello程序

快来打我* 2022-01-27 07:59 195阅读 0赞

# gin框架源码学习笔记(一)简单解读一个hello程序 #

### 文章目录 ###

*  gin框架源码学习笔记(一)简单解读一个hello程序
 *   *  hello程序
     *  Default()
     *   *  Engine
     *  GET()
     *  run()
     *  小结

--------------------

先把源码拉下来，go get [github.com/gin-gonic/gin][github.com_gin-gonic_gin]

之后本章简单解读一个hello程序.

## hello程序 ##

package main
     
    import (
        "github.com/gin-gonic/gin"
        "net/http"
    )
     
    func hello(context *gin.Context){
         
        context.String(http.StatusOK, "hello gin!")
    }
    func main(){
        
        // 注册一个默认路由器
        router := gin.Default()
     
        //注册GET处理
        router.GET("/hello", hello)
     
        //默认8080端口
        router.Run(":8080")
    }

![Alt text][]

## Default() ##

`Default()`  
Default()接口定义在gin.go里面,返回一个带日志和Reovery中间件的Engine实例.

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

Engine 是gin框架的实例，它包括了muxer复用器，中间件和配置设置，  
New() 或者 Default()接口会创建一个Engine 实例.

![Alt text][Alt text 1]

// Engine is the framework's instance, it contains the muxer, middleware and configuration settings.
    // Create an instance of Engine, by using New() or Default()
    type Engine struct {
        
    	RouterGroup
    
    	// Enables automatic redirection if the current route can't be matched but a
    	// handler for the path with (without) the trailing slash exists.
    	// For example if /foo/ is requested but a route only exists for /foo, the
    	// client is redirected to /foo with http status code 301 for GET requests
    	// and 307 for all other request methods.
    	RedirectTrailingSlash bool
    
    	// If enabled, the router tries to fix the current request path, if no
    	// handle is registered for it.
    	// First superfluous path elements like ../ or // are removed.
    	// Afterwards the router does a case-insensitive lookup of the cleaned path.
    	// If a handle can be found for this route, the router makes a redirection
    	// to the corrected path with status code 301 for GET requests and 307 for
    	// all other request methods.
    	// For example /FOO and /..//Foo could be redirected to /foo.
    	// RedirectTrailingSlash is independent of this option.
    	RedirectFixedPath bool
    
    	// If enabled, the router checks if another method is allowed for the
    	// current route, if the current request can not be routed.
    	// If this is the case, the request is answered with 'Method Not Allowed'
    	// and HTTP status code 405.
    	// If no other Method is allowed, the request is delegated to the NotFound
    	// handler.
    	HandleMethodNotAllowed bool
    	ForwardedByClientIP    bool
    
    	// #726 #755 If enabled, it will thrust some headers starting with
    	// 'X-AppEngine...' for better integration with that PaaS.
    	AppEngine bool
    
    	// If enabled, the url.RawPath will be used to find parameters.
    	UseRawPath bool
    
    	// If true, the path value will be unescaped.
    	// If UseRawPath is false (by default), the UnescapePathValues effectively is true,
    	// as url.Path gonna be used, which is already unescaped.
    	UnescapePathValues bool
    
    	// Value of 'maxMemory' param that is given to http.Request's ParseMultipartForm
    	// method call.
    	MaxMultipartMemory int64
    
    	delims           render.Delims
    	secureJsonPrefix string
    	HTMLRender       render.HTMLRender
    	FuncMap          template.FuncMap
    	allNoRoute       HandlersChain
    	allNoMethod      HandlersChain
    	noRoute          HandlersChain
    	noMethod         HandlersChain
    	pool             sync.Pool
    	trees            methodTrees
    }

RouterGroup 用于内部配置路由,一个RouterGroup关联一个前缀和handlers数组.

// RouterGroup is used internally to configure router, a RouterGroup is associated with
    // a prefix and an array of handlers (middleware).
    type RouterGroup struct {
        
    	Handlers HandlersChain
    	basePath string
    	engine   *Engine
    	root     bool
    }

// HandlerFunc defines the handler used by gin middleware as return value.
    type HandlerFunc func(*Context)
    
    // HandlersChain defines a HandlerFunc array.
    type HandlersChain []HandlerFunc

## GET() ##

RouterGroup.go中的IRoutes 定义了所有路由的handle接口，其中就包括了http的7种请求方法。

例如GET()会通过handle()->addRoute() 将path对应的handle添加到Get的字典树里面，关于压缩字典树上篇文章有简单介绍其算法实现 [go路由httprouter中的压缩字典树算法图解及c++实现][go_httprouter_c]

func (engine *Engine) addRoute(method, path string, handlers HandlersChain) {
        
    	assert1(path[0] == '/', "path must begin with '/'")
    	assert1(method != "", "HTTP method can not be empty")
    	assert1(len(handlers) > 0, "there must be at least one handler")
    
    	debugPrintRoute(method, path, handlers)
    	root := engine.trees.get(method)
    	if root == nil {
        
    		root = new(node)
    		engine.trees = append(engine.trees, methodTree{
        method: method, root: root})
    	}
    	root.addRoute(path, handlers)
    }

压缩字典树定义在tree.go里面，其实就是httprouter.

type methodTree struct {
        
    	method string
    	root   *node
    }
    
    type methodTrees []methodTree
    
    func (trees methodTrees) get(method string) *node {
        
    	for _, tree := range trees {
        
    		if tree.method == method {
        
    			return tree.root
    		}
    	}
    	return nil
    }

// IRoutes defines all router handle interface.
    type IRoutes interface {
        
    	Use(...HandlerFunc) IRoutes
    
    	Handle(string, string, ...HandlerFunc) IRoutes
    	Any(string, ...HandlerFunc) IRoutes
    	GET(string, ...HandlerFunc) IRoutes
    	POST(string, ...HandlerFunc) IRoutes
    	DELETE(string, ...HandlerFunc) IRoutes
    	PATCH(string, ...HandlerFunc) IRoutes
    	PUT(string, ...HandlerFunc) IRoutes
    	OPTIONS(string, ...HandlerFunc) IRoutes
    	HEAD(string, ...HandlerFunc) IRoutes
    
    	StaticFile(string, string) IRoutes
    	Static(string, string) IRoutes
    	StaticFS(string, http.FileSystem) IRoutes
    }
    
    var _ IRouter = &RouterGroup{
        }
    
    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()
    }
    
    // POST is a shortcut for router.Handle("POST", path, handle).
    func (group *RouterGroup) POST(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("POST", relativePath, handlers)
    }
    
    // GET is a shortcut for router.Handle("GET", path, handle).
    func (group *RouterGroup) GET(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("GET", relativePath, handlers)
    }
    
    // DELETE is a shortcut for router.Handle("DELETE", path, handle).
    func (group *RouterGroup) DELETE(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("DELETE", relativePath, handlers)
    }
    
    // PATCH is a shortcut for router.Handle("PATCH", path, handle).
    func (group *RouterGroup) PATCH(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("PATCH", relativePath, handlers)
    }
    
    // PUT is a shortcut for router.Handle("PUT", path, handle).
    func (group *RouterGroup) PUT(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("PUT", relativePath, handlers)
    }
    
    // OPTIONS is a shortcut for router.Handle("OPTIONS", path, handle).
    func (group *RouterGroup) OPTIONS(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("OPTIONS", relativePath, handlers)
    }
    
    // HEAD is a shortcut for router.Handle("HEAD", path, handle).
    func (group *RouterGroup) HEAD(relativePath string, handlers ...HandlerFunc) IRoutes {
        
    	return group.handle("HEAD", relativePath, handlers)
    }

## run() ##

使用go自己http包的ListenAndServe()方法启动监听并提供http请求服务.  
它会无限期阻塞调用协程除非错误发生.

// Run attaches the router to a http.Server and starts listening and serving HTTP requests.
    // It is a shortcut for http.ListenAndServe(addr, router)
    // Note: this method will block the calling goroutine indefinitely unless an error happens.
    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
    }

同时engine的ServeHttp方法()实现了http.Handler接口，故ListenAndServe()能直接使用engine作为了http处理器

// ServeHTTP conforms to the http.Handler interface.
    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)
    }

## 小结 ##

本文简单走读了一个gin的hello程序，大体上可以知道:  
1、Engine 是整个gin框架的实例;  
2、RouterGroup配置内部路由，其GET, POST, PUT, PATCH, HEAD, OPTIONS, DELETE接口会将路径对应的handler注册到Engine 字典树的trees中;  
3、Run()通过go自己的http框架接口启动服务;

[github.com_gin-gonic_gin]: http://github.com/gin-gonic/gin
[Alt text]: /images/20220127/a8e1f699e52b4fb181ef773974ccf31e.png
[Alt text 1]: /images/20220127/493cb032e22f4690916ba358ac5046bf.png
[go_httprouter_c]: https://blog.csdn.net/qq_17308321/article/details/89736691