Gee微框架学习记录(第三天)

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

// 第一个匹配成功的节点，用于插入
func (n *node) matchChild(part string) *node {
	for _, child := range n.children {
		if child.part == part || child.isWild {
			return child
		}
	}
	return nil
}
// 所有匹配成功的节点，用于查找
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
}

// 插入
func (n *node) insert(pattern string, parts []string, height int) {
	// 如果是最后一段，则赋值pattern，并结束递归
    if len(parts) == height {
		n.pattern = pattern
		return
	}
	// 取出当前段
	part := parts[height]
	// 用上面的查找方法匹配第一个精准匹配的节点 静态 or 动态
    child := n.matchChild(part)
    // 如果找不到，那么就到了插入位置
	if child == nil {
         // 新增node，赋值为当前的part，并判断是否是动态路由
		child = &node{part: part, isWild: part[0] == ':' || part[0] == '*'}
		// 将新增的节点加入树中
         n.children = append(n.children, child)
	}
    // 继续递归
	child.insert(pattern, parts, height+1)
}
// 查询
func (n *node) search(parts []string, height int) *node {
	// 如果是最后一段或者是当前 part 匹配 到了通配符*
    if len(parts) == height || strings.HasPrefix(n.part, "*") {
        // 判断pattern是否是空，如果是空则表示没找到。
        // pattern只有是最后一段(叶子节点)才会赋值。
         if n.pattern == "" {
			return nil
		}
        // 否则返回当前node，表示找到了
		return n
	}
	// 取出当前段
	part := parts[height]
	// 用上面的查找方法匹配第一个精准匹配的节点 静态 or 动态
    children := n.matchChildren(part)
	// 循环节点数组，找到对应的node
	for _, child := range children {
        // 递归查找 树的高度要 + 1
		result := child.search(parts, height+1)
		// 如果找到了，返回找到的node节点
         if result != nil {
			return result
		}
	}
	// 没找到返回空
	return nil
}

// route 结构体
type router struct {
    // 添加roots 关联node
	roots    map[string]*node
	handlers map[string]HandlerFunc
}

// roots key eg, roots['GET'] roots['POST']
// handlers key eg, handlers['GET-/p/:lang/doc'], handlers['POST-/p/book']

// new Router需要新的roots参数初始化
func newRouter() *router {
	return &router{
		roots:    make(map[string]*node),
		handlers: make(map[string]HandlerFunc),
	}
}

// Only one * is allowed
// router Path 路径解析，只支持一个通配符 *
func parsePattern(pattern string) []string {
	// 将通过'/'分割的字符串转化成一个数组
    vs := strings.Split(pattern, "/")
	
    // 定义一个parts 数组用于存储解析后的路径分段
	parts := make([]string, 0)
	// 循环判断，如果有通配符的情况，后续不需要添加到parts中，提升性能。其他的添加到parts中
    for _, item := range vs {
        // 当前元素不为空
		if item != "" {
		   // 加入到parts分段数组中
             parts = append(parts, item)
			// 如果当前元素首字母是通配符 '*'，那么后续全都跳过
             if item[0] == '*' {
				break
			}
		}
	}
    // 返回
	return parts
}

// 路径添加，需要调用Trie树的insert插入方法
func (r *router) addRoute(method string, pattern string, handler HandlerFunc) {
	// 解析路径
    parts := parsePattern(pattern)
	
    // 原来的string映射不变，用于handler处理
	key := method + "-" + pattern
	// 取对应方法的Trie树
    _, ok := r.roots[method]
    // 如果Trie树为空，则初始化
	if !ok {
		r.roots[method] = &node{}
	}
    // 对应方法的Trie树插入新节点
	r.roots[method].insert(pattern, parts, 0)
	// handlers 处理不变，key 映射 handler方法
    r.handlers[key] = handler
}

// 通过path查询树节点
func (r *router) getRoute(method string, path string) (*node, map[string]string) {
	// 解析路径
    searchParts := parsePattern(path)
	// 初始化一个方法用于存储匹配的路由参数
    params := make(map[string]string)
	// 通过method获取对应的方法Trie树
    root, ok := r.roots[method]
	// 如果Trie树不存在，返回空
	if !ok {
		return nil, nil
	}
	// 调用Trie树的查找方法，搜对应节点
	n := root.search(searchParts, 0)
	// 如果找到
	if n != nil {
		// 解析节点的pattern，转化成分段数组parts
         parts := parsePattern(n.pattern)
         // 循环解析的parts分段
		for index, part := range parts {
            // 如果是动态路由且为 ':'动态参数匹配，将params参数赋值，不需要':'号
			if part[0] == ':' {
				params[part[1:]] = searchParts[index]
			}
            // 如果是动态路由且为 '*'通配符匹配，判断part长度是否大于1，
            // 如果符合，同上处理params参数，并跳过后续处理，提升性能。
			if part[0] == '*' && len(part) > 1 {
				params[part[1:]] = strings.Join(searchParts[index:], "/")
				break
			}
		}
        // 返回 查找到的节点和params参数
		return n, params
	}
	// 如果没找到，返回空
	return nil, nil
}

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
}

func (r *router) handle(c *Context) {
	// 通过path查询树节点
    n, params := r.getRoute(c.Method, c.Path)
	// 如果节点存在
    if n != nil {
        // 给context的params赋值参数
		c.Params = params
		key := c.Method + "-" + n.pattern
        // 执行router 中 的handlers map映射的 handle
		r.handlers[key](c)
	} else {
		c.String(http.StatusNotFound, "404 NOT FOUND: %s\n", c.Path)
	}
}

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) {
		// expect /hello?name=geektutu
		c.String(http.StatusOK, "hello %s, you're at %s\n", c.Query("name"), c.Path)
	})

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

	r.GET("/assets/*filepath", func(c *gee.Context) {
		c.JSON(http.StatusOK, gee.H{"filepath": c.Param("filepath")})
	})

	r.Run(":9999")
}