golang net/http路由实现

当我们使用net/http开发一个接口时，需要编写一个handler函数，然后将handler函数注册到对应的url中。
当服务启动后，访问对应的url就会将对应的请求转发到对应的hander函数中。
下面是一个使用net/http的示例

func helloWorldHandler(w http.ResponseWriter, r *http.Request) {
	fmt.Fprintf(w, "Hello, World!")
}

func main() {
	http.HandleFunc("/", helloWorldHandler)
	http.ListenAndServe(":8888", nil)
}

1 2	➜ curl http://127.0.0.1:8888 Hello, World!

今天我们就来分析下这当中的路由过程，也就是net/http是如何通过URI找到对应的handler函数。

// net/http/server.go
// HandleFunc 将handler函数注册到指定的pattern中
func HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	DefaultServeMux.HandleFunc(pattern, handler)
}

func (mux *ServeMux) HandleFunc(pattern string, handler func(ResponseWriter, *Request)) {
	if handler == nil {
		panic("http: nil handler")
	}
    // HandlerFunc 实现了ServeHTTP方法
	mux.Handle(pattern, HandlerFunc(handler))
}

// The HandlerFunc type is an adapter to allow the use of
// ordinary functions as HTTP handlers. If f is a function
// with the appropriate signature, HandlerFunc(f) is a
// Handler that calls f.
type HandlerFunc func(ResponseWriter, *Request)

// ServeHTTP calls f(w, r).
func (f HandlerFunc) ServeHTTP(w ResponseWriter, r *Request) {
	f(w, r)
}


// Handle 完成handler函数的注册
func (mux *ServeMux) Handle(pattern string, handler Handler) {
    // 上锁
	mux.mu.Lock()
	defer mux.mu.Unlock()

    // pattern不能为空
	if pattern == "" {
		panic("http: invalid pattern")
	}
    // handler函数不能为nil
	if handler == nil {
		panic("http: nil handler")
	}
    // 如果patter已经注册，也会panic
	if _, exist := mux.m[pattern]; exist {
		panic("http: multiple registrations for " + pattern)
	}

	if mux.m == nil {
		mux.m = make(map[string]muxEntry)
	}

	e := muxEntry{h: handler, pattern: pattern}
    // 注册到m中
	mux.m[pattern] = e
    // 如果pattern以/结尾还需要加入到mux.es中
	if pattern[len(pattern)-1] == '/' {
		mux.es = appendSorted(mux.es, e)
	}

	if pattern[0] != '/' {
		mux.hosts = true
	}
}

// 以上便是handler的整个注册过程

 // net/http/server.go
// 上面涉及到的DefaultServeMux是一个结构体指针，指向ServeMux

// Patterns name 有两种形式，一种是 rooted paths, 如 "/favicon.ico"
// 另一个是 rooted subtrees, 如"/images/"(注意这里是以"/"结尾)

// 采用最长匹配优先原则，也就是说如果同时注册了"/images/", "/images/thumbnails/"
// 如果一个请求的URL前缀是"/images/thumbnails/"将会匹配到"/images/thumbnails/"对应的handler,
// "/images/"将会匹配除"/images/thumbnails/"之外的所有以"/images/"作为前缀的请求

// 虽说以 "/"结尾的pattern叫作 rooted subtree, 但"/"会匹配所有没有被匹配到的请求

// 如果注册了一个 rooted subtrees且一个请求的URL是没有以"/"结尾的 subtree, ServeMux将会将这个请求
// 重定向到subtree root,也就是说会加上"/". 这个行为可以通过注册另一个没有以"/"结尾的pattern来避免。

// 假设你只注册了"/images/", ServeMux会将"/images"重定向到"/images/"，除非你再单独注册"/images"

// 有的pattern可能还带有主机名，限制只匹配某一主机, 此优先级高于通用的pattern


var DefaultServeMux = &defaultServeMux

var defaultServeMux ServeMux

// ServeMux 是定义了一个http请求多路复用器
// 对于每个请求会根据请求的URL找到对应的handler函数


type ServeMux struct {
	mu    sync.RWMutex
	m     map[string]muxEntry
	es    []muxEntry // slice of entries sorted from longest to shortest.
	hosts bool       // whether any patterns contain hostnames
}

type muxEntry struct {
	h       Handler
	pattern string
}

一个http请求的路由过程

// ListenAndServe 监听指定地址，然后调用handler处理请求
// 这里的Handler是一个接口，实现了ServeHTTP方法
func ListenAndServe(addr string, handler Handler) error {
	server := &Server{Addr: addr, Handler: handler}
	return server.ListenAndServe()
}


type Handler interface {
	ServeHTTP(ResponseWriter, *Request)
}


// ServeMux实现了ServeHTTP方法
// 一个请求进行来ListenAndServe会调用ServeHTTP处理请求
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
	}
    // 这里会返回一个handler函数，该函数实现了ServeHTTP方法
	h, _ := mux.Handler(r)
    // 调用handler函数
	h.ServeHTTP(w, r)
}



func (mux *ServeMux) Handler(r *Request) (h Handler, pattern string) {

	// CONNECT requests are not canonicalized.
	if r.Method == "CONNECT" {
		// If r.URL.Path is /tree and its handler is not registered,
		// the /tree -> /tree/ redirect applies to CONNECT requests
		// but the path canonicalization does not.
		if u, ok := mux.redirectToPathSlash(r.URL.Host, r.URL.Path, r.URL); ok {
			return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
		}

		return mux.handler(r.Host, r.URL.Path)
	}

	// All other requests have any port stripped and path cleaned
	// before passing to mux.handler.
	host := stripHostPort(r.Host)
	path := cleanPath(r.URL.Path)

	// If the given path is /tree and its handler is not registered,
	// redirect for /tree/.
	if u, ok := mux.redirectToPathSlash(host, path, r.URL); ok {
		return RedirectHandler(u.String(), StatusMovedPermanently), u.Path
	}

	if path != r.URL.Path {
		_, pattern = mux.handler(host, path)
		u := &url.URL{Path: path, RawQuery: r.URL.RawQuery}
		return RedirectHandler(u.String(), StatusMovedPermanently), pattern
	}

	return mux.handler(host, r.URL.Path)
}


func (mux *ServeMux) handler(host, path string) (h Handler, pattern string) {
	mux.mu.RLock()
	defer mux.mu.RUnlock()

	// Host-specific pattern takes precedence over generic ones
	if mux.hosts {
		h, pattern = mux.match(host + path)
	}
	if h == nil {
		h, pattern = mux.match(path)
	}
	if h == nil {
		h, pattern = NotFoundHandler(), ""
	}
	return
}

// match 最终对URL进行匹配操作
func (mux *ServeMux) match(path string) (h Handler, pattern string) {
	// Check for exact match first.

	v, ok := mux.m[path]
	if ok {
		return v.h, v.pattern
	}

	// Check for longest valid match.  mux.es contains all patterns
	// that end in / sorted from longest to shortest.
	for _, e := range mux.es {
		if strings.HasPrefix(path, e.pattern) {
			return e.h, e.pattern
		}
	}
	return nil, ""
}

小结：
net/http的路由方式实现比较简单，只能适用于一些简单的场景，对于一些复杂的需求还是需要每三方库。
ServeMux使用map和列表来存储数据，如果存在很多类似的pattern的情况下会占用比较多的空间(相对于字典树实现方式)，
通过列表进行匹配也需要更多的计算资源。

REF: