Golang Web入門（2）：如何實現一個高效能的路由

紅雞菌發表於2020-04-19
GolangWeb路由

摘要

在上一篇文章中，我們聊了聊在Golang中怎麼實現一個Http伺服器。但是在最後我們可以發現，固然DefaultServeMux可以做路由分發的功能，但是他的功能同樣是不完善的。

由DefaultServeMux做路由分發，是不能實現RESTful風格的API的，我們沒有辦法定義請求所需的方法，也沒有辦法在API路徑中加入query引數。其次，我們也希望可以讓路由查詢的效率更高。

所以在這篇文章中，我們將分析httprouter這個包，從原始碼的層面研究他是如何實現我們上面提到的那些功能。並且，對於這個包中最重要的字首樹，本文將以圖文結合的方式來解釋。

1 使用

我們同樣以怎麼使用作為開始，自頂向下的去研究httprouter。我們先來看看官方文件中的小例子：

package main

import (
    "fmt"
    "net/http"
    "log"

    "github.com/julienschmidt/httprouter"
)

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.GET("/", Index)
    router.GET("/hello/:name", Hello)

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

其實我們可以發現，這裡的做法和使用Golang自帶的net/http包的做法是差不多的。都是先註冊相應的URI和函式，換一句話來說就是將路由和處理器相匹配。

在註冊的時候，使用router.XXX方法，來註冊相對應的方法，比如GET，POST等等。

註冊完之後，使用http.ListenAndServe開始監聽。

至於為什麼，我們會在後面的章節詳細介紹，現在只需要先了解做法即可。

2 建立

我們先來看看第一行程式碼，我們定義並宣告瞭一個Router。下面來看看這個Router的結構，這裡把與本文無關的其他屬性省略：

type Router struct {
	//這是字首樹，記錄了相應的路由
	trees map[string]*node
	
	//記錄了引數的最大數目
	maxParams  uint16

}

在建立了這個Router的結構後，我們就使用router.XXX方法來註冊路由了。繼續看看路由是怎麼註冊的：

func (r *Router) GET(path string, handle Handle) {
	r.Handle(http.MethodGet, path, handle)
}

func (r *Router) POST(path string, handle Handle) {
	r.Handle(http.MethodPost, path, handle)
}

...

在這裡還有一長串的方法，他們都是一樣的，呼叫了

r.Handle(http.MethodPost, path, handle)

這個方法。我們再來看看：

func (r *Router) Handle(method, path string, handle Handle) {
	...
	if r.trees == nil {
		r.trees = make(map[string]*node)
	}

	root := r.trees[method]
	if root == nil {
		root = new(node)
		r.trees[method] = root

		r.globalAllowed = r.allowed("*", "")
	}

	root.addRoute(path, handle)
	...
}

在這個方法裡，同樣省略了很多細節。我們只關注一下與本文有關的。我們可以看到，在這個方法中，如果tree還沒有初始化，則先初始化這顆字首樹。

然後我們注意到，這顆樹是一個map結構。也就是說，一個方法，對應了一顆樹。然後，對應這棵樹，呼叫addRoute方法，把URI和對應的Handle儲存進去。

3 字首樹

3.1 定義

又稱單詞查詢樹，Trie樹，是一種樹形結構，是一種雜湊樹的變種。典型應用是用於統計，排序和儲存大量的字串（但不僅限於字串），所以經常被搜尋引擎系統用於文字詞頻統計。它的優點是：利用字串的公共字首來減少查詢時間，最大限度地減少無謂的字串比較，查詢效率比雜湊樹高。

簡單的來講，就是要查詢什麼，只要跟著這棵樹的某一條路徑找，就可以找得到。

比如在搜尋引擎中，你輸入了一個蔡：

他會有這些聯想，也可以理解為是一個字首樹。

再舉個例子：

在這顆GET方法的字首樹中，包含了以下的路由：

  • /wow/awesome
  • /test
  • /hello/world
  • /hello/china
  • /hello/chinese

說到這裡你應該可以理解了，在構建這棵樹的過程中，任何兩個節點，只要有了相同的字首，相同的部分就會被合併成一個節點。

3.2 圖解構建

上面說的addRoute方法，就是這顆字首樹的插入方法。假設現在數為空，在這裡我打算以圖解的方式來說明這棵樹的構建。

假設我們需要插入的三個路由分別為：

  • /hello/world
  • /hello/china
  • /hello/chinese

（1）插入/hello/world

因為此時樹為空，所以可以直接插入：

(2)插入/hello/china

此時，發現/hello/world和/hello/china有相同的字首/hello/。

那麼要先將原來的/hello/world結點，拆分出來，然後將要插入的結點/hello/china，截去相同部分，作為/hello/world的子節點。

(3)插入/hello/chinese

此時，我們需要插入/hello/chinese，但是發現，/hello/chinese和結點/hello/有公共的字首/hello/，所以我們去檢視/hello/這個結點的子節點。

注意，在結點中有一個屬性，叫indices。它記錄了這個結點的子節點的首字母，便於我們查詢。比如這個/hello/結點，他的indices值為wc。而我們要插入的結點是/hello/chinese，除去公共字首後，chinese的第一個字母也是c，所以我們進入china這個結點。

這時，有沒有發現，情況回到了我們一開始插入/hello/china時候的局面。那個時候公共字首是/hello/，現在的公共字首是chin。

所以，我們同樣把chin截出來，作為一個結點，將a作為這個結點的子節點。並且，同樣把ese也作為子節點。

3.3 總結構建演算法

到這裡，構建就已經結束了。我們來總結一下演算法。

具體帶註釋的程式碼將在本文最末尾給出，如果想要了解的更深可以自行檢視。在這裡先理解這個過程：

（1）如果樹為空，則直接插入
（2）否則，查詢當前的結點是否與要插入的URI有公共字首
（3）如果沒有公共字首，則直接插入
（4）如果有公共字首，則判斷是否需要分裂當前的結點
（5）如果需要分裂，則將公共部分作為父節點，其餘的作為子節點
（6）如果不需要分裂，則尋找有無字首相同的子節點
（7）如果有字首相同的，則跳到(4)
（8）如果沒有字首相同的，直接插入
（9）在最後的結點，放入這條路由對應的Handle

但是到了這裡，有同學要問了：怎麼這裡的路由，不帶引數的呀？

其實只要你理解了上面的過程，帶引數也是一樣的。邏輯是這樣的：在每次插入之前，會掃描當前要插入的結點的path是否帶有引數（即掃描有沒有/或者*）。如果帶有引數的話，將當前結點的wildChild屬性設定為true，然後將引數部分，設定為一個新的子節點。

4 監聽

在講完了路由的註冊，我們來聊聊路由的監聽。

在上一篇文章的內容中，我們有提到這個：

type serverHandler struct {
	srv *Server
}

func (sh serverHandler) ServeHTTP(rw ResponseWriter, req *Request) {
	handler := sh.srv.Handler
	if handler == nil {
		handler = DefaultServeMux
	}
	if req.RequestURI == "*" && req.Method == "OPTIONS" {
		handler = globalOptionsHandler{}
	}
	handler.ServeHTTP(rw, req)
}

當時我們提到，如果我們不傳入任何的Handle方法，Golang將使用預設的DefaultServeMux方法來處理請求。而現在我們傳入了router，所以將會使用router來處理請求。

因此，router也是實現了ServeHTTP方法的。我們來看看（同樣省略了一些步驟）：

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	...
	path := req.URL.Path

	if root := r.trees[req.Method]; root != nil {
		if handle, ps, tsr := root.getValue(path, r.getParams); handle != nil {
			if ps != nil {
				handle(w, req, *ps)
				r.putParams(ps)
			} else {
				handle(w, req, nil)
			}
			return
		} 
	}
    ...
    // Handle 404
	if r.NotFound != nil {
		r.NotFound.ServeHTTP(w, req)
	} else {
		http.NotFound(w, req)
	}
}

在這裡，我們選擇請求方法所對應的字首樹，呼叫了getValue方法。

簡單解釋一下這個方法：在這個方法中會不斷的去匹配當前路徑與結點中的path，直到找到最後找到這個路由對應的Handle方法。

注意，在這期間，如果路由是RESTful風格的，在路由中含有引數，將會被儲存在Param中，這裡的Param結構如下：

type Param struct {
	Key   string
	Value string
}

如果未找到相對應的路由，則呼叫後面的404方法。

5 處理

到了這一步，其實和以前的內容幾乎一樣了。

在獲取了該路由對應的Handle之後，呼叫這個函式。

唯一和之前使用net/http包中的Handler不一樣的是，這裡的Handle，封裝了從API中獲取的引數。

type Handle func(http.ResponseWriter, *http.Request, Params)

6 寫在最後

謝謝你能看到這裡~

至此，httprouter介紹完畢，最關鍵的也就是字首樹的構建了。在上面我用圖文結合的方式，模擬了一次字首樹的構建過程，希望可以讓你理解字首樹是怎麼回事。當然，如果還有疑問，也可以留言或者在微信中與我交流~

當然，如果你不滿足於此，可以看看後面的附錄，有字首樹的全程式碼註釋。

當然了，作者也是剛入門。所以，可能會有很多的疏漏。如果在閱讀的過程中，有哪些解釋不到位，或者理解出現了偏差，也請你留言指正。

再次感謝~

PS：如果有其他的問題，也可以在公眾號找到作者。並且，所有文章第一時間會在公眾號更新，歡迎來找作者玩~

7 原始碼閱讀

7.1 樹的結構

type node struct {
	
	path      string    //當前結點的URI
	indices   string    //子結點的首字母
	wildChild bool      //子節點是否為引數結點
	nType     nodeType  //結點型別
	priority  uint32    //權重
	children  []*node   //子節點
	handle    Handle    //處理器
}

7.2 addRoute

func (n *node) addRoute(path string, handle Handle) {

	fullPath := path
	n.priority++

	// 如果這是個空樹，那麼直接插入
	if len(n.path) == 0 && len(n.indices) == 0 {

		//這個方法其實是在n這個結點插入path，但是會處理引數
		//詳細實現在後文會給出
		n.insertChild(path, fullPath, handle)
		n.nType = root
		return
	}

	//設定一個flag
walk:
	for {
		// 找到當前結點path和要插入的path中最長的字首
		// i為第一位不相同的下標
		i := longestCommonPrefix(path, n.path)

		// 此時相同的部分比這個結點記錄的path短
		// 也就是說需要把當前的結點分裂開
		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}
			// 把這個結點的首字母加入indices中
			// 目的是查詢更快
			n.indices = string([]byte{n.path[i]})
			n.path = path[:i]
			n.handle = nil
			n.wildChild = false
		}

		// 此時相同的部分只佔了新URI的一部分
		// 所以把path後面不相同的部分要設定成一個新的結點
		if i < len(path) {
			path = path[i:]

			// 此時如果n的子節點是帶引數的
			if n.wildChild {
				n = n.children[0]
				n.priority++

				// 判斷是否會不合法
				if len(path) >= len(n.path) && n.path == path[:len(n.path)] &&
					n.nType != catchAll &&
					(len(n.path) >= len(path) || path[len(n.path)] == '/') {
					continue walk
				} else {
					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 +
						"'")
				}
			}

			// 把擷取的path的第一位記錄下來
			idxc := path[0]

			// 如果此時n的子節點是帶引數的
			if n.nType == param && idxc == '/' && len(n.children) == 1 {
				n = n.children[0]
				n.priority++
				continue walk
			}

			// 這一步是檢查拆分出的path，是否應該被合併入子節點中
			// 具體例子可看上文中的圖解
			// 如果是這樣的話，把這個子節點設定為n，然後開始一輪新的迴圈
			for i, c := range []byte(n.indices) {
				if c == idxc {
					// 這一部分是為了把權重更高的首字元調整到前面
					i = n.incrementChildPrio(i)
					n = n.children[i]
					continue walk
				}
			}

			// 如果這個結點不用被合併
			if idxc != ':' && idxc != '*' {
				// 把這個結點的首字母也加入n的indices中
				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
		}

		// 直接插入到當前的結點
		if n.handle != nil {
			panic("a handle is already registered for path '" + fullPath + "'")
		}
		n.handle = handle
		return
	}
}

7.3 insertChild

func (n *node) insertChild(path, fullPath string, handle Handle) {
	for {
		// 這個方法是用來找這個path是否含有引數的
		wildcard, i, valid := findWildcard(path)
		// 如果不含引數，直接跳出迴圈，看最後兩行
		if i < 0 {
			break
		}

		// 條件校驗
		if !valid {
			panic("only one wildcard per path segment is allowed, has: '" +
				wildcard + "' in path '" + fullPath + "'")
		}

		// 同樣判斷是否合法
		if len(wildcard) < 2 {
			panic("wildcards must be named with a non-empty name in path '" + fullPath + "'")
		}

		if len(n.children) > 0 {
			panic("wildcard segment '" + wildcard +
				"' conflicts with existing children in path '" + fullPath + "'")
		}

		// 如果引數的第一位是`:`，則說明這是一個引數型別
		if wildcard[0] == ':' {
			if i > 0 {
				// 把當前的path設定為引數之前的那部分
				n.path = path[:i]
				// 準備把引數後面的部分作為一個新的結點
				path = path[i:]
			}

			//然後把引數部分作為新的結點
			n.wildChild = true
			child := &node{
				nType: param,
				path:  wildcard,
			}
			n.children = []*node{child}
			n = child
			n.priority++

			// 這裡的意思是，path在引數後面還沒有結束
			if len(wildcard) < len(path) {
				// 把引數後面那部分再分出一個結點，continue繼續處理
				path = path[len(wildcard):]
				child := &node{
					priority: 1,
				}
				n.children = []*node{child}
				n = child
				continue
			}

			// 把處理器設定進去
			n.handle = handle
			return

		} else { // 另外一種情況
			if i+len(wildcard) != len(path) {
				panic("catch-all routes are only allowed at the end of the path in path '" + fullPath + "'")
			}

			if len(n.path) > 0 && n.path[len(n.path)-1] == '/' {
				panic("catch-all conflicts with existing handle for the path segment root in path '" + fullPath + "'")
			}

			// 判斷在這之前有沒有一個/
			i--
			if path[i] != '/' {
				panic("no / before catch-all in path '" + fullPath + "'")
			}

			n.path = path[:i]

			// 設定一個catchAll型別的子節點
			child := &node{
				wildChild: true,
				nType:     catchAll,
			}
			n.children = []*node{child}
			n.indices = string('/')
			n = child
			n.priority++

			// 把後面的引數部分設定為新節點
			child = &node{
				path:     path[i:],
				nType:    catchAll,
				handle:   handle,
				priority: 1,
			}
			n.children = []*node{child}

			return
		}
	}

	// 對應最開頭的部分，如果這個path裡面沒有引數，直接設定
	n.path = path
	n.handle = handle
}

最關鍵的幾個方法到這裡就全部結束啦，先給看到這裡的你鼓個掌！

這一部分理解會比較難，可能需要多看幾遍。

如果還是有難以理解的地方，歡迎留言交流，或者直接來公眾號找我~

相關文章