前言

mux 是go实现的轻量的路由，可以基于host，path，query匹配。

使用示例：

r := mux.NewRouter()
r.HandleFunc("/products/{key}", ProductHandler)
r.HandleFunc("/articles/{category}/", ArticlesCategoryHandler)
r.HandleFunc("/articles/{category}/{id:[0-9]+}", ArticleHandler)

源码实现

Router类型结构

type Router struct {
    // Routes to be matched, in order.
    routes []*Route

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

    // configuration shared with `Route`
    routeConf
}

• 1.根路由，相当于http请求的多路复用器，可以通过HandleFunc注册多个path 和handler。
• 2.实现了http.handler接口，兼容http标准库

Route类型结构

// Route stores information to match a request and build URLs.
type Route struct {
    // Request handler for the route.
    handler http.Handler

    // config possibly passed in from `Router`
    routeConf
}
type routeConf struct {
    
    // Manager for the variables from host and path.
    regexp routeRegexpGroup

    // List of matchers.
    matchers []matcher

    buildVarsFunc BuildVarsFunc
}

• 1. 一条路由信息
• 2. 内部结构中 []matcher 用于存储多个匹配条件。
• 3. routeRegexpGroup 用于保存 匹配成功后提取的参数的实际值。http 请求 匹配成功后，需要将参数传递到handler处理器中，参数可以从此结构获取。

matcher接口

对于不同的匹配类型 抽象出的接口。

• 1. method匹配

// Methods --------------------------------------------------------------------

// methodMatcher matches the request against HTTP methods.
type methodMatcher []string

func (m methodMatcher) Match(r *http.Request, match *RouteMatch) bool {
    return matchInArray(m, r.Method)
}

// Methods adds a matcher for HTTP methods.
// It accepts a sequence of one or more methods to be matched, e.g.:
// "GET", "POST", "PUT".
func (r *Route) Methods(methods ...string) *Route {
    for k, v := range methods {
        methods[k] = strings.ToUpper(v)
    }
    return r.addMatcher(methodMatcher(methods))
}

Methods方法添加一个methodMatcher到route的matcher切片中。 methodMatcher的Match方法实现为：取request中的方法进行匹配。

• 2. path匹配

func (r *Route) Path(tpl string) *Route {
    r.err = r.addRegexpMatcher(tpl, regexpTypePath)
    return r
}

Path 方法添加一个支持正则匹配的matcher，类型为regexpTypePath。

routeRegexp 类型结构 是支持参数， 正则 匹配的核心。

type routeRegexp struct {
    // The unmodified template.
    template string
    // The type of match
    regexpType regexpType
    // Options for matching
    options routeRegexpOptions
    // Expanded regexp.
    regexp *regexp.Regexp
    // Reverse template.
    reverse string
    // Variable names.
    varsN []string
    // Variable regexps (validators).
    varsR []*regexp.Regexp
}

addRegexpMatcher方法解析传入的模板字符串，解析出参数和正则表达式存储到 varsN varsR 中。
以 "/articles/{category}/{id:[0-9]+}" 为例，varsN 中保存了 'category', 'id'两个参数，varsR 中保存了 ‘[0-9]+’正则表达式。

• 3.其余匹配 还支持host header 等匹配。

Route的Match方法

// Match matches the route against the request.
func (r *Route) Match(req *http.Request, match *RouteMatch) bool {
// 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
        }
    }
// Set variables.
    r.regexp.setMatch(req, match, r)

}

遍历所有添加的matcher ，所有都匹配则匹配成功。
匹配成功后，提取参数的值。保存到route的routeRegexpGroup类型变量中。

Router实现了http.handler接口

// ServeHTTP dispatches the handler registered in the matched route.
//
// When there is a match, the route variables can be retrieved calling
// mux.Vars(request).
func (r *Router) ServeHTTP(w http.ResponseWriter, req *http.Request) {
    var match RouteMatch
    var handler http.Handler
    if r.Match(req, &match) {
        handler = match.Handler
        req = setVars(req, match.Vars)
        req = setCurrentRoute(req, match.Route)
    }

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

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

    handler.ServeHTTP(w, req)
}

调用Match，如果匹配成功。通过setVars将匹配的参数设置到req的context中。
handler处理函数可以通过Vars 从requst中提取参数。 通过context传值 保证了handler接口的一致性。
如果匹配失败，交给http.NotFoundHandler处理。

Router的Match方法

将中间件 添加到 handler处理器 之上

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
}

参考：
https://github.com/gorilla/mux