来看看 http 自带的路由功能。
阅读前留几个问题
- 如果要自己实现路由，该怎么做？
- 默认路由的结构，搜索方式是什么？
例子
我们经常在示例中看到如下两种写法，示例来自于 stackoverflow
// 使用 DefaultServeMux
func main() {
http.HandleFunc("/page2", Page2)
http.HandleFunc("/", Index)
http.ListenAndServe(":3000", nil)
}
// 使用 ServeMux 路由
func main() {
mux := http.NewServeMux()
mux.HandleFunc("/page2", Page2)
mux.HandleFunc("/", Index)
http.ListenAndServe(":3000", mux)
}
其实通过代码就可以发现，http 包直接调用 HandleFunc 使用的是DefaultServeMux，我们可以看到最后调用 ListenAndServe，后面一个参数传递的是 nil，会让 server 使用 DefaultServeMux，通过分析代码可以知道，DefaultServeMux 和 ServeMux的结构，path解析都是一样的。唯一的区别在于下面，
// DefaultServeMux is the default ServeMux used by Serve.
var DefaultServeMux = &defaultServeMux
可以看到这个 DefaultServeMux 是一个全局变量，那么意味这有安全风险，任何其他的第三方包都可以添加路由。这个存在的意义据介绍是为了一些自定义功能，我们大部分场景都可以不使用这个方法。那么从这里可以看出，如果我们要实现一个路由，得满足下面的接口。然后传递到 ListenAndServe 函数的第二个参数就行了。
type Handler interface {
ServeHTTP(ResponseWriter, *Request)
}
结构介绍
type ServeMux struct {
mu sync.RWMutex
m map[string]muxEntry
hosts bool // hostname 路由
}
type muxEntry struct {
explicit bool // 是否注册过
h Handler // 处理函数
pattern string // 路由 path 和 key 一致
}
看到上面的结构，可以知道路由的节点是使用 hash 存储的，key 为路由 path，value 为节点，其结构为 muxEntry。
路由注册
我们直接看路由注册部分的代码。
// Handle 为给定路由 path 注册 handler。
// 如果该路由 path 的 handler 已存在会在编译时 panic。即 mux.m[pattern].explicit
func (mux *ServeMux) Handle(pattern string, handler Handler) {
mux.mu.Lock()
defer mux.mu.Unlock()
if pattern == "" {
panic("http: invalid pattern " + pattern)
}
if handler == nil {
panic("http: nil handler")
}
if mux.m[pattern].explicit {
panic("http: multiple registrations for " + pattern)
}
if mux.m == nil {
mux.m = make(map[string]muxEntry)
}
mux.m[pattern] = muxEntry{explicit: true, h: handler, pattern: pattern}
if pattern[0] != '/' {
mux.hosts = true
}
// 如果 pattern 是 /tree/，则为 /tree 插入隐式永久重定向。
// 这个规则可以被覆盖。
n := len(pattern)
if n > 0 && pattern[n-1] == '/' && !mux.m[pattern[0:n-1]].explicit {
// If pattern contains a host name, strip it and use remaining
// path for redirect.
path := pattern
if pattern[0] != '/' {
// In pattern, at least the last character is a '/', so
// strings.Index can't be -1.
path = pattern[strings.Index(pattern, "/"):]
}
url := &url.URL{Path: path}
mux.m[pattern[0:n-1]] = muxEntry{h: RedirectHandler(url.String(), StatusMovedPermanently), pattern: pattern}
}
}
从代码可以了解到，其实就是把路由信息放在了 hash 结构里，最后对 /tree 这种方式做了一些小优化，使它重定向到 /tree/。
路由查找
从请求分析路径可以知到路由的查找源头，如下
// ServeHTTP 调度请求给已注册模式最匹配 URL 的 handler
func (mux *ServeMux) ServeHTTP(w ResponseWriter, r *Request) {
if r.RequestURI == "*" {
if r.ProtoAtLeast(1, 1) {
w.Header().Set("Connection", "close")
}
w.WriteHeader(StatusBadRequest)
return
}
h, _ := mux.Handler(r)
h.ServeHTTP(w, r)
}
再往下找，我们可以知道最终的匹配规则，
// 通过给定的 path 从 handler hash 结构中查找 handler
// 最长模式优先
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
var n = 0
// 遍历
for k, v := range mux.m {
if !pathMatch(k, path) {
continue
}
// len(k) > n 即还能找到更长的 pattern，满足最长模式优先
if h == nil || len(k) > n {
n = len(k)
// 返回 handler
h = v.h
pattern = v.pattern
}
}
return
}
// 匹配
func pathMatch(pattern, path string) bool {
if len(pattern) == 0 {
// should not happen
return false
}
n := len(pattern)
if pattern[n-1] != '/' {
return pattern == path
}
// 是否匹配，mux 的 key（pattern）和给定的 path比较，按照最长原则
return len(path) >= n && path[0:n] == pattern
}
回顾问题
如果要自己实现路由，该怎么做？
我们得实现 Handler 接口，即实现签名为ServeHTTP(ResponseWriter, *Request)的方法。默认路由的结构，搜索方式是什么？
默认路由用的ServeMux结构，用 hash 存储了 path 和 handler。查找的时候会遍历这个 hash 结构，采用最长匹配的原则去查找 handler，当出现 /tree/ 和 /tree/sub/ 同时注册时，/tree/sub/ 会用 /tree/sub/ 注册的 handler 而不是 /tree/ 注册的 handler。同时，当 /tree/ 没有子路由注册时， /tree/ 的 handler 会匹配所有 /tree/sub/ 等这种子路由，一定程度满足了 * 这样的匹配模式。