详解go-zero是如何做路由管理的

// 路由管理数据结构
type ServeMux struct {
    mu    sync.RWMutex          // 对象操作读写锁
    m     map[string]muxEntry   // 存储路由映射关系
}

// core/search/tree.go
const (
    colon = ':'
    slash = '/'
)
type (
    // 节点
    node struct {
        item     interface{}
        children [2]map[string]*node
    }
    // A Tree is a search tree.
    Tree struct {
        root *node
    }
)

func (nd *node) getChildren(route string) map[string]*node {
    // 判断路由是不是以 : 开头
    if len(route) > 0 && route[0] == colon {
        return nd.children[1]
    }
    return nd.children[0]
}

// Add adds item to associate with route.
func (t *Tree) Add(route string, item interface{}) error {
    // 需要路由以 / 开头
    if len(route) == 0 || route[0] != slash {
        return errNotFromRoot
    }
    if item == nil {
        return errEmptyItem
    }
    // 把去掉 / 的路由作为参数传入
    err := add(t.root, route[1:], item)
    switch err {
    case errDupItem:
        return duplicatedItem(route)
    case errDupSlash:
        return duplicatedSlash(route)
    default:
        return err
    }
}
func add(nd *node, route string, item interface{}) error {
    if len(route) == 0 {
        if nd.item != nil {
            return errDupItem
        }
        nd.item = item
        return nil
    }
    // 继续判断，看看是不是有多个 /
    if route[0] == slash {
        return errDupSlash
    }
    for i := range route {
        // 判断是不是 /，目的就是去处两个 / 之间的内容
        if route[i] != slash {
            continue
        }
        token := route[:i]
        // 看看有没有子节点，如果有子节点，就在子节点下面继续添加
        children := nd.getChildren(token)
        if child, ok := children[token]; ok {
            if child != nil {
                return add(child, route[i+1:], item)
            }
            return errInvalidState
        }
        // 没有子节点，那么新建一个
        child := newNode(nil)
        children[token] = child
        return add(child, route[i+1:], item)
    }
    children := nd.getChildren(route)
    if child, ok := children[route]; ok {
        if child.item != nil {
            return errDupItem
        }
        child.item = item
    } else {
        children[route] = newNode(item)
    }
    return nil
}

func match(pat, token string) innerResult {
    if pat[0] == colon {
        return innerResult{
            key:   pat[1:],
            value: token,
            named: true,
            found: true,
        }
    }
    return innerResult{
        found: pat == token,
    }
}

// Search searches item that associates with given route.
func (t *Tree) Search(route string) (Result, bool) {
    // 第一步先判断是不是 / 开头
    if len(route) == 0 || route[0] != slash {
        return NotFound, false
    }
    var result Result
    ok := t.next(t.root, route[1:], &result)
    return result, ok
}
func (t *Tree) next(n *node, route string, result *Result) bool {
    if len(route) == 0 && n.item != nil {
        result.Item = n.item
        return true
    }
    for i := range route {
        // 和 add 里同样的提取逻辑
        if route[i] != slash {
            continue
        }
        token := route[:i]
        return n.forEach(func(k string, v *node) bool {
            r := match(k, token)
            if !r.found || !t.next(v, route[i+1:], result) {
                return false
            }
            // 如果 url 中有参数，会把键值对保存到结果中
            if r.named {
                addParam(result, r.key, r.value)
            }
            return true
        })
    }
    return n.forEach(func(k string, v *node) bool {
        if r := match(k, route); r.found && v.item != nil {
            result.Item = v.item
            if r.named {
                addParam(result, r.key, r.value)
            }
            return true
        }
        return false
    })
}