深入浅出关于go web的请求路由

---

前言

最近重新接触Go语言以及对应框架，想借此机会深入下对应部分。
并分享一下最近学的过程很喜欢的一句话：

The limits of my language mean the limits of my world. by Ludwig Wittgenstein
我的语言之局限，即我的世界之局限。

---

一、是否一定要用框架来使用路由？

• 首先来介绍一下什么是路由。

路由是指确定请求应该由哪个处理程序处理的过程。在 Web 开发中，路由用于将请求映射到相应的处理程序或控制器。路由的种类通常包括以下几种：

• 静态路由： 静态路由是指将特定的 URL 路径映射到特定的处理程序或控制器的路由。这种路由是最基本的路由类型，通常用于处理固定的 URL 请求。例如一个简单的GET请求: /test/router
• 动态路由： 动态路由是指根据 URL 中的参数或模式进行匹配的路由。例如，可以使用动态路由来处理包含变量或参数的 URL 请求，以便根据请求的内容返回相应的结果。例如一个简单的GET请求: /test/:id

因为 Go 的 net/http 包提供了基础的路由函数组合与丰富的功能函数。所以在社区里流行一种用 Go 编写 API 不需要框架的观点，在我们看来，如果你的项目的路由在个位数、URI 固定且不通过 URI 来传递参数，那么确实使用官方库也就足够。

Go 的 Web 框架大致可以分为这么两类：

• Router 框架
• MVC 类框架

• 在框架的选择上，大多数情况下都是依照个人的喜好和公司的技术栈。例如公司有很多技术人员是 PHP 出身转go，那么他们一般会喜欢用 beego 这样的框架（典型的mvc架构），对于有些公司可能更喜欢轻量的框架那么则会使用gin，当然像字节这种内部则会去选择性能更高的kiteX作为web框架。
• 但如果公司有很多 C 程序员，那么他们的想法可能是越简单越好。比如很多大厂的 C 程序员甚至可能都会去用 C 语言去写很小的 CGI 程序，他们可能本身并没有什么意愿去学习 MVC 或者更复杂的 Web 框架，他们需要的只是一个非常简单的路由（甚至连路由都不需要，只需要一个基础的 HTTP 协议处理库来帮他省掉没什么意思的体力劳动）。
• 而对于一个简单的web服务利用官方库来编写也只需要短短的几行代码足矣：

package main
import (...)

func echo(wr http.ResponseWriter, r *http.Request) {
    msg, err := ioutil.ReadAll(r.Body)
    if err != nil {
        wr.Write([]byte("echo error"))
        return
    }

    writeLen, err := wr.Write(msg)
    if err != nil || writeLen != len(msg) {
        log.Println(err, "write len:", writeLen)
    }
}

func main() {
    http.HandleFunc("/", echo)
    err := http.ListenAndServe(":8080", nil)
    if err != nil {
        log.Fatal(err)
    }
}

这个例子是为了说明在 Go 中写一个 HTTP 协议的小程序有多么简单。如果你面临的情况比较复杂，例如几十个接口的企业级应用，直接用 net/http 库就显得不太合适了。
例如来看早期开源社区中一个 Kafka 监控项目Burrow中的做法：

func NewHttpServer(app *ApplicationContext) (*HttpServer, error) {
    ...
    server.mux.HandleFunc("/", handleDefault)

    server.mux.HandleFunc("/burrow/admin", handleAdmin)

    server.mux.Handle("/v2/kafka", appHandler{server.app, handleClusterList})
    server.mux.Handle("/v2/kafka/", appHandler{server.app, handleKafka})
    server.mux.Handle("/v2/zookeeper", appHandler{server.app, handleClusterList})
    ...
}

看上去很简短，但是我们再深入进去：

func handleKafka(app *ApplicationContext, w http.ResponseWriter, r *http.Request) (int, string) {
    pathParts := strings.Split(r.URL.Path[1:], "/")
    if _, ok := app.Config.Kafka[pathParts[2]]; !ok {
        return makeErrorResponse(http.StatusNotFound, "cluster not found", w, r)
    }
    if pathParts[2] == "" {
        // Allow a trailing / on requests
        return handleClusterList(app, w, r)
    }
    if (len(pathParts) == 3) || (pathParts[3] == "") {
        return handleClusterDetail(app, w, r, pathParts[2])
    }

    switch pathParts[3] {
    case "consumer":
        switch {
        case r.Method == "DELETE":
            switch {
            case (len(pathParts) == 5) || (pathParts[5] == ""):
                return handleConsumerDrop(app, w, r, pathParts[2], pathParts[4])
            default:
                return makeErrorResponse(http.StatusMethodNotAllowed, "request method not supported", w, r)
            }
        case r.Method == "GET":
            switch {
            case (len(pathParts) == 4) || (pathParts[4] == ""):
                return handleConsumerList(app, w, r, pathParts[2])
            case (len(pathParts) == 5) || (pathParts[5] == ""):
                // Consumer detail - list of consumer streams/hosts? Can be config info later
                return makeErrorResponse(http.StatusNotFound, "unknown API call", w, r)
            case pathParts[5] == "topic":
                switch {
                case (len(pathParts) == 6) || (pathParts[6] == ""):
                    return handleConsumerTopicList(app, w, r, pathParts[2], pathParts[4])
                case (len(pathParts) == 7) || (pathParts[7] == ""):
                    return handleConsumerTopicDetail(app, w, r, pathParts[2], pathParts[4], pathParts[6])
                }
            case pathParts[5] == "status":
                return handleConsumerStatus(app, w, r, pathParts[2], pathParts[4], false)
            case pathParts[5] == "lag":
                return handleConsumerStatus(app, w, r, pathParts[2], pathParts[4], true)
            }
        default:
            return makeErrorResponse(http.StatusMethodNotAllowed, "request method not supported", w, r)
        }
    case "topic":
        switch {
        case r.Method != "GET":
            return makeErrorResponse(http.StatusMethodNotAllowed, "request method not supported", w, r)
        case (len(pathParts) == 4) || (pathParts[4] == ""):
            return handleBrokerTopicList(app, w, r, pathParts[2])
        case (len(pathParts) == 5) || (pathParts[5] == ""):
            return handleBrokerTopicDetail(app, w, r, pathParts[2], pathParts[4])
        }
    case "offsets":
        // Reserving this endpoint to implement later
        return makeErrorResponse(http.StatusNotFound, "unknown API call", w, r)
    }

    // If we fell through, return a 404
    return makeErrorResponse(http.StatusNotFound, "unknown API call", w, r)
}

这会发现这其中的这个handler扩展的比较复杂，这个原因是因为默认的 net/http 包中的 mux 不支持带参数的路由，所以 Burrow 这个项目使用了非常蹩脚的字符串 Split 和乱七八糟的 switch case 来达到自己的目的，但却让本来应该很集中的路由管理逻辑变得复杂，散落在系统的各处，难以维护和管理。但如今Burrow项目的路由已经重构为使用httpRouter。感兴趣的小伙伴可以自己再去看看相关源码：Burrow

type Coordinator struct {
	// App is a pointer to the application context. This stores the channel to the storage subsystem
	App *protocol.ApplicationContext

	// Log is a logger that has been configured for this module to use. Normally, this means it has been set up with
	// fields that are appropriate to identify this coordinator
	Log *zap.Logger

	router  *httprouter.Router
	servers map[string]*http.Server
	theCert map[string]string
	theKey  map[string]string
}

包括如今的web框架的路由部分也是由httprouter改造而成的，后续也会继续深入讲下这部分。

---

二、httprouter

在常见的 Web 框架中，router 是必备的组件。Go 语言圈子里 router 也时常被称为 http 的 multiplexer。如果开发 Web 系统对路径中带参数没什么兴趣的话，用 http 标准库中的 mux 就可以。而对于最近新起的Restful的api设计风格则基本重度依赖路径参数：

GET /repos/:owner/:repo/comments/:id/reactions

POST /projects/:project_id/columns

PUT /user/starred/:owner/:repo

DELETE /user/starred/:owner/:repo

如果我们的系统也想要这样的 URI 设计，使用之前标准库的 mux 显然就力不从心了。而这时候一般就会使用之前提到的httprouter。

2.1 httprouter介绍

地址：
https://github.com/julienschmidt/httprouter
https://godoc.org/github.com/julienschmidt/httprouter

因为 httprouter 中使用的是显式匹配，所以在设计路由的时候需要规避一些会导致路由冲突的情况，例如：

#冲突的情况:
GET /user/info/:name
GET /user/:id

#不冲突的情况:
GET /user/info/:name
POST /user/:id

简单来讲的话，如果两个路由拥有一致的 http 方法 (指 GET、POST、PUT、DELETE) 和请求路径前缀，且在某个位置出现了 A 路由是 带动态的参数（/:id)，B 路由则是普通字符串，那么就会发生路由冲突。路由冲突会在初始化阶段直接 panic，如：

panic: wildcard route ':id' conflicts with existing children in path '/user/:id'

goroutine 1 [running]:
github.com/cch123/httprouter.(*node).insertChild(0xc4200801e0, 0xc42004fc01, 0x126b177, 0x3, 0x126b171, 0x9, 0x127b668)
  /Users/caochunhui/go_work/src/github.com/cch123/httprouter/tree.go:256 +0x841
github.com/cch123/httprouter.(*node).addRoute(0xc4200801e0, 0x126b171, 0x9, 0x127b668)
  /Users/caochunhui/go_work/src/github.com/cch123/httprouter/tree.go:221 +0x22a
github.com/cch123/httprouter.(*Router).Handle(0xc42004ff38, 0x126a39b, 0x3, 0x126b171, 0x9, 0x127b668)
  /Users/caochunhui/go_work/src/github.com/cch123/httprouter/router.go:262 +0xc3
github.com/cch123/httprouter.(*Router).GET(0xc42004ff38, 0x126b171, 0x9, 0x127b668)
  /Users/caochunhui/go_work/src/github.com/cch123/httprouter/router.go:193 +0x5e
main.main()
  /Users/caochunhui/test/go_web/httprouter_learn2.go:18 +0xaf
exit status 2

除支持路径中的 动态参数之外，httprouter 还可以支持 * 号来进行通配，不过 * 号开头的参数只能放在路由的结尾，例如下面这样：

Pattern: /src/*filepath
 /src/                     filepath = ""
 /src/somefile.go          filepath = "somefile.go"
 /src/subdir/somefile.go   filepath = "subdir/somefile.go"

而这种场景主要是为了： httprouter 来做简单的 HTTP 静态文件服务器。

除了正常情况下的路由支持，httprouter 也支持对一些特殊情况下的回调函数进行定制，例如 404 的时候：

r := httprouter.New()
r.NotFound = http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    w.Write([]byte("oh no, not found"))
})

或者内部 panic 的时候：

r := httprouter.New()
在r.PanicHandler = func(w http.ResponseWriter, r *http.Request, c interface{}) {
    log.Printf("Recovering from panic, Reason: %#v", c.(error))
    w.WriteHeader(http.StatusInternalServerError)
    w.Write([]byte(c.(error).Error()))
}

---

2.2 httprouter原理

httprouter的使用在一开始时会使用New进行注册。对应函数为：

func New() *Router {
	return &Router{
		RedirectTrailingSlash:  true,
		RedirectFixedPath:      true,
		HandleMethodNotAllowed: true,
		HandleOPTIONS:          true,
	}
}

这四个参数的分别的作用为：

• RedirectTrailingSlash： 指定是否重定向带有尾部斜杠的 URL。如果设置为 true，则当用户访问没有斜杠结尾的 URL 时，httprouter 会将其重定向到带有斜杠结尾的 URL。例如，将 “/path” 重定向到 “/path/”。
• RedirectFixedPath： 指定是否重定向固定路径。如果设置为 true，则当用户访问具有固定路径的 URL 时，httprouter 会将其重定向到正确的固定路径。这对于确保 URL 的一致性和规范性非常有用。
• HandleMethodNotAllowed： 指定是否处理不允许的 HTTP 方法。如果设置为 true，则当用户使用不允许的 HTTP 方法访问 URL 时，httprouter 会返回 “405 Method Not Allowed” 错误。
• HandleOPTIONS： 指定是否处理 OPTIONS 方法。如果设置为 true，则当用户使用 OPTIONS 方法访问 URL 时，httprouter 会返回允许的 HTTP 方法列表。

更详细的可以参考源码注释。
除此之外Router中还有一个很重要的字段：

type Router struct {
    // ...
    trees map[string]*node
    // ...
}

而这个字段则涉及到了底层的数据结构实现，阅读httprouter的源码注释可以简单知道：

Package httprouter is a trie based high performance HTTP request router.

• 因此httprouter的底层是用压缩字典树实现的，属于字典树的一个变种，在继续介绍这块之前简单做一个知识的补充：

• 字典树即前缀树（Trie树），又称单词查找树或键树，是一种树形结构，是一种哈希树的变种。典型应用是用于统计和排序大量的字符串（但不仅限于字符串），所以经常被搜索引擎系统用于文本词频统计。
  它的优点是： 利用字符串的公共前缀来减少查询时间，最大限度地减少无谓的字符串比较。
  以下是一颗字典树的生成，分别插入app、apple、abcd、user、use、job。

• 而压缩字典树（Radix)也很好理解，因为字典树的节点粒度是以一个字母，而像路由这种有规律的字符串完全可以把节点粒度加粗，减少了不必要的节点层级减少存储空间压缩字符，并且由于深度的降低，搜索的速度也会相对应的加快。例如做成如下这种形式：：
  
  因此上述的Map其实存放的key 即为 HTTP 1.1 的 RFC 中定义的各种方法，而node则为各个方法下的root节点。

  GET、HEAD、OPTIONS、POST、PUT、PATCH、DELETE
  

因此每一种方法对应的都是一棵独立的压缩字典树，这些树彼此之间不共享数据。

• 对于node结构体：

type node struct {
	path      string 
	indices   string
	wildChild bool     
	nType     nodeType
	priority  uint32
	children  []*node
	handle    Handle
}

参数分别代表的意思：

• path： 表示当前节点对应的路径中的字符串。例如，如果节点对应的路径是 “/user/:id”，那么 path 字段的值就是 “:id”。

• indices： 一个字符串，用于快速查找子节点。它包含了当前节点的所有子节点的第一个字符。为了加快路由匹配的速度。

• wildChild： 一个布尔值，表示子节点是否为参数节点，即 wildcard node，或者说像 “:id” 这种类型的节点。如果子节点是参数节点，则 wildChild 为 true，否则为 false。

• nType： 表示节点的类型，是一个枚举类型。它可以表示静态节点、参数节点或通配符节点等不同类型的节点。

• priority： 一个无符号整数，用于确定节点的优先级。这有助于在路由匹配时确定最佳匹配项。

• children： 一个指向子节点的指针数组。它包含了当前节点的所有子节点。

• handle： 表示与当前节点关联的处理函数（handler）。当路由匹配到当前节点时，将调用与之关联的处理函数来处理请求。

• 对于nodeType:

const (
	static   nodeType = iota // 非根节点的普通字符串节点
	root                     // 根节点
	param                    // 参数节点 如：id
	catchAll                 // 通配符节点 如：*anyway
)

而对于添加一个路由的过程基本在源码tree.go的addRoute的func中。大概得过程补充在注释中：

// 增加路由并且配置节点handle，因为中间的变量没有加锁，所以不保证并发安全，如children之间的优先级
func (n *node) addRoute(path string, handle Handle) {
	fullPath := path
	n.priority++

	// 空树的情况下插入一个root节点
	if n.path == "" && n.indices == "" {
		n.insertChild(path, fullPath, handle)
		n.nType = root
		return
	}

walk:
	for {
		// 找到最长的公共前缀。
		// 并且公共前缀中不会包含 no ':' or '*'，因为公共前缀key不能包含这两个字符，遇到了则直接continue
		i := longestCommonPrefix(path, n.path)

		// 如果最长公共前缀小于 path 的长度，那么说明 path 无法与当前节点路径匹配，需要进行边的分裂
		// 例如：n 的路径是 "/user/profile"，而当前需要插入的路径是 "/user/posts"
		if i < len(n.path) {
			child := node{
				path:      n.path[i:],
				wildChild: n.wildChild,
				nType:     static,
				indices:   n.indices,
				children:  n.children,
				handle:    n.handle,
				priority:  n.priority - 1,
			}

			n.children = []*node{&child}
			// []byte for proper unicode char conversion, see #65
			n.indices = string([]byte{n.path[i]})
			n.path = path[:i]
			n.handle = nil
			n.wildChild = false
		}

		// 处理剩下非公共前缀的部分
		if i < len(path) {
			path = path[i:]

			// 如果当前节点有通配符（wildChild），则会检查通配符是否匹配，如果匹配则继续向下匹配，否则会出现通配符冲突的情况，并抛出异常。
			if n.wildChild {
				n = n.children[0]
				n.priority++

				// Check if the wildcard matches
				if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
					// Adding a child to a catchAll is not possible
					n.nType != catchAll &&
					// Check for longer wildcard, e.g. :name and :names
					(len(n.path) >= len(path) || path[len(n.path)] == '/') {
					continue walk
				} else {
					// Wildcard conflict
					pathSeg := path
					if n.nType != catchAll {
						pathSeg = strings.SplitN(pathSeg, "/", 2)[0]
					}
					prefix := fullPath[:strings.Index(fullPath, pathSeg)] + n.path
					panic("'" + pathSeg +
						"' in new path '" + fullPath +
						"' conflicts with existing wildcard '" + n.path +
						"' in existing prefix '" + prefix +
						"'")
				}
			}

			idxc := path[0]

			// 如果当前节点是参数类型（param）并且路径中的下一个字符是 '/'，并且当前节点只有一个子节点，则会继续向下匹配。
			if n.nType == param && idxc == '/' && len(n.children) == 1 {
				n = n.children[0]
				n.priority++
				continue walk
			}

			// 检查是否存在与路径中的下一个字符相匹配的子节点，如果有则继续向下匹配，否则会插入新的子节点来处理剩余的路径部分。
			for i, c := range []byte(n.indices) {
				if c == idxc {
					i = n.incrementChildPrio(i)
					n = n.children[i]
					continue walk
				}
			}

			if idxc != ':' && idxc != '*' {
				// []byte for proper unicode char conversion, see #65
				n.indices += string([]byte{idxc})
				child := &node{}
				n.children = append(n.children, child)
				n.incrementChildPrio(len(n.indices) - 1)
				n = child
			}
			n.insertChild(path, fullPath, handle)
			return
		}

		// Otherwise add handle to current node
		if n.handle != nil {
			panic("a handle is already registered for path '" + fullPath + "'")
		}
		n.handle = handle
		return
	}
}

接下来以一个实际的案例,创建6个路由：

func Index(w http.ResponseWriter, r *http.Request, _ httprouter.Params) {
	fmt.Fprint(w, "Welcome!\n")
}

func Hello(w http.ResponseWriter, r *http.Request, ps httprouter.Params) {
	fmt.Fprintf(w, "hello, %s!\n", ps.ByName("name"))
}

func main() {
	router := httprouter.New()
	router.PUT("/hello/:name", Hello)
	router.GET("/test/router/", Hello)
	router.GET("/test/router/:name/branchA", Hello)
	router.GET("/test/router/:name/branchB", Hello)
	router.GET("status", Hello)
	router.GET("searcher", Hello)

	log.Fatal(http.ListenAndServe(":8080", router))
}

• 插入 “/hello/:name”
  

• 插入 “/test/router/”
  

• 插入 “/test/router/:name/branchA”
  

• 插入 “/test/router/:name/branchB”,此时由于/banch的孩子节点个数大于1，所以indices字段有作用，此时为两个孩子节点path的首字母
  

• 插入 “/status”
  

• 插入 “searcher”
  

也因为底层数据结构的原因，所以为了不让树的深度过深，在初始化时会对参数的数量进行限制，所以在路由中的参数数目不能超过 255，否则会导致 httprouter 无法识别后续的参数。

2.3 路由冲突情况

所以路由本身只有字符串的情况下，不会发生任何冲突。只有当路由中含有 wildcard（类似 :id）或者 catchAll 的情况下才可能冲突。这在2.1中也提到过。

而子节点的冲突处理很简单，分几种情况：

• 在插入 wildcard 节点时，父节点的 children 数组非空且 wildChild 被设置为 false。

例如：GET /user/getAll 和 GET /user/:id/getAddr，或者 GET /user/*aaa 和 GET /user/:id。

• 在插入 wildcard 节点时，父节点的 children 数组非空且 wildChild 被设置为 true，但该父节点的 wildcard 子节点要插入的 wildcard 名字不一样。

例如：GET /user/:id/info 和 GET /user/:name/info。

• 在插入 catchAll 节点时，父节点的 children 非空。

例如：GET /src/abc 和 GET /src/*filename，或者 GET /src/:id 和 GET /src/*filename。

• 在插入 static 节点时，父节点的 wildChild 字段被设置为 true。
• 在插入 static 节点时，父节点的 children 非空，且子节点 nType 为 catchAll。

---

三、gin中的路由

之前提到过现在Star数最高的web框架gin中的router中的很多核心实现很多基于httprouter中的，具体的可以去gin项目中的tree.go文件看对应部分，这里主要讲一下gin的路由除此之外额外实现了什么。

gin项目地址链接

在gin进行初始化的时候，可以看到初始化的路由时它其实是初始化了一个路由组,而使用router对应的GET\PUT等方法时则是复用了这个默认的路由组，这里已经略过不相干代码。

r := gin.Default()

func Default() *Engine {
	...
	engine := New()
	...
}


func New() *Engine {
	...
	engine := &Engine{
		RouterGroup: RouterGroup{
			Handlers: nil,
			basePath: "/",
			root:     true,
		},
		...
	...
}

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

因此可以看出gin在底层实现上比普通的httprouter多出了一个路由组的概念。这个路由组的作用主要能对api进行分组授权。例如正常的业务逻辑很多需要登录授权，有的接口需要这个鉴权，有些则可以不用，这个时候就可以利用路由组的概念的去进行分组。

• 这里用一个最简单的例子去使用：

// 创建路由组
authorized := r.Group("/admin",func(c *gin.Context) {
		// 在此处编写验证用户权限的逻辑
		// 如果用户未经授权，则可以使用 c.Abort() 中止请求并返回相应的错误信息
	})

// 在路由组上添加需要授权的路径
authorized.GET("/dashboard", dashboardHandler)
authorized.POST("/settings", settingsHandler)

当然group源码中也可以传入一连串的handlers去进行前置的处理业务逻辑。

// Group creates a new router group. You should add all the routes that have common middlewares or the same path prefix.
// For example, all the routes that use a common middleware for authorization could be grouped.
func (group *RouterGroup) Group(relativePath string, handlers ...HandlerFunc) *RouterGroup {
	return &RouterGroup{
		Handlers: group.combineHandlers(handlers),
		basePath: group.calculateAbsolutePath(relativePath),
		engine:   group.engine,
	}
}

对于正常的使用一个
而这个RouterGroup正如注释提到的RouterGroup is used internally to configure router，只是配置对应的路由，对应真正的路由树的结构还是在对应的engine的trees中的。与我们之前看的httprouter差不多

type methodTrees []methodTree

func New() *Engine {
	...
	trees            methodTrees
	...
}

所以总的来说，RouterGroup与Engine的关系是这样

因此不管通过Engine实例对象可以创建多个routergroup，然后创建出来的routergroup都会再重新绑定上engine，而借助结构体的正交性组合的特点，新构建出来的组的路由组还可以继续使用engine继续创造新的路由组，而不管横向创造多少个，或者纵向创建多少个，改变的始终是唯一那个engine的路由树。而纵向创建group这种方式，则是gin中创建嵌套路由的使用方式。

package main

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

func main() {
	router := gin.Default()

	// 创建父级路由组
	v1 := router.Group("/v1")
	{
		// 在父级路由组中创建子级路由组
		users := v1.Group("/users")
		{
			// 子级路由组中的路由
			users.GET("/", func(c *gin.Context) {
				c.JSON(200, gin.H{"message": "Get all users"})
			})
			users.POST("/", func(c *gin.Context) {
				c.JSON(200, gin.H{"message": "Create a new user"})
			})
		}
	}

	router.Run(":8080")
}

总结

重新接触go，看了些书并深入学习了下组件/框架源码，还是和几年前写6.824时只是使用go理解有些不同，特别是刚从熟悉的java转过来，也去看了些对应的方面，觉得go这种静态类型的语言还是有很多可以学习的地方，也写了些对应的笔记(后续有时间再结合起来发…)，这次看gin的框架时也更加的体会到关于go函数式编程的魅力。后续大概还会继续深入看gin的框架源码，然后希望能坚持到看完hertz。
如有不足，欢迎指正~