requestMapping-根据请求路径获取对应处理方法

超、凢脫俗 2021-12-11 14:21 601阅读 0赞

上一篇文章中我们了解了Spring如何处理@RequestMapping注解，并将请求映射信息保存到系统中以处理客户端发送来的请求，但是Spring是怎样接受请求，并根据请求URL来匹配正确的处理器方法呢，更重要的是Spring允许我们定义签名灵活的处理器方法，也就是说你的参数类型，顺序，返回类型都可以自定义，只要你方便就好。真的很棒，但是他怎样做到的呢？ 这篇文章我们就研究这个问题。

### 一、重要的类和接口 ###

1.  HandlerMethodArgumentResolver 一个策略接口，根据请求解析处理方法的参数值（这是重点），我们就是通过实现它来自定义我们的参数类型的。Spring默认提供了十多个类型的解析器来处理常见的方法参数，如@PathVariabe，@RequestParam， Model，@ModelAttribute等等。  
    
2.  HandlerMethodReturnValueHandler 一个策略接口，用来处理处理器方法的返回值(重点啊)， 我们通过实现它来自定义我们的返回类型
3.  RequestMappingHandlerAdapter 一个HandlerAdapter的实现类，用来处理HandlerMethod，它包含了上面两个接口一系列实现类的列表，用于处理不同的参数和返回类型
4.  HandlerMethodArgumentResolverComposite 这个类 维护了一个MethodParameter 与 HandlerMethodArgumentResolver的映射表，可以快速检索某一MethodParameter对应的Resolver，并调用Resolver进行参数解析。
5.  HandlerMethodReturnValueHandlerComposite 这个类只维护了一个所有HandlerMethodReturnValueHandler的列表，每次遍历检索支持某返回类型的处理器。
6.  ModelAndViewContainer 这个类记录了Model和View的对应关系，可快速检索某个视图对应的Model。

说明：当我们阅读@RequestMapping注解的说明时会了解到，Spring的处理器方法默认支持诸多参数类型和返回值类型，并提供了每一个参数类型，返回值类型的解析器和处理器，上述1,2两个接口的实现类，我们大致看一下他们的类层次结构：

![144924_lbqN_258230.png][]

![144944_3CqX_258230.png][]

以上是方法参数的可能类型以及他们的解析器，Spring默认支持还是挺棒的，可以应付绝大多数需求了。

![145132_jtRf_258230.png][]

![145150_5Vp2_258230.png][]

以上是可能的返回值类型和他们的处理器，同样Spring的默认支持很强大，我们都可以实现自己的参数解析器和返回值处理器。

我们可以看到支持的类型非常多，由于篇幅限制，我们只讲解最常用的一个或几个，如@PathVariable，@RequestParam，Model等，如果有兴趣大家可以自行研究，思路都一样。

### 二、找到请求对应的处理方法 ###

我们知道Spring会通过DispatcherServlet来处理所有的请求，那么我们就看他是怎么处理的：

**\[java\]**  [view plain][]  [copy][view plain]

1.  protected void doDispatch(HttpServletRequest request, HttpServletResponse response) \{  
2.          HttpServletRequest processedRequest = request;  
3.          HandlerExecutionChain mappedHandler = null;  
4.          AsyncExecutionChain asyncChain = AsyncExecutionChain.getForCurrentRequest(request);  
5.          try \{  
6.              ModelAndView mv = null;  
7.              Exception dispatchException = null;  
8.              try \{  
9.                  processedRequest = checkMultipart(request);  
10.                 // 确定当前请求的处理器（HandlerExecutionChain 包含Handler和Interceptor列表）  
11.                 mappedHandler = getHandler(processedRequest, false);  
12.                 if (mappedHandler == null || mappedHandler.getHandler() == null) \{  
13.                     noHandlerFound(processedRequest, response);//404异常  
14.                     return;  
15.                 \}  
16.                 // 确定当前请求的处理器适配器  
17.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());  
18.                 //......省略诸多代码......  
19.                 // 调用处理处理器方法，返回ModelAndView对象  
20.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());  
21.             \}//处理返回结果  
22.         processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);  
23.         \}  
24.     \}

相信这个方法大家都很熟了，我删除了一些与当前主体无关的代码，下面我们看getHandler是怎么做的：

**\[java\]**  [view plain][]  [copy][view plain]

1.  protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception \{  
2.          //这里有一个handlerMappings实例变量，如果你看过<mvc:annotation-driven/>那篇文章，相信你就知道这  
3.          //个handlerMappings都包括哪些HandlerMapping实例了？  
4.          for (HandlerMapping hm : this.handlerMappings) \{  
5.              HandlerExecutionChain handler = hm.getHandler(request);  
6.              if (handler != null) \{  
7.                  return handler;  
8.              \}  
9.          \}  
10.         return null;  
11.     \}

[<mvc:annotation-driven/>这篇博客][mvc_annotation-driven] 中说明了在启用该标签时Spring会默认注册RequestMappingHandlerMapping实例在处理@RequestMapping注解，而[@RequestMapping (1)][RequestMapping _1][ ][RequestMapping _1]这篇博客说明了该HandlerMapping是如何处理@RequestMapping注解，以及怎么保存请求映射关系的。下面我们就看RequestMappingHandlerMapping的getHandler方法：

**\[java\]**  [view plain][]  [copy][view plain]

1.  //.....  
2.  //AbstractHandlerMapping  
3.  //.....  
4.  public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception \{  
5.          Object handler = getHandlerInternal(request);//调用下面的方法  
6.          if (handler == null) \{  
7.              handler = getDefaultHandler();  
8.          \}  
9.          if (handler == null) \{  
10.             return null;  
11.         \}  
12.         // Bean name or resolved handler?  
13.         if (handler instanceof String) \{  
14.             String handlerName = (String) handler;  
15.             handler = getApplicationContext().getBean(handlerName);  
16.         \}//返回该请求对应的HandlerExecutionChain（包括处理器方法和拦截器）  
17.         return getHandlerExecutionChain(handler, request);  
18.     \}  
19. //.....  
20. //AbstractHandlerMethodMapping(RequestMappingHandlerMapping 的祖先类)  
21. //返回值是HandlerMethod  
22. //.....  
23. @Override  
24.     protected HandlerMethod getHandlerInternal(HttpServletRequest request) throws Exception \{  
25.         String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);  
26.         ///查找请求路径对应的HandlerMethod实例  
27.         HandlerMethod handlerMethod = lookupHandlerMethod(lookupPath, request);  
28.         //确保HandlerMethod中的handler是处理器实例而不是处理器名字  
29.         return (handlerMethod != null) ? handlerMethod.createWithResolvedBean() : null;  
30.     \}

以上两个方法都是RequestMappingHandlerMapping的祖先类，逻辑很简单，先获取当前请求的路径，然后查找该路径对应的HandlerMethod实例。[@RequestMapping (1)][RequestMapping _1] 这篇博客最后讲到了，RequestMappingHandlerMapping中的两个映射表实例，urlMap和handlerMethods，第一个是路径与RequestMappingInfo的映射，第二个是RequestMappingInfo和HandlerMethod的映射，不用说，lookupHandlerMethod方法肯定是检索这两个变量了:

**\[java\]**  [view plain][]  [copy][view plain]

1.  protected HandlerMethod lookupHandlerMethod(String lookupPath, HttpServletRequest request)\{  
2.          List<Match> matches = new ArrayList<Match>();  
3.          //查找urlMap，获取直接匹配的RequestMappingInfo列表。如  
4.          //URL 是/work/produce/2， @RequestMapping（"/work/produce/2")直接匹配  
5.          List<T> directPathMatches = this.urlMap.get(lookupPath);  
6.          if (directPathMatches != null) \{  
7.              addMatchingMappings(directPathMatches, matches, request);  
8.          \}  
9.          if (matches.isEmpty()) \{ //如果没有找到直接匹配项，遍历所有的注册的RequestMappingInfo来查找  
10.             //遍历所有可能的RequestMappingInfo，找到完全匹配的RequestMappingInfo实例，并生成Match对象  
11.             //添加到Match列表中，Match是RequestMappingInfo和HandlerMethod的临时映射表。  
12.             //举个例子：请求URL可能是GET:/work/produce/2,  
13.             //而@RequestMapping("/work/produce/\{no\}" "GET")此时需要匹配是否是GET请求，以及模式是否匹配  
14.             addMatchingMappings(this.handlerMethods.keySet(), matches, request);  
15.         \}  
16.         if (!matches.isEmpty()) \{ //排序，找出最佳匹配  
17.             Comparator<Match> comparator = new MatchComparator(getMappingComparator(request));  
18.             Collections.sort(matches, comparator);  
19.             Match bestMatch = matches.get(0);  
20.             if (matches.size() > 1) \{ //如果可能的方法多余一个  
21.                 Match secondBestMatch = matches.get(1);//并且两个方法的@RequestMapping内容相同  
22.                 if (comparator.compare(bestMatch, secondBestMatch) == 0) \{ //抛出异常  
23.                     Method m1 = bestMatch.handlerMethod.getMethod();  
24.                     Method m2 = secondBestMatch.handlerMethod.getMethod();  
25.                     throw new IllegalStateException(  
26.                             "Ambiguous handler methods mapped for HTTP path");  
27.                 \}  
28.             \}  
29.             //这里是处理请求路径中的变量，如果/work/produce/\{no\}匹配的/work/produce/2中将no=2  
30.             //添加到Request的属性表中，以便后面@PathVarible参数的处理  
31.             handleMatch(bestMatch.mapping, lookupPath, request);  
32.             return bestMatch.handlerMethod;  
33.         \}  
34.         else \{  
35.             return handleNoMatch(handlerMethods.keySet(), lookupPath, request);  
36.         \}  
37.     \}

在进行URL匹配中，Spring会先查找是否存在直接匹配的RequestMappingInfo实例，即@RequestMapping中的value，method属性完全匹配请求的，如果没有找到通常是存在PathVariable的，如果上面讲的/\{no\}和/222的情况等也是匹配的,  找到匹配项后，需要找出最优解，然后将路径中的变量存入Request的变量表中，我们分别详细的了解下：

**\[java\]**  [view plain][]  [copy][view plain]

1.  private void addMatchingMappings(Collection<T> mappings, List<Match> matches,   
2.                                                                  HttpServletRequest request) \{  
3.          for (T mapping : mappings) \{ //遍历所有的RequestMappingInfo列表  
4.              T match = getMatchingMapping(mapping, request);//获取匹配的RequestMappingInfo实例  
5.              if (match != null) \{ //并生成匹配的RequestMappingInfo实例和对应HandlerMethod的Match实例  
6.                  matches.add(new Match(match, handlerMethods.get(mapping)));  
7.              \}  
8.          \}  
9.      \}

继续看getMatchingMapping的实现：

**\[java\]**  [view plain][]  [copy][view plain]

1.  public RequestMappingInfo getMatchingCondition(HttpServletRequest request) \{  
2.          //查看RequestMappingInfo的所有属性是否匹配  
3.          RequestMethodsRequestCondition methods = methodsCondition.getMatchingCondition(request);  
4.          ParamsRequestCondition params = paramsCondition.getMatchingCondition(request);  
5.          HeadersRequestCondition headers = headersCondition.getMatchingCondition(request);  
6.          ConsumesRequestCondition consumes = consumesCondition.getMatchingCondition(request);  
7.          ProducesRequestCondition produces = producesCondition.getMatchingCondition(request);  
8.          if (methods == null || params == null || headers == null   
9.                                                      || consumes == null || produces == null) \{  
10.             return null;  
11.         \}//我们重点看这个，路径是否匹配  
12.         PatternsRequestCondition patterns = patternsCondition.getMatchingCondition(request);  
13.         if (patterns == null) \{  
14.             return null;  
15.         \}  
16.         RequestConditionHolder custom = customConditionHolder.getMatchingCondition(request);  
17.         if (custom == null) \{  
18.             return null;  
19.         \}  
20.         return new RequestMappingInfo(patterns, methods, params, headers,   
21.                                                         produces, custom.getCondition());  
22.     \}

我们知道RequestMappingInfo就是@RequestMapping注解的抽象，它包含@RequestMapping中的所有属性，因此在查找匹配项时，需要查看所有这些属性是否与请求匹配。我们这里只看路径模式是否匹配，其他属性自行研究，都很简单：

**\[java\]**  [view plain][]  [copy][view plain]

1.  public PatternsRequestCondition getMatchingCondition(HttpServletRequest request) \{  
2.          if (this.patterns.isEmpty()) \{  
3.              return this;  
4.          \}//获取请求路径如/work/produce/2  
5.          String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);  
6.          List<String> matches = new ArrayList<String>();  
7.          //遍历@RequestMapping中的所有模式  
8.          for (String pattern : patterns) \{  
9.              //找出与请求路径匹配的模式，如/work/produce/\{no\}  
10.             String match = getMatchingPattern(pattern, lookupPath);  
11.             if (match != null) \{  
12.                 matches.add(match);  
13.             \}  
14.         \}//排序  
15.         Collections.sort(matches, this.pathMatcher.getPatternComparator(lookupPath));  
16.         //返回匹配的请求模式实例  
17.         return matches.isEmpty() ? null :   
18.             new PatternsRequestCondition(matches, this.urlPathHelper, this.pathMatcher,   
19.                                        this.useSuffixPatternMatch, this.useTrailingSlashMatch);  
20.     \}  
21.   
22. private String getMatchingPattern(String pattern, String lookupPath) \{  
23.         if (pattern.equals(lookupPath)) \{  
24.             return pattern;//直接匹配  
25.         \}  
26.         if (this.useSuffixPatternMatch) \{ //是否使用后缀模式，/abc/de匹配/abc  
27.             boolean hasSuffix = pattern.indexOf('.') != -1;  
28.             if (!hasSuffix && this.pathMatcher.match(pattern + ".\*", lookupPath)) \{  
29.                 return pattern + ".\*";  
30.             \}  
31.         \}//匹配/work/produce/\{no\} 和/work/produce/2  
32.         if (this.pathMatcher.match(pattern, lookupPath)) \{  
33.             return pattern;  
34.         \}//是否使用结尾的斜线匹配  
35.         boolean endsWithSlash = pattern.endsWith("/");  
36.         if (this.useTrailingSlashMatch) \{  
37.             if (!endsWithSlash && this.pathMatcher.match(pattern + "/", lookupPath)) \{  
38.                 return pattern +"/";  
39.             \}  
40.         \}  
41.         return null;  
42.     \}

至于上面的pathMatcher.match方法这里就不分析了，可以自己看看，匹配算法还是比较复杂的，主要是尽可能的全面，除了进行匹配外，还会将路径中的变量保存起来以便@PathVariable参数使用。

以上便是整个的匹配过好麻烦，或许你会说这会不会降低Spring的性能？实话说，在处理首次请求时，效率是很差，但是Spring使用了各种缓存策略，一旦程序进入正轨，效率就非常高了。

### 三、处理器方法的调用 ###

现在我们已经查找到了对应请求的处理器方法，下面我们就看Spring是如何在运行时动态地调用处理器方法的，并传递正确的参数。在doDispatch方法中，我们看到，确定了处理器（方法）后，Spring接着获取了该处理器方法的适配器（HandlerAdapter概念讲解中说到过，用来调用处理器方法的）

**\[java\]**  [view plain][]  [copy][view plain]

1.  protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException \{  
2.          //这个handlerAdapters跟handlerMappings一样，启用<mvc:annoation-driven/>后默认注册  
3.          //RequestMappingHandlerAdapter（since3.1）  
4.          for (HandlerAdapter ha : this.handlerAdapters) \{  
5.              if (ha.supports(handler)) \{  
6.                  return ha;  
7.              \}  
8.          \}  
9.          throw new ServletException("No adapter for handler \[" + handler +  
10.                 "\]: Does your handler implement a supported interface like Controller?");  
11.     \}  
12. //是否支持当前处理器，其实就是看看处理器是不是HandlerMethod实例  
13. public final boolean supports(Object handler) \{  
14.         return handler instanceof HandlerMethod && supportsInternal((HandlerMethod) handler);  
15.     \}

获取了HandlerAdapter后，Spring就会调用handlerAdapter实例的handle方法，并返回ModelAndView实例：

**\[java\]**  [view plain][]  [copy][view plain]

1.  @Override  
2.      protected final ModelAndView handleInternal(HttpServletRequest request,  
3.              HttpServletResponse response, HandlerMethod handlerMethod) throws Exception \{  
4.          //如果HandlerMethod所属的处理器被@SessionAttribute注解标记了  
5.          if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) \{  
6.           //设置响应头信息，防止缓存以便Session属性的管理  
7.           checkAndPrepare(request, response, this.cacheSecondsForSessionAttributeHandlers, true);  
8.          \}  
9.          else \{  
10.             //设置响应头，缓存默认时间  
11.             checkAndPrepare(request, response, true);  
12.         \}  
13.         //要求在Session级别上进行同步，即同一个客户端的多个请求需要阻塞调用该处理器方法  
14.         if (this.synchronizeOnSession) \{  
15.             HttpSession session = request.getSession(false);  
16.             if (session != null) \{  
17.                 Object mutex = WebUtils.getSessionMutex(session);  
18.                 synchronized (mutex) \{ //调用  
19.                     return invokeHandleMethod(request, response, handlerMethod);  
20.                 \}  
21.             \}  
22.         \}//调用  
23.         return invokeHandleMethod(request, response, handlerMethod);  
24.     \}

我们接着看invokeHandlerMethod方法：

**\[java\]**  [view plain][]  [copy][view plain]

1.  private ModelAndView invokeHandleMethod(HttpServletRequest request,  
2.              HttpServletResponse response, HandlerMethod handlerMethod) throws Exception \{  
3.          //包装请求和响应对象  
4.          ServletWebRequest webRequest = new ServletWebRequest(request, response);  
5.          //获取与HandlerMethod对应的DataBinderFactory。  
6.          WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);  
7.          //获取处理器方法所属处理器中被@ModelAttribute标记，但是没有被@RequestMapping标记的方法  
8.          ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);  
9.          //创建请求映射方法，并将HandlerAdapter中的参数解析器列表和返回值处理器列表传递给它。  
10.         ServletInvocableHandlerMethod requestMappingMethod =   
11.                                       createRequestMappingMethod(handlerMethod, binderFactory);  
12.         //创建ModelAndViewContainer  
13.         ModelAndViewContainer mavContainer = new ModelAndViewContainer();  
14.         mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));  
15.         modelFactory.initModel(webRequest, mavContainer, requestMappingMethod);  
16.         mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);  
17.         //获取并设置当前请求的异步调用链实例  
18.         AsyncExecutionChain chain = AsyncExecutionChain.getForCurrentRequest(request);  
19.         chain.addDelegatingCallable(getAsyncCallable(mavContainer, modelFactory, webRequest));  
20.         chain.setAsyncWebRequest(createAsyncWebRequest(request, response));  
21.         chain.setTaskExecutor(this.taskExecutor);  
22.         //调用该处理器方法。  
23.         requestMappingMethod.invokeAndHandle(webRequest, mavContainer);  
24.   
25.         if (chain.isAsyncStarted()) \{  
26.             return null;  
27.         \}  
28.         //获取并返回ModelAndView  
29.         return getModelAndView(mavContainer, modelFactory, webRequest);  
30.     \}

关于异步调用链那块我们暂不关心，后续文章会专题讨论。从上面代码可以看到，在调用方法前，分别检查了处理器中存在的@InitBinder注解的方法和@ModelAttribute注解的方法，InitBinder方法用于类型转化，如将String转化为Date类型等，可以通过@InitBinder方法实现，感兴趣可以自己看看，不在详细分析。至于@ModelAttribute注解的方法，其返回值会被放入Model对象中供视图使用。下面我们看invokeAndHandle方法：

**\[java\]**  [view plain][]  [copy][view plain]

1.  public final void invokeAndHandle(ServletWebRequest webRequest,  
2.              ModelAndViewContainer mavContainer, Object... providedArgs) throws Exception \{  
3.          //....省略异步调用方法，暂不考虑  
4.          Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);  
5.          //....省略几行代码，暂不考虑  
6.          try \{ //处理返回结果  
7.              this.returnValueHandlers.handleReturnValue(returnValue,   
8.                                      getReturnValueType(returnValue), mavContainer, webRequest);  
9.          \}  
10.     \}

接着我们看下invokeForRequest方法：----we are so close.

**\[java\]**  [view plain][]  [copy][view plain]

1.  public final Object invokeForRequest(NativeWebRequest request,  
2.                                           ModelAndViewContainer mavContainer,  
3.                                           Object... providedArgs) throws Exception \{  
4.          //获取方法参数值。  
5.          Object\[\] args = getMethodArgumentValues(request, mavContainer, providedArgs);  
6.          //传递参数值，调用，返回返回值  
7.          Object returnValue = invoke(args);  
8.          return returnValue;  
9.      \}

啊哈上面的代码貌似很简单，实则不是，重点就在getMethodArgumentValues方法，这才是我们这片文章的真正主题呢。打起精神来了：

**\[java\]**  [view plain][]  [copy][view plain]

1.  private Object\[\] getMethodArgumentValues(  
2.              NativeWebRequest request, ModelAndViewContainer mavContainer,  
3.              Object... providedArgs) throws Exception \{  
4.          //获取处理器方法的MethodParameter数组，就是方法的“参数定义”列表。  
5.          MethodParameter\[\] parameters = getMethodParameters();  
6.          Object\[\] args = new Object\[parameters.length\];  
7.          //遍历所有方法参数  
8.          for (int i = 0; i < parameters.length; i++) \{  
9.              MethodParameter parameter = parameters\[i\];  
10.             parameter.initParameterNameDiscovery(parameterNameDiscoverer);  
11.             //确定泛型参数的类型  
12.             GenericTypeResolver.resolveParameterType(parameter, getBean().getClass());  
13.             //根据提供的参数值，解析当前参数的值  
14.             args\[i\] = resolveProvidedArgument(parameter, providedArgs);  
15.             if (args\[i\] != null) \{  
16.                 continue;  
17.             \}  
18.             //根据内置的参数解析器（上面的图片中列出了），来解析当前的参数值  
19.             if (argumentResolvers.supportsParameter(parameter)) \{  
20.                 try \{  
21.                     args\[i\] = argumentResolvers.resolveArgument(parameter, mavContainer,  
22.                                                                  request, dataBinderFactory);  
23.                     continue;  
24.                 \}  
25.             \}  
26.             //如果参数值依旧为空，抛出异常。  
27.             if (args\[i\] == null) \{  
28.          String msg = getArgumentResolutionErrorMessage("No suitable resolver for argument", i);  
29.          throw new IllegalStateException(msg);  
30.             \}  
31.         \}  
32.         return args;  
33.     \}

该方法是HandlerMethod中的方法，因此可以调用getMethodParameters()方法获取参数列表，然后遍历这些参数，分别用参数解析器来解析当前参数值，其中，argumentResolvers是HandlerMethodArgumentResolverComposite，概念讲解中已经阐述，它包含了所有的参数解析器的列表，以及参数类型和解析器的映射表，我们不妨看看到底什么怎么回事：

**\[java\]**

[144924_lbqN_258230.png]: /images/20211211/a47de95d4e2943a5823cba15dc453234.png
[144944_3CqX_258230.png]: /images/20211211/92adf7ec0bcc4d5f88be55f3b6398e7b.png
[145132_jtRf_258230.png]: /images/20211211/c236fc57a68f4287ad0049f5252b5bc0.png
[145150_5Vp2_258230.png]: /images/20211211/5fe826e4ef99422aa4f5396441580183.png
[view plain]: http://blog.csdn.net/J080624/article/details/56278869#
[mvc_annotation-driven]: http://blog.csdn.net/J080624/article/details/56276785
[RequestMapping _1]: http://blog.csdn.net/j080624/article/details/56278461