路由表Trie树实现

package xxx
import (
	"strings"
	"sync"
)

type node struct {
	pattern  string  // 匹配的路由规则
	part     string  // 匹配的路由规则的一部分，用于动态路由和路径参数
	children []*node // 子节点
	isWild   bool    // 是否是动态路由
	handler  Handler // 处理器
}

type Router struct {
	mu    sync.RWMutex // 读写锁
	roots map[string]*node
}

func NewRouter() *Router {
	return &Router{
		roots: make(map[string]*node),
	}
}

func (r *Router) AddRoute(method string, pattern string, handler Handler) {
	r.mu.Lock()
	defer r.mu.Unlock()

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

func (r *Router) GetRoute(method string, path string) (*node, map[string]string) {
	r.mu.RLock()
	defer r.mu.RUnlock()

	searchParts := parsePattern(path)
	params := make(map[string]string)
	root, ok := r.roots[method]
	if !ok {
		return nil, nil
	}

	n := search(root, searchParts, 0, params)
	if n != nil {
		return n, params
	}

	return nil, nil
}

func insert(n *node, parts []string, height int, key string, handler Handler) {
	if len(parts) == height {
		n.pattern = key
		n.handler = handler
		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)
	}
	insert(child, parts, height+1, key, handler)
}

// == "" {
// params[""] = strings.Join(parts[height:], "/")
// return child
// }
// params[child.part[1:]] = part
// res := search(child, parts, height+1, params)
// if res != nil {
// return res
// }
// } else if child.part == part {
// res := search(child, parts, height+1, params)
// if res != nil {
// return res
// }
// }
// }

func search(n *node, parts []string, height int, params map[string]string) *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 {
		if child.isWild {
			if child.part[0] == '*' {
				params[child.part[1:]] = strings.Join(parts[height:], "/")
				return child
			}
			params[child.part[1:]] = part
		}
		result := search(child, parts, height+1, params)
		if result != nil {
			return result
		}
	}
	return nil
}
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 {
	children := make([]*node, 0)
	for _, child := range n.children {
		if child.part == part || child.isWild {
			children = append(children, child)
		}
	}
	return children
}

func parsePattern(pattern string) []string {
	parts := strings.Split(pattern, "/")
	for i, part := range parts {
		if strings.HasPrefix(part, ":") {
			parts[i] = ":"
		} else if strings.HasPrefix(part, "") {
			parts[i] = ""
		}
	}
	return parts
}

假设我们已经定义好了一个 Handler 类型的函数 myHandler，可以通过以下方式调用 AddRoute 方法来添加路由：

router := NewRouter()
router.AddRoute("GET", "/users/:id", myHandler)
router.AddRoute("POST", "/users", myHandler)
router.AddRoute("GET", "/posts/:id", myHandler)

然后可以通过以下方式调用 GetRoute 方法来匹配路由：

node, params := router.GetRoute("GET", "/users/123")
if node != nil {
    handler := node.handler
    // 执行 handler 并将 params 传递给它
    handler(params)
}