Gee教程3.实现前缀树路由

需要完成的目标

• 使用 Trie 树实现动态路由(dynamic route)解析。
• 支持两种模式:name和*filepath，(开头带有':'或者'*')

 这里前缀树的实现修复了Go语言动手写Web框架 - Gee第三天 前缀树路由Router | 极客兔兔​​​​​​  中路由冲突的bug。

 Trie树简介

 之前，我们用了一个非常简单的map结构存储了路由表，使用map存储键值对，索引非常高效，但是有一个弊端，键值对的存储的方式，只能用来索引静态路由。

如果我们想支持类似于/hello/:name这样的动态路由怎么办呢？所谓动态路由，即一条路由规则可以匹配某一类型而非某一条固定的路由。例如/hello/:name，可以匹配/hello/abc、hello/jack等。

实现动态路由最常用的数据结构，被称为前缀树(Trie树)。看到名字你大概也能知道前缀树长啥样了：每一个节点的所有的子节点都拥有相同的前缀。这种结构非常适用于路由匹配。

所有路由按照请求 method 分成对应的 method 树，然后将请求根据 `/` 拆封后，组装成树形结构。

接下来我们实现的动态路由具备以下两个功能。

• 参数匹配:。例如 /p/:lang/doc，可以匹配 /p/c/doc 和 /p/go/doc。
• 通配*。例如 /static/*filepath，可以匹配/static/fav.ico，也可以匹配/static/js/jQuery.js，这种模式常用于静态服务器，能够递归地匹配子路径。

Trie树实现

 力扣上有前缀树的题目实现 Trie (前缀树)，若不懂前缀树的，可以前去查看了解。

首先是需要设置树节点上要存储的信息

节点结构

type node struct {
	path     string           //路由路径 例如 /aa.com/home
	part     string           //路由中由'/'分隔的部分
	children []*node //子节点
	isWild   bool             //是否是通配符节点，是为true
}

与普通树的不同，为了实现动态路由匹配，加上了isWild这个参数。即是当我们匹配 /a/b/c/这个路径时。假如当前有个节点的path是 /a/:name,这时候a精准匹配到了a,b模糊匹配到了:name,那么会将name这个参数赋值为b，继续下一层的匹配。

那么前缀树的操作基本是插入和查找

那么讲解前需要了解下这一节的路由router结构

type router struct {
	handers map[string]HandlerFunc
	root    map[string]*node //key是GET，POST等请求方法
}

插入

那就要和router.go文件中的插入操作一起来讲解。

该插入的实现与极客兔兔的教程会有所不同。

举个例子：要插入GET方法的/user/info/a。要结合开头的前缀树那图片来想象。

1.先判断该路由中是否有GET方法的树，若是没有就需要创建该树，即是创建一个头结点。

2.接着调用parsePath函数，这个函数就是把/user/info/a组成一个切片,切片有三个元素

[]string{"user","info","a"}

 之后就调用节点的插入方法insert。

一层一层往下插入数据。

parts中第一个是user,当前的children[part]是空，所以需要新建一个结点。之后就cur = cur.children[part]，这样就可以一层一层往下走。

到最后就是把path赋值给当前结点的路径。

//在router.go文件中
func (r *router) addRoute(method string, path string, handler HandlerFunc) {
	// r.handers[key] = handler

	if _, ok := r.root[method]; !ok {
		r.root[method] = &node{}
	}

	parts := parsePath(path)
	r.root[method].insert(path, parts)

	key := method + "-" + path
	r.handers[key] = handler
}

//在trie.go文件中
func (n *node) insert(path string, parts []string) {
	tmpNode := n
	for _, part := range parts {
		var tmp *node
		for _, child := range tmpNode.children { //一个for循环就是一层，一层一层查找
			if child.part == part {
				tmp = child
				break
			}
		}
        //表示没有找到该节点，需要创建新节点
		if tmp == nil {
			tmp = &node{
				part:   part,
				isWild: part[0] == ':' || part[0] == '*',
			}
			tmpNode.children = append(tmpNode.children, tmp)
		}
		tmpNode = tmp
	}
	tmpNode.path = path
}

//在router.go文件中
func parsePath(path string) (parts []string) {
	par := strings.Split(path, "/")
	for _, p := range par {
		if p != "" {
			parts = append(parts, p)
			//如果p是以通配符*开头的
			if p[0] == '*' {
				break
			}
		}
	}
	return
}

查找

 先看getRoute方法，要是没有对应的方法树，直接返回空即可。

接着调用parsePath函数。最后调用前缀树的search方法。

search方法是递归查找的。

有一点需要注意，例如：/user/:id/a只有在第三层节点，即a节点，path才会设置为/user/:id/a。user和:id节点的path属性皆为空。

因此，当匹配结束时，我们可以使用n.path == ""来判断路由规则是否匹配成功。

例如，/user/th虽能成功匹配到/user/:id，但/user/:id的path值为空，因此匹配失败。查询功能，同样也是递归查询每一层的节点，退出规则是，匹配到了*，匹配失败，或者匹配到了第len(parts)层节点。

matchChildren有点重要，可以对比下和极客兔兔教程的matchChildren函数有何不同。

//在router.go文件中
func (r *router) getRoute(method, path string) (*node, map[string]string) {
	root, ok := r.roots[method]
	if !ok {
		return nil, nil
	}
	searchParts := parsePath(path)

	n := root.search(searchParts, 0)
	if n == nil {
		return nil, nil
	}
	params := make(map[string]string)
	parts := parsePath(n.path)
	for i, part := range parts {
        //这些操作是为了可以找到动态路由的参数
        //例如添加了路由 /user/:id/a，
        //那用户使用/user/my/a来访问的时候，其参数id就是my
		if part[0] == ':' {
			params[part[1:]] = searchParts[i]
		}
		if part[0] == '*' && len(part) > 1 {
			params[part[1:]] = strings.Join(searchParts[i:], "/")
			break
		}
	}
	return n, params
}

//在trie.go文件中
func (n *node) search(searchParts []string, height int) *node {
	if len(searchParts) == height || strings.HasPrefix(n.part, "*") {
		if n.path == "" {
			return nil
		}
		return n
	}

	part := searchParts[height]
	childern := n.matchChildren(part)

	for _, child := range childern {
		result := child.search(searchParts, height+1)
		if result != nil {
			return result
		}
	}

	return nil
}

func (n *node) matchChildren(part string) (result []*node) {
	nodes := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part {
			result = append(result, child)
		} else if child.isWild {
			nodes = append(nodes, child)
		}
	}
	return append(result, nodes...)
}

Router

 前缀树的算法实现后，接下来就需要把该树应用到路由中。我们使用root来存储每中请求方法的前缀树根结点。使用hander来存储每种请求方式的处理方法HandlerFunc。

代码也在Trie实现中讲解了。

getRoute 函数中，解析了:和*两种匹配符的参数，返回一个 map 。例如前缀树有/p/:lang/doc和/static/*filepath。

路径/p/go/doc匹配到/p/:lang/doc，解析结果为：{lang: "go"};路径/static/css/geektutu.css匹配到/static/*filepath，解析结果为{filepath: "css/geektutu.css"}。

这个匹配就是通过getRoute函数中for range获取的。

Contex和Router.handle的变化

 Context有了些许变化。在 HandlerFunc 中，希望能够访问到解析的参数，因此，需要对 Context 对象增加一个属性和方法，来提供对路由参数的访问。我们将解析后的参数存储到Params中，通过c.Param("lang")的方式获取到对应的值。

type Context struct {
	Wrtier http.ResponseWriter
	Req    *http.Request

	Path   string
	Method string
	Params map[string]string      //新添加的
	//响应的状态码
	StatusCode int
}

func (c *Context) Param(key string) string {
	value, _ := c.Params[key]
	return value
}

Router.handle方法

 在调用匹配到的handler前，将解析出来的路由参数赋值给了c.Params。这样就能够在handler中，通过Context对象访问到具体的值了。

func (r *router) handle(c *Context) {
	n, params := r.getRoute(c.Method, c.Path)
	if n != nil {
		c.Params = params
		//key := c.Method + "-" + c.Path 这样写是错误的，是要+n.path
		key := c.Method + "-" + n.path
		r.handers[key](c)
	} else {
		c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	}

    //上一节的实现
	// key := c.Method + "-" + c.Path
	// if hander, ok := r.handers[key]; ok {
	// 	hander(c)
	// } else {
	// 	c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	// }
}

 修复的路由冲突BUG

主要是对比极客兔兔的教程，这节的路由有两部分不同。

一在node的insert函数中，这里只是判别child.part == part，没有判别child.isWild==true。

这样当出现要先后插入/:name,/16时候，/:name是没有的，那就是直接创建插入。

而到插入/16时候，若是也判别child.isWild==true的话，这时是true的，那么就不会创建part是16的结点。所以不进行判断child.isWild==true，只判断child.part是否等于所给的part,这样就可以创建part是16的结点。

二是在node的matchChildren函数中。

还是/:name,/16的例子，这时用户通过/16来访问，那肯定是想返回/16对应的处理函数。假如matchChildren返回的[]*node第一个元素:name,那么这个是符合条件的，那就会执行:name对应的处理函数了。

func (n *node) matchChildren(part string) (result []*node) {
	nodes := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part {
			result = append(result, child)
		} else if child.isWild {
			nodes = append(nodes, child)
		}
	}
	return append(result, nodes...)
}

//极客兔兔教程的
func (n *node) matchChildren(part string) []*node {
	nodes := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part || child.isWild {
			nodes = append(nodes, child)
		}
	}
	return nodes
}

而这里，是把/16放在返回的[]*node中的第一个位置。那么就会先把 /16来进行判别是否符合条件，而/16是符合条件的，那就会执行/16对应的处理函数。 

基本就是这样。若有不同意见或有更好的想法，欢迎在评论区讨论。

Router单元测试

当前框架的文件结构

创建router_test.go文件来进行测试router。

进入到gee文件夹，执行命令 go test -run 要测试的函数。

例如测试TestGetRoute，执行命令 go test -run TestGetRoute

后面添加-v,可以查看具体的情况，例如： go test -run TestGetRoute -v

func newTestRouter() *router {
	r := newRouter()
	r.addRoute("GET", "/", nil)
	r.addRoute("GET", "/hello/:name", nil)
	r.addRoute("GET", "/hello/b/c", nil)
	r.addRoute("GET", "/hi/:name", nil)
	r.addRoute("GET", "/assets/*filepath", nil)
	return r
}

func TestParsePattern(t *testing.T) {
	ok := reflect.DeepEqual(parsePath("/p/:name"), []string{"p", ":name"})
	ok = ok && reflect.DeepEqual(parsePath("/p/*"), []string{"p", "*"})
	ok = ok && reflect.DeepEqual(parsePath("/p/*name/*"), []string{"p", "*name"})
	if !ok {
		t.Fatal("test parsePattern failed")
	}
}

func TestGetRoute(t *testing.T) {
	r := newTestRouter()
	n, ps := r.getRoute("GET", "/hello/li")

	if n == nil {
		t.Fatal("nil shouldn't be returned")
	}

	if n.path != "/hello/:name" {
		t.Fatal("should match /hello/:name")
	}

	if ps["name"] != "li" {
		t.Fatal("name should be equal to 'li'")
	}

	fmt.Printf("matched path: %s, params['name']: %s\n", n.path, ps["name"])

}

func TestGetRoute2(t *testing.T) {
	r := newTestRouter()
	n1, ps1 := r.getRoute("GET", "/assets/file1.txt")

	ok1 := n1.path == "/assets/*filepath" && ps1["filepath"] == "file1.txt"
	if !ok1 {
		t.Fatal("pattern shoule be /assets/*filepath & filepath shoule be file1.txt")
	}

	n2, ps2 := r.getRoute("GET", "/assets/css/test.css")
	ok2 := n2.path == "/assets/*filepath" && ps2["filepath"] == "css/test.css"
	if !ok2 {
		t.Fatal("pattern shoule be /assets/*filepath & filepath shoule be css/test.css")
	}
}

测试

func main() {
	fmt.Println("hello web")
	r := gee.New()

	r.GET("/:name", func(c *gee.Context) {
		name := c.Param("name")
		c.String(http.StatusOK, "name is %s", name)
	})

	r.GET("/16", func(c *gee.Context) {
		c.String(http.StatusOK, "id is 16")
	})

	r.GET("/user/info/a", func(c *gee.Context) {
		c.String(http.StatusOK, "static is %s", "sdfsd")
	})

	r.GET("/user/:id/a", func(c *gee.Context) {
		name := c.Param("id")
		c.String(http.StatusOK, "id is %s", name)
	})

	r.Run("localhost:10000")
}

完整代码：https://github.com/liwook/Go-projects/tree/main/gee-web/3-trie-router