Mux源码分析

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
// This will send all incoming requests to the 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

  // Parent route, if this is a subrouter.
  parent parentRoute
  // Routes to be matched, in order.
  routes []*Route
  // Routes by name for URL building.
  namedRoutes map[string]*Route
  // See Router.StrictSlash(). This defines the flag for new routes.
  strictSlash bool
  // See Router.SkipClean(). This defines the flag for new routes.
  skipClean bool
  // If true, do not clear the request context after handling the request.
  // This has no effect when go1.7+ is used, since the context is stored
  // on the request itself.
  KeepContext bool
  // see Router.UseEncodedPath(). This defines a flag for all routes.
  useEncodedPath bool
  // Slice of middlewares to be called after a match is found
  middlewares []middleware
}

1
2
3
4
5
6
7
8
9
10
11
12
13
// StrictSlash defines the trailing slash behavior for new routes. The initial
// value is false.
//
// When true, if the route path is "/path/", accessing "/path" will perform a redirect
// to the former and vice versa. In other words, your application will always
// see the path as specified in the route.
//
// When false, if the route path is "/path", accessing "/path/" will not match
// this route and vice versa.
func (r *Router) StrictSlash(value bool) *Router {
    r.strictSlash = value
    return r
}

1
2
3
4
5
6
7
8
9
10
11
12
// SkipClean defines the path cleaning behaviour for new routes. The initial
// value is false. Users should be careful about which routes are not cleaned
//
// When true, if the route path is "/path//to", it will remain with the double
// slash. This is helpful if you have a route like: /fetch/http://xkcd.com/534/
//
// When false, the path will be cleaned, so /fetch/http://xkcd.com/534/ will
// become /fetch/http/xkcd.com/534
func (r *Router) SkipClean(value bool) *Router {
    r.skipClean = value
    return r
}

1
2
3
4
5
6
7
8
9
10
// UseEncodedPath tells the router to match the encoded original path
// to the routes.
// For eg. "/path/foo%2Fbar/to" will match the path "/path/{var}/to".
//
// If not called, the router will match the unencoded path to the routes.
// For eg. "/path/foo%2Fbar/to" will match the path "/path/foo/bar/to"
func (r *Router) UseEncodedPath() *Router {
    r.useEncodedPath = true
    return r
}

1
2
3
4
5
6
// HandleFunc registers a new route with a matcher for the URL path.
// See Route.Path() and Route.HandlerFunc().
func (r *Router) HandleFunc(path string, f func(http.ResponseWriter,
  *http.Request)) *Route {
  return r.NewRoute().Path(path).HandlerFunc(f)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
// 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) {
  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 = setVars(req, match.Vars)
    req = setCurrentRoute(req, match.Route)
  }

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

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

  if !r.KeepContext {
    defer contextClear(req)
  }

  handler.ServeHTTP(w, req)
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
// Match attempts to match the given request against the router's registered routes.
//
// If the request matches a route of this router or one of its subrouters the Route,
// Handler, and Vars fields of the the match argument are filled and this function
// returns true.
//
// If the request does not match any of this router's or its subrouters' routes
// then this function returns false. If available, a reason for the match failure
// will be filled in the match argument's MatchErr field. If the match failure type
// (eg: not found) has a registered handler, the handler is assigned to the Handler
// field of the match argument.
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
    }
  }
  // ...
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
// Route stores information to match a request and build URLs.
type Route struct {
  // Parent where the route was registered (a Router).
  parent parentRoute
  // Request handler for the route.
  handler http.Handler
  // List of matchers.
  matchers []matcher
  // Manager for the variables from host and path.
  regexp *routeRegexpGroup
  // If true, when the path pattern is "/path/", accessing "/path" will
  // redirect to the former and vice versa.
  strictSlash bool
  // If true, when the path pattern is "/path//to", accessing "/path//to"
  // will not redirect
  skipClean bool
  // If true, "/path/foo%2Fbar/to" will match the path "/path/{var}/to"
  useEncodedPath bool
  // The scheme used when building URLs.
  buildScheme string
  // 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

  buildVarsFunc BuildVarsFunc
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
// Path adds a matcher for the URL path.
// It accepts a template with zero or more URL variables enclosed by {}. The
// template must start with a "/".
// Variables can define an optional regexp pattern to be matched:
//
// - {name} matches anything until the next slash.
//
// - {name:pattern} matches the given regexp pattern.
//
// For example:
//
//     r := mux.NewRouter()
//     r.Path("/products/").Handler(ProductsHandler)
//     r.Path("/products/{key}").Handler(ProductsHandler)
//     r.Path("/articles/{category}/{id:[0-9]+}").
//       Handler(ArticleHandler)
//
// Variable names must be unique in a given route. They can be retrieved
// calling mux.Vars(request).
func (r *Route) Path(tpl string) *Route {
  r.err = r.addRegexpMatcher(tpl, regexpTypePath)
  return r
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
// 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
      }
      matchErr = nil
      return false
    }
  }

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

  if match.MatchErr == ErrMethodMismatch {
    // 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.
  if r.regexp != nil {
    r.regexp.setMatch(req, match, r)
  }
  return true
}