学习Go语言Web框架Gee总结--前缀树路由Router(三)

学习网站来源：Gee

项目目录结构：

router/gee/trie.go

实现动态路由最常用的数据结构，被称为前缀树(Trie树)

关于前缀树：

1. 根节点不包含字符，除根节点外每一个节点都只包含一个字符
2. 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串
3. 每个节点的所有子节点包含的字符都不相同

package gee

import (
	"fmt"
	"strings"
)

//node结构体表示路由节点，包含了待匹配的路由pattern、路由中的一部分part、子节点children和是否精确匹配isWild
type node struct {
	pattern  string // 待匹配路由，例如 /p/:lang
	part     string // 路由中的一部分，例如 :lang
	children []*node // 子节点，例如 [doc, tutorial, intro]
	isWild   bool // 是否精确匹配，part 含有 : 或 * 时为true
}

/* 
用于将节点的信息格式化为字符串的方法
该方法返回一个包含节点模式（pattern）、节点部分（part）和是否是通配符（isWild）的字符串
其中%t是用于格式化布尔值的占位符
例如，如果有一个节点n，它的pattern为"/user/:id"，part为":id"，isWild为true，那么调用n.String()会返回以下格式的字符串:
"node{pattern=/user/:id, part=:id, isWild=true}"
*/
func (n *node) String() string {
	return fmt.Sprintf("node{pattern=%s, part=%s, isWild=%t}", n.pattern, n.part, n.isWild)
}

/*
用于遍历路由树中的节点，并将具有路由模式的节点添加到传入的列表中
方法接收一个指向节点切片的指针作为参数，然后遍历当前节点及其子节点，将具有路由模式的节点添加到传入的节点切片中
首先，如果当前节点的pattern不为空（即具有路由模式），则将当前节点添加到传入的节点切片中。
然后，遍历当前节点的子节点，对每个子节点递归调用travel方法，将子节点及其子节点的路由模式节点添加到传入的节点切片中
*/
func (n *node) travel(list *[]*node) {
	if n.pattern != "" {
		*list = append(*list, n)
	}
	for _, child := range n.children {
		child.travel(list)
	}
}

/*
用于在子节点中找到第一个匹配成功的节点，如果子节点的part和传入的part相等，或者子节点是通配符（isWild为true）
则返回该子节点。如果没有匹配成功的子节点，则返回nil
*/
func (n *node) matchChild(part string) *node {
	for _, child := range n.children {
		if child.part == part || child.isWild {
			return child
		}
	}
	return nil
}

/*
用于在子节点中找到所有匹配成功的节点，如果子节点的part和传入的part相等，或者子节点是通配符（isWild为true）
则将该子节点加入到nodes切片中。最后返回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
}

/*
用于向路由树中插入路由。它接收三个参数：pattern表示要插入的路由模式，parts表示路由模式分割后的部分，height表示当前插入的层级
首先，它检查当前层级是否已经是最后一层（即parts的长度是否等于height），如果是，则将当前节点的pattern设置为传入的pattern，表示找到了对应的路由
否则，它从parts中取出当前层级的部分，然后调用matchChild方法查找是否已经存在对应的子节点
如果没有找到对应的子节点，说明需要创建一个新的子节点，然后将其插入到当前节点的children中
然后，递归调用insert方法，将pattern、parts和height+1传入新创建的子节点中，继续插入下一层级的路由
*/
func (n *node) insert(pattern string, parts []string, height int) {
	if len(parts) == height {
		n.pattern = pattern
		return
	}
	part := parts[height]
	child := n.matchChild(part)
	if child == nil {
		child = &node{part: part, isWild: part[0] == ':' || part[0] == '*'}
		n.children = append(n.children, child)
	}
	child.insert(pattern, parts, height+1)
}

/*
用于在路由树中搜索路由。它接收两个参数：parts表示路由模式分割后的部分，height表示当前搜索的层级
首先，它检查当前层级是否已经是最后一层（即parts的长度是否等于height），或者当前节点是一个通配符节点（part以*开头）
如果是，则检查当前节点是否有对应的路由模式，如果有，则返回当前节点，表示找到了对应的路由
否则，它从parts中取出当前层级的部分，然后调用matchChildren方法查找所有匹配的子节点
然后，对于每一个匹配的子节点，递归调用search方法，将parts和height+1传入子节点中，继续搜索下一层级的路由
如果在递归过程中找到了对应的路由节点，则直接返回该节点；如果没有找到，则返回nil
*/
func (n *node) search(parts []string, height int) *node {
	if len(parts) == height || strings.HasPrefix(n.part, "*") {
		if n.pattern == "" {
			return nil
		}
		return n
	}
	part := parts[height]
	children := n.matchChildren(part)

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

router/gee/router.go

Trie 树的插入与查找都成功实现了，接下来我们将 Trie 树应用到路由中去吧。我们使用 roots 来存储每种请求方式的Trie 树根节点。使用 handlers 存储每种请求方式的 HandlerFunc 。getRoute 函数中，还解析了:和*两种匹配符的参数，返回一个 map

package gee

import (
	"net/http"
	"strings"
)

//用于存储路由树和处理函数
type router struct {
	roots    map[string]*node
	handlers map[string]HandlerFunc
}


func newRouter() *router {
	return &router{
		roots:    make(map[string]*node),
		handlers: make(map[string]HandlerFunc),
	}
}

//用于解析路由模式的函数
func parsePattern(pattern string) []string {
	vs := strings.Split(pattern, "/")

	parts := make([]string, 0)
	for _, item := range vs {
		if item != "" {
			parts = append(parts, item)
			if item[0] == '*' {
				break
			}
		}
	}
	return parts
}

/*
用于向路由器中添加路由
首先调用 parsePattern 函数解析路由模式，然后将方法和模式拼接成键，并检查 roots 中是否存在对应的方法
如果不存在，则将方法添加到 roots 中，然后调用 insert 方法将模式插入到路由树中，并将处理函数添加到 handlers 中
*/
func (r *router) addRoute(method string, pattern string, handler HandlerFunc) {
	parts := parsePattern(pattern)

	key := method + "-" + pattern
	_, ok := r.roots[method]
	if !ok {
		r.roots[method] = &node{}
	}
	r.roots[method].insert(pattern, parts, 0)
	r.handlers[key] = handler
}

/*
用于根据请求方法和路径获取路由
首先调用 parsePattern 函数解析路径，然后检查 roots 中是否存在对应的方法
如果存在，则调用 search 方法在路由树中查找匹配的节点，并将匹配的部分和参数存储到 params 中
最后返回匹配的节点和参数
*/
func (r *router) getRoute(method string, path string) (*node, map[string]string) {
	searchParts := parsePattern(path)
	params := make(map[string]string)
	root, ok := r.roots[method]

	if !ok {
		return nil, nil
	}

	n := root.search(searchParts, 0)

	if n != nil {
		parts := parsePattern(n.pattern)
		for index, part := range parts {
			if part[0] == ':' {
				params[part[1:]] = searchParts[index]
			}
			if part[0] == '*' && len(part) > 1 {
				params[part[1:]] = strings.Join(searchParts[index:], "/")
				break
			}
		}
		return n, params
	}

	return nil, nil
}

/*
用于获取指定请求方法下的所有路由节点
首先检查 roots 中是否存在对应的方法
如果存在，则调用 travel 方法遍历路由树并将节点存储到切片中，最后返回该切片
*/
func (r *router) getRoutes(method string) []*node {
	root, ok := r.roots[method]
	if !ok {
		return nil
	}
	nodes := make([]*node, 0)
	root.travel(&nodes)
	return nodes
}

/*
用于处理请求
首先调用 getRoute 方法获取匹配的路由节点和参数
然后根据匹配的节点和请求方法拼接键，从 handlers 中取出对应的处理函数并调用它
如果找不到匹配的路由节点，则返回 404 NOT FOUND
*/
func (r *router) handle(c *Context) {
	n, params := r.getRoute(c.Method, c.Path)
	if n != nil {
		c.Params = params
		key := c.Method + "-" + n.pattern
		r.handlers[key](c)
	} else {
		c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	}
}

router/gee/context.go

由于需要能够访问到解析的参数，需要对context对象增加关于param的属性与方法

type Context struct {
	// origin objects
	Writer http.ResponseWriter
	Req    *http.Request
	// request info
	Path   string
	Method string
	Params map[string]string
	// response info
	StatusCode int
}

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

router/main.go

package main
import (
	"net/http"
	"gee"
)

func main() {
	r := gee.New()
	r.GET("/", func(c *gee.Context) {
		c.HTML(http.StatusOK, "<h1>Hello Gee</h1>")
	})

	r.GET("/hello", func(c *gee.Context) {
		c.String(http.StatusOK, "hello %s, you're at %s\n", c.Query("name"), c.Path)
	})

	r.GET("/hello/:name", func(c *gee.Context) {
		c.String(http.StatusOK, "hello %s, you're at %s\n", c.Param("name"), c.Path)
	})

	//添加了一个带有通配符的路由
	//当用户访问 /assets/some/file/path 路径时，会执行传入的匿名函数，该函数从路径参数中获取 filepath 的值
	//并将其包含在 JSON 响应中返回
	r.GET("/assets/*filepath", func(c *gee.Context) {
		c.JSON(http.StatusOK, gee.H{"filepath": c.Param("filepath")})
	})

	r.Run(":9999")
}

这样，动态路由就成功实现了