学习Go语言Web框架Gee总结--前缀树路由Router(三)
学习Go语言Web框架Gee总结--前缀树路由Router
- router/gee/trie.go
- router/gee/router.go
- router/gee/context.go
- router/main.go
学习网站来源：Gee
项目目录结构：
router/gee/trie.go
实现动态路由最常用的数据结构，被称为前缀树(Trie树)
关于前缀树：
- 根节点不包含字符，除根节点外每一个节点都只包含一个字符
- 从根节点到某一节点，路径上经过的字符连接起来，为该节点对应的字符串
- 每个节点的所有子节点包含的字符都不相同
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, "Hello Gee
")
})
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")
}
这样，动态路由就成功实现了