从零实现Go Web框架Gee：第三天 前缀树路由解析

从零实现Go Web框架Gee：第三天 前缀树路由解析

7days-golang 7 days golang programs from scratch (web framework Gee, distributed cache GeeCache, object relational mapping ORM framework GeeORM, rpc framework GeeRPC etc) 7天用Go动手写/从零实现系列 项目地址: https://gitcode.com/gh_mirrors/7d/7days-golang

在构建Web框架时，路由系统是核心组件之一。本文将深入探讨如何在Gee框架中实现基于前缀树(Trie)的高效动态路由解析系统。

为什么需要动态路由

在传统的静态路由系统中，我们通常使用简单的键值对(map)来存储路由规则。这种方式虽然简单高效，但存在明显局限性：

1. 无法处理动态路径参数，如/user/:id这样的路由
2. 难以支持通配符匹配，如/static/*filepath
3. 缺乏灵活的路由匹配规则

为了解决这些问题，我们需要引入更强大的路由数据结构——前缀树(Trie)。

前缀树(Trie)基础

前缀树是一种多叉树结构，具有以下特点：

• 每个节点代表一个字符串(通常是路径的一部分)
• 从根节点到某一节点的路径构成一个完整的前缀
• 共享公共前缀的路由在树中共享相同的路径

这种结构特别适合HTTP路由的场景，因为HTTP路径本身就是由/分隔的层级结构。

Gee中的Trie实现

节点结构设计

Gee框架中的路由节点定义为：

type node struct {
    pattern  string // 完整路由模式，如 /p/:lang/doc
    part     string // 当前节点代表的部分，如 :lang
    children []*node // 子节点列表
    isWild   bool   // 是否为通配节点(包含:或*)
}

关键点说明：

• pattern只在叶子节点设置，表示一个完整的路由规则
• isWild标记区分静态路由和动态路由
• children存储所有子节点，支持多分支

路由插入逻辑

插入新路由时，采用递归方式构建Trie树：

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

插入过程解析：

1. 将路由模式按/分割成parts数组
2. 从根节点开始，逐层匹配parts
3. 若无匹配子节点，则创建新节点
4. 递归处理直到所有parts处理完毕

路由查询逻辑

查询路由时同样采用递归方式：

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
}

查询过程特点：

• 支持精确匹配和通配匹配
• 遇到*通配符时停止递归
• 只有匹配到完整路由(pattern不为空)才返回成功

路由参数解析

Gee框架支持两种动态参数：

1. 命名参数：:name形式，匹配单个路径段

   • 示例：/user/:id 匹配 /user/123
   • 解析结果：{"id": "123"}

2. 通配参数：*filepath形式，匹配剩余所有路径

   • 示例：/static/*filepath 匹配 /static/css/style.css
   • 解析结果：{"filepath": "css/style.css"}

参数解析在getRoute方法中实现：

func (r *router) getRoute(method string, path string) (*node, map[string]string) {
    searchParts := parsePattern(path)
    params := make(map[string]string)
    root := r.roots[method]
    
    n := root.search(searchParts, 0)
    if n != nil {
        parts := parsePattern(n.pattern)
        for i, part := range parts {
            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
    }
    return nil, nil
}

上下文整合

为了在处理器中访问路由参数，Gee扩展了Context结构：

type Context struct {
    // 原有字段...
    Params map[string]string // 路由参数
}

func (c *Context) Param(key string) string {
    return c.Params[key]
}

这样在路由处理器中就可以方便地获取参数：

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

性能考量

Trie树路由相比简单map路由有以下优势：

1. 空间效率：共享公共前缀，减少存储开销
2. 查询效率：时间复杂度为O(L)，L为路径深度
3. 灵活性：支持复杂路由模式

但需要注意：

• 通配符*应出现在路径末尾，避免歧义
• 路由冲突需要合理处理(如/user/:id和/user/name)

实际应用示例

下面是一个完整的使用示例：

func main() {
    r := gee.New()
    
    // 静态路由
    r.GET("/", func(c *gee.Context) {
        c.HTML(http.StatusOK, "<h1>Welcome</h1>")
    })
    
    // 命名参数
    r.GET("/user/:name", func(c *gee.Context) {
        c.String(http.StatusOK, "Hello %s", c.Param("name"))
    })
    
    // 通配参数
    r.GET("/static/*filepath", func(c *gee.Context) {
        c.JSON(http.StatusOK, gee.H{"file": c.Param("filepath")})
    })
    
    r.Run(":8080")
}

测试结果：

$ curl "http://localhost:8080/user/geektutu"
Hello geektutu

$ curl "http://localhost:8080/static/js/app.js"
{"file":"js/app.js"}

总结

通过实现基于Trie树的路由系统，Gee框架获得了以下能力：

1. 支持静态路由和动态路由
2. 提供命名参数和通配参数解析
3. 保持高效的路由匹配性能
4. 简洁直观的API设计

这为构建更复杂的Web应用奠定了坚实基础。下一节我们将探讨如何实现路由分组和中间件机制，使框架功能更加完善。

7days-golang 7 days golang programs from scratch (web framework Gee, distributed cache GeeCache, object relational mapping ORM framework GeeORM, rpc framework GeeRPC etc) 7天用Go动手写/从零实现系列 项目地址: https://gitcode.com/gh_mirrors/7d/7days-golang