GO语言web开发的几种Mux库阅读

DefaultServeMux阅读

可以查看到ServeMux结构的定义如下：

type ServeMux struct {
    mu    sync.RWMutex
    m     map[string]muxEntry
    hosts bool 
}

type muxEntry struct {
    explicit bool
    h        Handler
    pattern  string
}

ServeMux结构中最重要的字段为map[string]muxEntry类型的m，这是一个map，key为表示url模式的string，value则是muxEntry结构。可以看到muxEntry结构中存储了表示具体的url模式的string和handler，以及是否explicit的bool类型。由于ServeMux也实现了ServeHTTP函数，其也可以看成是一个handler接口，与之前ServeHTTP函数处理http请求并产生http响应不同，ServeMux的ServeHTTP方法是用来找到路由对应的handler的。

ServeMux的任务是将用户请求中 path 映射到 Handler，由于其可能会被并发访问，因此其还有一个子段mu作为sync.RWMutex类型，也就是读写互斥锁，其保证不同go程对该线程不安全变量的互斥访问。

可以查看到ServeMux的Match函数如下：

// Find a handler on a handler map given a path string.
// Most-specific (longest) pattern wins.
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, ""
}

可以看到，其首先检查mux.m中是否含有path对应的精确匹配，如果有的话就直接返回对应的handler和pattern。否则则遍历所有的patterns，由于patterns首先按照长度从大到小排序，因此其会找到具有最长匹配前缀的pattern并将其和对应的handler返回。这相比过去版本的match有了优化，可以更快地找到第一个具有最长匹配的pattern。

而Handle函数可以用于注册路由，可以看到其实现如下：

// Handle registers the handler for the given pattern.
// If a handler already exists for pattern, Handle panics.
func (mux *ServeMux) Handle(pattern string, handler Handler) {
	mux.mu.Lock()
	defer mux.mu.Unlock()

	if pattern == "" {
		panic("http: invalid pattern")
	}
	if handler == nil {
		panic("http: nil handler")
	}
	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}
	mux.m[pattern] = e
	if pattern[len(pattern)-1] == '/' {
		mux.es = appendSorted(mux.es, e)
	}

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

正如之前所述，由于ServeMux不是线程安全的，因此Handle函数首先将ServerMux加上互斥锁，并在函数处理完后解开互斥锁。之后其检查pattern和handler是否是合法且是没有注册过的，如果是的话则将其加入到mux.m这个map中(如果还没有申请mux.m就创建)。之后按照长度的顺序将其插入到es中，使得插入后es仍然有序。

然后可以查看到handler方法：

// handler is the main implementation of Handler.
// The path is known to be in canonical form, except for CONNECT methods.
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检查是否存在host+path路径，如果有就返回对应的h和pattern，否则再调用match检查是否存在path路径，如果有也返回对应的h和pattern。否则就进入NotFoundHandler的处理。

// NotFoundHandler returns a simple request handler
// that replies to each request with a ``404 page not found'' reply.
func NotFoundHandler() Handler { return HandlerFunc(NotFound) }

NotFoundHandler如上吗，将NotFound作为参数，使用HandlerFunc函数处理，也就是处理了404错误的情况。

经过上面的分析，可以看到DefaultServeMux实现了对用户请求url进行路由的功能。可以看到，DefaultServeMux支持url的精确匹配和最长前缀匹配。但由于路由的时候还需要一条条检查所有项目来匹配，因此在路由条目比较多的时候可能还是比较慢。为了加快速度，可以像其他一些后端路由一样采取基于Trie前缀树(用/分隔)等层次匹配的算法，可以使得最长查找次数为树的高度。此外，DefaultServeMux也不支持Method，header，host等信息匹配以及正则表达式的url匹配。

gorilla/mux阅读

进一步对比阅读gorilla/mux代码。可以看到gorilla/mux比DefaultServeMux实现了更强大的功能，包括正则表达式匹配以及Method，header，host等信息的匹配，利用gorilla/mux可以更方便地开发server程序。

可以看到其定义Route如下，Route结构存储了匹配请求的handler和name等结构其还有着map[string]类型指针，指向全局索引所有命名Routes的结构。

// Route stores information to match a request and build URLs.
type Route struct {
	// Request handler for the route.
	handler http.Handler
	// If true, this route never matches: it is only used to build URLs.
	buildOnly bool
	// The name used to build URLs.
	name string
	// Error resulted from building a route.
	err error
	// "global" reference to all named routes
	namedRoutes map[string]*Route
	// config possibly passed in from `Router`
	routeConf
}

Router的代码则如下：

type Router struct {
	// Configurable Handler to be used when no route matches.
	NotFoundHandler http.Handler

	// Configurable Handler to be used when the request method does not match the route.
	MethodNotAllowedHandler http.Handler

	// Routes to be matched, in order.
	routes []*Route

	// Routes by name for URL building.
	namedRoutes map[string]*Route

	// If true, do not clear the request context after handling the request.
	//
	// Deprecated: No effect, since the context is stored on the request itself.
	KeepContext bool

	// Slice of middlewares to be called after a match is found
	middlewares []middleware

	// configuration shared with `Route`
	routeConf
}

可以看到，其包括特定的NotFoundHandler 和MethodNotAllowedHandler 字段来处理页面没有找到，和方法不允许的通常情况，这两个handler也是http.handler类型。而其存储路由条目则是用一个[]*Route存储，同时还有一个map[string]*Route类型根据名称索引到对应路由。

其Match函数与net/http包中的不同，其首先遍历所有routes，然后调用route.Match看能否匹配，如果可以匹配就检查如果在没有错误的情况下，添加各个中间件作为回调函数链。这样可以支持服务端通过中间件实现更强大的路由功能。之后其检查方法如果不匹配的话，就用MethodNotAllowedHandler进行处理，最后检查如果是没有找到页面的话，就用NotFoundHandler 进行处理。

func (r *Router) Match(req *http.Request, match *RouteMatch) bool {
	for _, route := range r.routes {
		if route.Match(req, match) {
			// Build middleware chain if no error was found
			if match.MatchErr == nil {
				for i := len(r.middlewares) - 1; i >= 0; i-- {
					match.Handler = r.middlewares[i].Middleware(match.Handler)
				}
			}
			return true
		}
	}

	if match.MatchErr == ErrMethodMismatch {
		if r.MethodNotAllowedHandler != nil {
			match.Handler = r.MethodNotAllowedHandler
			return true
		}

		return false
	}

	// Closest match for a router (includes sub-routers)
	if r.NotFoundHandler != nil {
		match.Handler = r.NotFoundHandler
		match.MatchErr = ErrNotFound
		return true
	}

	match.MatchErr = ErrNotFound
	return false
}

进一步查看route.Match函数的代码如下：

// Match matches the route against the request.
func (r *Route) Match(req *http.Request, match *RouteMatch) bool {
	if r.buildOnly || r.err != nil {
		return false
	}

	var matchErr error

	// Match everything.
	for _, m := range r.matchers {
		if matched := m.Match(req, match); !matched {
			if _, ok := m.(methodMatcher); ok {
				matchErr = ErrMethodMismatch
				continue
			}

			// Ignore ErrNotFound errors. These errors arise from match call
			// to Subrouters.
			//
			// This prevents subsequent matching subrouters from failing to
			// run middleware. If not ignored, the middleware would see a
			// non-nil MatchErr and be skipped, even when there was a
			// matching route.
			if match.MatchErr == ErrNotFound {
				match.MatchErr = nil
			}

			matchErr = nil
			return false
		}
	}

	if matchErr != nil {
		match.MatchErr = matchErr
		return false
	}

	if match.MatchErr == ErrMethodMismatch && r.handler != nil {
		// We found a route which matches request method, clear MatchErr
		match.MatchErr = nil
		// Then override the mis-matched handler
		match.Handler = r.handler
	}

	// Yay, we have a match. Let's collect some info about it.
	if match.Route == nil {
		match.Route = r
	}
	if match.Handler == nil {
		match.Handler = r.handler
	}
	if match.Vars == nil {
		match.Vars = make(map[string]string)
	}

	// Set variables.
	r.regexp.setMatch(req, match, r)
	return true
}

可以看到，其首先检查buildOnly和err，在buildOnly为假和err为nil的情况下，遍历r.matchers ，调用m.Match检查是否方法匹配，如果发生错误就进行错误处理，直到找到匹配的match。之后就收集相关信息，设定对应的Route和handler，以及参数Vars，之后通过正则表达式的setMatch匹配相应正则表达式中的参数。

然后可以查看Vars函数如下，其取出http请求相关联的变量的信息。该函数从上下文中获得对应的varsKey，将存放该请求对应的变量值集合的string映射到string的map类型返回。

func Vars(r *http.Request) map[string]string {
	if rv := r.Context().Value(varsKey); rv != nil {
		return rv.(map[string]string)
	}
	return nil
}

还可以查看handler的实现如下，HandlerFunc调用Route的Handler函数字段对http.HandlerFunc(f)返回的带handler的Route进行处理。而Handler函数则设置了Route的handler并将其返回。

func (r *Route) HandlerFunc(f func(http.ResponseWriter, *http.Request)) *Route {
    return r.Handler(http.HandlerFunc(f))
}
// Handler sets a handler for the route.
func (r *Route) Handler(handler http.Handler) *Route {
	if r.err == nil {
		r.handler = handler
	}
	return r
}

查看Router的ServeHTTP函数如下，其处理http的请求，并在http.ResponseWriter类型参数中写入响应报文。其首先在r.skipClean为假的情况下获得请求的url路径，之后在r.useEncodedPath为真的情况下调用EscapedPath()对路径进行处理。之后其清理路径到规范的形式并重定向。之后就检查是否有match和请求相匹配，匹配的话就设定handler为match的Handler字段，以及设置请求包括match的参数，路由等。之后看是否需要用到methodNotAllowedHandler和NotFoundHandler，最终让handler处理请求。

func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
	if !r.skipClean {
		path := req.URL.Path
		if r.useEncodedPath {
			path = req.URL.EscapedPath()
		}
		// Clean path to canonical form and redirect.
		if p := cleanPath(path); p != path {

			// Added 3 lines (Philip Schlump) - It was dropping the query string and #whatever from query.
			// This matches with fix in go 1.2 r.c. 4 for same problem.  Go Issue:
			// http://code.google.com/p/go/issues/detail?id=5252
			url := *req.URL
			url.Path = p
			p = url.String()

			w.Header().Set("Location", p)
			w.WriteHeader(http.StatusMovedPermanently)
			return
		}
	}
	var match RouteMatch
	var handler http.Handler
	if r.Match(req, &match) {
		handler = match.Handler
		req = requestWithVars(req, match.Vars)
		req = requestWithRoute(req, match.Route)
	}

	if handler == nil && match.MatchErr == ErrMethodMismatch {
		handler = methodNotAllowedHandler()
	}

	if handler == nil {
		handler = http.NotFoundHandler()
	}

	handler.ServeHTTP(w, req)
}