参照网址

一、执行流程

1、用户发送请求至前端控制器DispatcherServlet
2、DispatcherServlet收到请求调用处理器映射器HandlerMapping。
3、处理器映射器根据请求url找到具体的处理器，生成处理器执行链HandlerExecutionChain(包括处理器对象和处理器拦截器)一并返回给DispatcherServlet。
4、DispatcherServlet根据处理器Handler获取处理器适配器HandlerAdapter执行HandlerAdapter处理一系列的操作，如：参数封装，数据格式转换，数据验证等操作
5、执行处理器Handler(Controller，也叫页面控制器)。
6、Handler执行完成返回ModelAndView
7、HandlerAdapter将Handler执行结果ModelAndView返回到DispatcherServlet
8、DispatcherServlet将ModelAndView传给ViewReslover视图解析器
9、ViewReslover解析后返回具体View
10、DispatcherServlet对View进行渲染视图（即将模型数据model填充至视图中）。
11、DispatcherServlet响应用户。

image.png

二、工作机制

在容器初始化时会建立所有url和controller的对应关系，保存到Map中。tomcat启动时会通知spring初始化容器(加载bean的定义信息和初始化所有单例bean)，然后springmvc会遍历容器中的bean，获取每一个controller中的所有方法访问的url,然后将url和Controller保存到一个Map中；
这样就可以根据request快速定位到Controller，因为最终处理request的是Controller中的方法，Map中只保留了url和Controller中的对应关系，所以要根据request的url进一步确认Controller中的method，这一步工作的原理就是拼接Controller的url(Controller上@RequestMapping的值)和方法的url(method上@RequestMapping的值)，与request的url进行匹配,找到匹配的那个方法；
确定处理请求的method后，接下来的任务就是参数绑定，把request中参数绑定到方法的形式参数上，这一步是整个请求处理过程中最复杂的一个步骤。SpringMVC提供了两种request参数与方法形参的绑定方法：
① 通过注解进行绑定 @RequestParam
② 通过参数名称进行绑定.
使用注解进行绑定，我们只要在方法参数前面声明@RequestParam(“a”)，就可以将request中参数a的值绑定到方法的该参数上。使用参数名称进行绑定的前提是必须要获取方法中参数的名称，Java反射只提供了获取方法的参数的类型，并没有提供获取参数名称的方法。SpringMVC解决这个问题的方法是用asm框架读取字节码文件，来获取方法的参数名称。asm框架是一个字节码操作框架，关于asm更多介绍可以参考它的官网。个人建议，使用注解来完成参数绑定，这样就可以省去asm框架的读取字节码的操作。

三、源代码分析

我们根据工作机制中三部分来分析springmvc的源代码。
其一 ApplicationContext初始化时建立所有url和controller类的对应关系(用Map保存)；
其二 根据请求url找到对应的controller，并从controller中找到处理请求的方法；
其三 request参数绑定到方法的形参，执行方法处理请求,并返回结果视图；

第一步、建立Map的关系

我们首先看第一个步骤，也就是建立Map关系的部分。第一部分的入口类为ApplicationObjectSupport的setApplicationContext方法。setApplicationContext方法中核心部分就是初始化容器initApplicationContext(context)，子类AbstractDetectingUrlHandlerMapping实现了该方法，所以我们直接看子类中的初始化容器方法。

  1. public void initApplicationContext() throws ApplicationContextException {
  2.         super.initApplicationContext();
  3.         detectHandlers();
  4.     }
  5.     /**
  6. 　　  * 建立当前ApplicationContext中的所有controller和url的对应关系
  7. 　　　 */
  8.     protected void detectHandlers() throws BeansException {
  9.         if (logger.isDebugEnabled()) {
  10.             logger.debug("Looking for URL mappings in application context: " + getApplicationContext());
  11.         }
  12. 　　　　 // 获取ApplicationContext容器中所有bean的Name
  13.         String[] beanNames = (this.detectHandlersInAncestorContexts ?
  14.                 BeanFactoryUtils.beanNamesForTypeIncludingAncestors(getApplicationContext(), Object.class) :
  15.                 getApplicationContext().getBeanNamesForType(Object.class));
  17.         // 遍历beanNames,并找到这些bean对应的url
  18.         for (String beanName : beanNames) {
  19. 　　　　　　 // 找bean上的所有url(controller上的url+方法上的url),该方法由对应的子类实现
  20.             String[] urls = determineUrlsForHandler(beanName);
  21.             if (!ObjectUtils.isEmpty(urls)) {
  22.                 // 保存urls和beanName的对应关系,put it to Map<urls,beanName>,该方法在父类AbstractUrlHandlerMapping中实现
  23.                 registerHandler(urls, beanName);
  24.             }
  25.             else {
  26.                 if (logger.isDebugEnabled()) {
  27.                     logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
  28.                 }
  29.             }
  30.         }
  31.     }
  32.     /** 获取controller中所有方法的url,由子类实现,典型的模板模式 **/
  33. 　　protected abstract String[] determineUrlsForHandler(String beanName);

determineUrlsForHandler(String beanName)方法的作用是获取每个controller中的url，不同的子类有不同的实现,这是一个典型的模板设计模式。因为开发中我们用的最多的就是用注解来配置controller中的url，DefaultAnnotationHandlerMapping是AbstractDetectingUrlHandlerMapping的子类，处理注解形式的url映射。所以我们这里以DefaultAnnotationHandlerMapping来进行分析。我们看DefaultAnnotationHandlerMapping是如何查beanName上所有映射的url。

  1. /**
  2. 　　 * 获取controller中所有的url
  3.      */
  4. 　　protected String[] determineUrlsForHandler(String beanName) {
  5.        // 获取ApplicationContext容器 
  6. 　　　　ApplicationContext context = getApplicationContext();
  7.         //从容器中获取controller
  8. 　　　　 Class<?> handlerType = context.getType(beanName);
  9. 　　　　 // 获取controller上的@RequestMapping注解
  10.         RequestMapping mapping = context.findAnnotationOnBean(beanName, RequestMapping.class);
  11.         if (mapping != null) { // controller上有注解
  12.             this.cachedMappings.put(handlerType, mapping);
  13. 　　　　　　  // 返回结果集
  14.             Set<String> urls = new LinkedHashSet<String>();
  15. 　　　　　　  // controller的映射url
  16.             String[] typeLevelPatterns = mapping.value();
  17.             if (typeLevelPatterns.length > 0) { // url>0
  18.                 // 获取controller中所有方法及方法的映射url
  19.                 String[] methodLevelPatterns = determineUrlsForHandlerMethods(handlerType, true);
  20.                 for (String typeLevelPattern : typeLevelPatterns) {
  21.                     if (!typeLevelPattern.startsWith("/")) {
  22.                         typeLevelPattern = "/" + typeLevelPattern;
  23.                     }
  24.                     boolean hasEmptyMethodLevelMappings = false;
  25.                     for (String methodLevelPattern : methodLevelPatterns) {
  26.                         if (methodLevelPattern == null) {
  27.                             hasEmptyMethodLevelMappings = true;
  28.                         }
  29.                         else {
  30. 　　　　　　　　　　　　　　　　// controller的映射url+方法映射的url
  31.                             String combinedPattern = getPathMatcher().combine(typeLevelPattern, methodLevelPattern);
  32. 　　　　　　　　　　　　　　　　// 保存到set集合中
  33. 　　　　　　　　　　　　　　　　 addUrlsForPath(urls, combinedPattern);
  34.                         }
  35.                     }
  36.                     if (hasEmptyMethodLevelMappings ||
  37.                             org.springframework.web.servlet.mvc.Controller.class.isAssignableFrom(handlerType)) {
  38.                         addUrlsForPath(urls, typeLevelPattern);
  39.                     }
  40.                 }
  41. 　　　　　　　　　// 以数组形式返回controller上的所有url
  42.                 return StringUtils.toStringArray(urls);
  43.             }
  44.             else {
  45.                 // controller上的@RequestMapping映射url为空串,直接找方法的映射url
  46.                 return determineUrlsForHandlerMethods(handlerType, false);
  47.             }
  48.         } // controller上没@RequestMapping注解
  49.         else if (AnnotationUtils.findAnnotation(handlerType, Controller.class) != null) {
  50.             // 获取controller中方法上的映射url
  51.             return determineUrlsForHandlerMethods(handlerType, false);
  52.         }
  53.         else {
  54.             return null;
  55.         }
  56.     }

到这里HandlerMapping组件就已经建立所有url和controller的对应关系。

第二步、根据访问url找到对应controller中处理请求的方法

下面我们开始分析第二个步骤,第二个步骤是由请求触发的，所以入口为DispatcherServlet.DispatcherServlet的核心方法为doService()，doService()中的核心逻辑由doDispatch()实现，我们查看doDispatch()的源代码。

  1. /** 中央控制器,控制请求的转发 **/
  2. protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
  3.         HttpServletRequest processedRequest = request;
  4.         HandlerExecutionChain mappedHandler = null;
  5.         int interceptorIndex = -1;
  7.         try {
  8.             ModelAndView mv;
  9.             boolean errorView = false;
  10.             try {
  11. 　　　　　　　　　// 1.检查是否是文件上传的请求
  12.                 processedRequest = checkMultipart(request);
  14.                 // 2.取得处理当前请求的controller,这里也称为hanlder,处理器,第一个步骤的意义就在这里体现了.这里并不是直接返回controller,而是返回的HandlerExecutionChain请求处理器链对象,该对象封装了handler和interceptors.
  15.                 mappedHandler = getHandler(processedRequest, false);
  16. 　　　　　　　　　// 如果handler为空,则返回404
  17.                 if (mappedHandler == null || mappedHandler.getHandler() == null) {
  18.                     noHandlerFound(processedRequest, response);
  19.                     return;
  20.                 }
  21.                 //3. 获取处理request的处理器适配器handler adapter 
  22.                 HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
  23.                 // 处理 last-modified 请求头
  24.                 String method = request.getMethod();
  25.                 boolean isGet = "GET".equals(method);
  26.                 if (isGet || "HEAD".equals(method)) {
  27.                     long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
  28.                     if (logger.isDebugEnabled()) {
  29.                         String requestUri = urlPathHelper.getRequestUri(request);
  30.                         logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
  31.                     }
  32.                     if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
  33.                         return;
  34.                     }
  35.                 }
  37.                 // 4.拦截器的预处理方法
  38.                 HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
  39.                 if (interceptors != null) {
  40.                     for (int i = 0; i < interceptors.length; i++) {
  41.                         HandlerInterceptor interceptor = interceptors[i];
  42.                         if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
  43.                             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
  44.                             return;
  45.                         }
  46.                         interceptorIndex = i;
  47.                     }
  48.                 }
  50.                 // 5.实际的处理器处理请求,返回结果视图对象
  51.                 mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
  53.                 // 结果视图对象的处理
  54.                 if (mv != null && !mv.hasView()) {
  55.                     mv.setViewName(getDefaultViewName(request));
  56.                 }
  58.                 // 6.拦截器的后处理方法
  59.                 if (interceptors != null) {
  60.                     for (int i = interceptors.length - 1; i >= 0; i--) {
  61.                         HandlerInterceptor interceptor = interceptors[i];
  62.                         interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
  63.                     }
  64.                 }
  65.             }
  66.             catch (ModelAndViewDefiningException ex) {
  67.                 logger.debug("ModelAndViewDefiningException encountered", ex);
  68.                 mv = ex.getModelAndView();
  69.             }
  70.             catch (Exception ex) {
  71.                 Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
  72.                 mv = processHandlerException(processedRequest, response, handler, ex);
  73.                 errorView = (mv != null);
  74.             }
  77.             if (mv != null && !mv.wasCleared()) {
  78.                 render(mv, processedRequest, response);
  79.                 if (errorView) {
  80.                     WebUtils.clearErrorRequestAttributes(request);
  81.                 }
  82.             }
  83.             else {
  84.                 if (logger.isDebugEnabled()) {
  85.                     logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
  86.                             "': assuming HandlerAdapter completed request handling");
  87.                 }
  88.             }
  90.             // 请求成功响应之后的方法
  91.             triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
  92.         }

第2步:getHandler(processedRequest)方法实际上就是从HandlerMapping中找到url和controller的对应关系。这也就是第一个步骤:建立Map的意义。我们知道，最终处理request的是controller中的方法，我们现在只是知道了controller，还要进一步确认controller中处理request的方法。由于下面的步骤和第三个步骤关系更加紧密，直接转到第三个步骤。

第三步、反射调用处理请求的方法，返回结果视图

上面的方法中，第2步其实就是从第一个步骤中的Map中取得Controller，然后经过拦截器的预处理方法，到最核心的部分—第5步调用controller的方法处理请求。在第2步中我们可以知道处理request的Controller，第5步就是要根据url确定Controller中处理请求的方法，然后通过反射获取该方法上的注解和参数，解析方法和参数上的注解，最后反射调用方法获取ModelAndView结果视图。因为上面采用注解url形式说明的，所以我们这里继续以注解处理器适配器来说明。第5步调用的就是AnnotationMethodHandlerAdapter的handle().handle()中的核心逻辑由invokeHandlerMethod(request, response, handler)实现。

  1. /** 获取处理请求的方法,执行并返回结果视图 **/
  2. protected ModelAndView invokeHandlerMethod(HttpServletRequest request, HttpServletResponse response, Object handler)
  3.             throws Exception {
  4. 　　　　 // 1.获取方法解析器
  5.         ServletHandlerMethodResolver methodResolver = getMethodResolver(handler);
  6. 　　　　 // 2.解析request中的url,获取处理request的方法 
  7.         Method handlerMethod = methodResolver.resolveHandlerMethod(request);
  8. 　　　　 // 3.方法调用器
  9.         ServletHandlerMethodInvoker methodInvoker = new ServletHandlerMethodInvoker(methodResolver);
  10.         ServletWebRequest webRequest = new ServletWebRequest(request, response);
  11.         ExtendedModelMap implicitModel = new BindingAwareModelMap();
  12. 　　　　 // 4.执行方法
  13.         Object result = methodInvoker.invokeHandlerMethod(handlerMethod, handler, webRequest, implicitModel);
  14. 　　　　 // 5.封装结果视图
  15.         ModelAndView mav =
  16.                 methodInvoker.getModelAndView(handlerMethod, handler.getClass(), result, implicitModel, webRequest);
  17.         methodInvoker.updateModelAttributes(handler, (mav != null ? mav.getModel() : null), implicitModel, webRequest);
  18.         return mav;
  19.     }

这一部分的核心就在2和4了。先看第2步，通过request找controller的处理方法。实际上就是拼接controller的url和方法的url，与request的url进行匹配，找到匹配的方法。

  1. /** 根据url获取处理请求的方法 **/
  2. public Method resolveHandlerMethod(HttpServletRequest request) throws ServletException {
  3. 　　　　　　  // 如果请求url为,localhost:8080/springmvc/helloWorldController/say.action, 则lookupPath=helloWorldController/say.action
  4.             String lookupPath = urlPathHelper.getLookupPathForRequest(request);
  5.             Comparator<String> pathComparator = pathMatcher.getPatternComparator(lookupPath);
  6.             Map<RequestSpecificMappingInfo, Method> targetHandlerMethods = new LinkedHashMap<RequestSpecificMappingInfo, Method>();
  7.             Set<String> allowedMethods = new LinkedHashSet<String>(7);
  8.             String resolvedMethodName = null;
  9. 　　　　　　 // 遍历controller上的所有方法,获取url匹配的方法
  10.             for (Method handlerMethod : getHandlerMethods()) {
  11.                 RequestSpecificMappingInfo mappingInfo = new RequestSpecificMappingInfo(this.mappings.get(handlerMethod));
  12.                 boolean match = false;
  13.                 if (mappingInfo.hasPatterns()) {// 获取方法上的url
  14.                     for (String pattern : mappingInfo.getPatterns()) { // 方法上可能有多个url,springmvc支持方法映射多个url
  15.                         if (!hasTypeLevelMapping() && !pattern.startsWith("/")) {
  16.                             pattern = "/" + pattern;
  17.                         }
  18. 　　　　　　　　　　　　　　// 获取controller上的映射和url和方法上的url,拼凑起来与lookupPath是否匹配
  19.                         String combinedPattern = getCombinedPattern(pattern, lookupPath, request);
  20.                         if (combinedPattern != null) { 
  21.                             if (mappingInfo.matches(request)) {
  22.                                 match = true;
  23.                                 mappingInfo.addMatchedPattern(combinedPattern);
  24.                             }
  25.                             else {
  26.                                 if (!mappingInfo.matchesRequestMethod(request)) {
  27.                                     allowedMethods.addAll(mappingInfo.methodNames());
  28.                                 }
  29.                                 break;
  30.                             }
  31.                         }
  32.                     }
  33.                     mappingInfo.sortMatchedPatterns(pathComparator);
  34.                 }
  35.                 else if (useTypeLevelMapping(request)) {
  36.               　// other 
  37.         }

通过上面的代码，已经可以找到处理request的Controller中的方法了，现在看如何解析该方法上的参数,并调用该方法。也就是执行方法这一步。执行方法这一步最重要的就是获取方法的参数，然后我们就可以反射调用方法了。

  1.     public final Object invokeHandlerMethod(Method handlerMethod, Object handler,
  2.             NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
  4. 　　　　 Method handlerMethodToInvoke = BridgeMethodResolver.findBridgedMethod(handlerMethod);
  5.         try {
  6.             boolean debug = logger.isDebugEnabled();
  7. 　　　　　　　// 处理方法上的其他注解
  8.             for (String attrName : this.methodResolver.getActualSessionAttributeNames()) {
  9.                 Object attrValue = this.sessionAttributeStore.retrieveAttribute(webRequest, attrName);
  10.                 if (attrValue != null) {
  11.                     implicitModel.addAttribute(attrName, attrValue);
  12.                 }
  13.             }
  14.             for (Method attributeMethod : this.methodResolver.getModelAttributeMethods()) {
  15.                 Method attributeMethodToInvoke = BridgeMethodResolver.findBridgedMethod(attributeMethod);
  16.                 Object[] args = resolveHandlerArguments(attributeMethodToInvoke, handler, webRequest, implicitModel);
  17.                 if (debug) {
  18.                     logger.debug("Invoking model attribute method: " + attributeMethodToInvoke);
  19.                 }
  20.                 String attrName = AnnotationUtils.findAnnotation(attributeMethod, ModelAttribute.class).value();
  21.                 if (!"".equals(attrName) && implicitModel.containsAttribute(attrName)) {
  22.                     continue;
  23.                 }
  24.                 ReflectionUtils.makeAccessible(attributeMethodToInvoke);
  25.                 Object attrValue = attributeMethodToInvoke.invoke(handler, args);
  26.                 if ("".equals(attrName)) {
  27.                     Class resolvedType = GenericTypeResolver.resolveReturnType(attributeMethodToInvoke, handler.getClass());
  28.                     attrName = Conventions.getVariableNameForReturnType(attributeMethodToInvoke, resolvedType, attrValue);
  29.                 }
  30.                 if (!implicitModel.containsAttribute(attrName)) {
  31.                     implicitModel.addAttribute(attrName, attrValue);
  32.                 }
  33.             }
  34. 　　　　　　　// 核心代码,获取方法上的参数值
  35.             Object[] args = resolveHandlerArguments(handlerMethodToInvoke, handler, webRequest, implicitModel);
  36.             if (debug) {
  37.                 logger.debug("Invoking request handler method: " + handlerMethodToInvoke);
  38.             }
  39.             ReflectionUtils.makeAccessible(handlerMethodToInvoke);
  40.             return handlerMethodToInvoke.invoke(handler, args);
  41.         }

resolveHandlerArguments方法实现代码比较长，它最终要实现的目的就是：完成request中的参数和方法参数上数据的绑定。
SpringMVC中提供两种request参数到方法中参数的绑定方式：
① 通过注解进行绑定 @RequestParam
② 通过参数名称进行绑定
使用注解进行绑定，我们只要在方法参数前面声明@RequestParam(“a”)，就可以将request中参数a的值绑定到方法的该参数上。使用参数名称进行绑定的前提是必须要获取方法中参数的名称，Java反射只提供了获取方法的参数的类型，并没有提供获取参数名称的方法。SpringMVC解决这个问题的方法是用asm框架读取字节码文件,来获取方法的参数名称。asm框架是一个字节码操作框架，关于asm更多介绍可以参考它的官网。个人建议，使用注解来完成参数绑定，这样就可以省去asm框架的读取字节码的操作。

  1. private Object[] resolveHandlerArguments(Method handlerMethod, Object handler,
  2.             NativeWebRequest webRequest, ExtendedModelMap implicitModel) throws Exception {
  3. 　　　　 // 1.获取方法参数类型的数组
  4.         Class[] paramTypes = handlerMethod.getParameterTypes();
  5. 　　　　// 声明数组,存参数的值
  6.         Object[] args = new Object[paramTypes.length];
  7. 　　　　//2.遍历参数数组,获取每个参数的值
  8.         for (int i = 0; i < args.length; i++) {
  9.             MethodParameter methodParam = new MethodParameter(handlerMethod, i);
  10.             methodParam.initParameterNameDiscovery(this.parameterNameDiscoverer);
  11.             GenericTypeResolver.resolveParameterType(methodParam, handler.getClass());
  12.             String paramName = null;
  13.             String headerName = null;
  14.             boolean requestBodyFound = false;
  15.             String cookieName = null;
  16.             String pathVarName = null;
  17.             String attrName = null;
  18.             boolean required = false;
  19.             String defaultValue = null;
  20.             boolean validate = false;
  21.             int annotationsFound = 0;
  22.             Annotation[] paramAnns = methodParam.getParameterAnnotations();
  23. 　　　　　　 // 处理参数上的注解
  24.             for (Annotation paramAnn : paramAnns) {
  25.                 if (RequestParam.class.isInstance(paramAnn)) {
  26.                     RequestParam requestParam = (RequestParam) paramAnn;
  27.                     paramName = requestParam.value();
  28.                     required = requestParam.required();
  29.                     defaultValue = parseDefaultValueAttribute(requestParam.defaultValue());
  30.                     annotationsFound++;
  31.                 }
  32.                 else if (RequestHeader.class.isInstance(paramAnn)) {
  33.                     RequestHeader requestHeader = (RequestHeader) paramAnn;
  34.                     headerName = requestHeader.value();
  35.                     required = requestHeader.required();
  36.                     defaultValue = parseDefaultValueAttribute(requestHeader.defaultValue());
  37.                     annotationsFound++;
  38.                 }
  39.                 else if (RequestBody.class.isInstance(paramAnn)) {
  40.                     requestBodyFound = true;
  41.                     annotationsFound++;
  42.                 }
  43.                 else if (CookieValue.class.isInstance(paramAnn)) {
  44.                     CookieValue cookieValue = (CookieValue) paramAnn;
  45.                     cookieName = cookieValue.value();
  46.                     required = cookieValue.required();
  47.                     defaultValue = parseDefaultValueAttribute(cookieValue.defaultValue());
  48.                     annotationsFound++;
  49.                 }
  50.                 else if (PathVariable.class.isInstance(paramAnn)) {
  51.                     PathVariable pathVar = (PathVariable) paramAnn;
  52.                     pathVarName = pathVar.value();
  53.                     annotationsFound++;
  54.                 }
  55.                 else if (ModelAttribute.class.isInstance(paramAnn)) {
  56.                     ModelAttribute attr = (ModelAttribute) paramAnn;
  57.                     attrName = attr.value();
  58.                     annotationsFound++;
  59.                 }
  60.                 else if (Value.class.isInstance(paramAnn)) {
  61.                     defaultValue = ((Value) paramAnn).value();
  62.                 }
  63.                 else if ("Valid".equals(paramAnn.annotationType().getSimpleName())) {
  64.                     validate = true;
  65.                 }
  66.             }
  67. 　　
  68.             if (annotationsFound > 1) {
  69.                 throw new IllegalStateException("Handler parameter annotations are exclusive choices - " +
  70.                         "do not specify more than one such annotation on the same parameter: " + handlerMethod);
  71.             }
  73.             if (annotationsFound == 0) {// 如果没有注解
  74.                 Object argValue = resolveCommonArgument(methodParam, webRequest);
  75.                 if (argValue != WebArgumentResolver.UNRESOLVED) {
  76.                     args[i] = argValue;
  77.                 }
  78.                 else if (defaultValue != null) {
  79.                     args[i] = resolveDefaultValue(defaultValue);
  80.                 }
  81.                 else {
  82.                     Class paramType = methodParam.getParameterType();
  83. 　　　　　　　　　　  // 将方法声明中的Map和Model参数,放到request中,用于将数据放到request中带回页面
  84.                     if (Model.class.isAssignableFrom(paramType) || Map.class.isAssignableFrom(paramType)) {
  85.                         args[i] = implicitModel;
  86.                     }
  87.                     else if (SessionStatus.class.isAssignableFrom(paramType)) {
  88.                         args[i] = this.sessionStatus;
  89.                     }
  90.                     else if (HttpEntity.class.isAssignableFrom(paramType)) {
  91.                         args[i] = resolveHttpEntityRequest(methodParam, webRequest);
  92.                     }
  93.                     else if (Errors.class.isAssignableFrom(paramType)) {
  94.                         throw new IllegalStateException("Errors/BindingResult argument declared " +
  95.                                 "without preceding model attribute. Check your handler method signature!");
  96.                     }
  97.                     else if (BeanUtils.isSimpleProperty(paramType)) {
  98.                         paramName = "";
  99.                     }
  100.                     else {
  101.                         attrName = "";
  102.                     }
  103.                 }
  104.             }
  105. 　　　　　　　// 从request中取值,并进行赋值操作
  106.             if (paramName != null) {
  107. 　　　　　　　　　// 根据paramName从request中取值,如果没有通过RequestParam注解指定paramName,则使用asm读取class文件来获取paramName
  108.                 args[i] = resolveRequestParam(paramName, required, defaultValue, methodParam, webRequest, handler);
  109.             }
  110.             else if (headerName != null) {
  111.                 args[i] = resolveRequestHeader(headerName, required, defaultValue, methodParam, webRequest, handler);
  112.             }
  113.             else if (requestBodyFound) {
  114.                 args[i] = resolveRequestBody(methodParam, webRequest, handler);
  115.             }
  116.             else if (cookieName != null) {
  117.                 args[i] = resolveCookieValue(cookieName, required, defaultValue, methodParam, webRequest, handler);
  118.             }
  119.             else if (pathVarName != null) {
  120.                 args[i] = resolvePathVariable(pathVarName, methodParam, webRequest, handler);
  121.             }
  122.             else if (attrName != null) {
  123.                 WebDataBinder binder =
  124.                         resolveModelAttribute(attrName, methodParam, implicitModel, webRequest, handler);
  125.                 boolean assignBindingResult = (args.length > i + 1 && Errors.class.isAssignableFrom(paramTypes[i + 1]));
  126.                 if (binder.getTarget() != null) {
  127.                     doBind(binder, webRequest, validate, !assignBindingResult);
  128.                 }
  129.                 args[i] = binder.getTarget();
  130.                 if (assignBindingResult) {
  131.                     args[i + 1] = binder.getBindingResult();
  132.                     i++;
  133.                 }
  134.                 implicitModel.putAll(binder.getBindingResult().getModel());
  135.             }
  136.         }
  137. 　　　　 // 返回参数值数组
  138.         return args;
  139.     }

关于asm框架获取方法参数的部分，这里就不再进行分析了。感兴趣的话F3进去就能看到这个过程。
到这里,方法的参数值列表也获取到了，就可以直接进行方法的调用了。整个请求过程中最复杂的一步就是在这里了。ok，到这里整个请求处理过程的关键步骤都分析完了。理解了SpringMVC中的请求处理流程,整个代码还是比较清晰的。

四、SpringMvc的优化

上面我们已经对SpringMVC的工作原理和源码进行了分析,在这个过程发现了几个优化点：
1、Controller如果能保持单例，尽量使用单例,这样可以减少创建对象和回收对象的开销。也就是说，如果Controller的类变量和实例变量可以以方法形参声明的尽量以方法的形参声明，不要以类变量和实例变量声明，这样可以避免线程安全问题。
2、处理request的方法中的形参务必加上@RequestParam注解，这样可以避免SpringMVC使用asm框架读取class文件获取方法参数名的过程。即便 SpringMVC对读取出的方法参数名进行了缓存，如果不要读取class文件当然是更加好。
3、阅读源码的过程中,发现SpringMVC并没有对处理url的方法进行缓存，也就是说每次都要根据请求url去匹配Controller中的方法url，如果把url和method的关系缓存起来，会不会带来性能上的提升呢？有点恶心的是，负责解析url和method对应关系的ServletHandlerMethodResolver是一个private的内部类，不能直接继承该类增强代码，必须要该代码后重新编译。当然，如果缓存起来，必须要考虑缓存的线程安全问题。
后续笔者将会根据自己的理解补充相应体会，及时更新新版本带来的好处~
更新：SpringMVC 版本4以上的流程

image.png

五、Demo示例

为了简单起见，再一个就是现在这个年代也没有啥项目使用JSP了。所以本次分析使用SpringBoot结合thymeleaf来搞

  • 首先pom文件依赖

    1.  <parent>
    2.      <groupId>org.springframework.boot</groupId>
    3.      <artifactId>spring-boot-starter-parent</artifactId>
    4.      <version>2.0.0.RELEASE</version>
    5.  </parent>
    6. <dependency>
    7.          <groupId>org.springframework.boot</groupId>
    8.          <artifactId>spring-boot-starter-web</artifactId>
    9.      </dependency>
    10.      <dependency>
    11.          <groupId>org.springframework.boot</groupId>
    12.          <artifactId>spring-boot-starter-thymeleaf</artifactId>
    13.      </dependency>

  • application.properties

    1. spring.thymeleaf.prefix=classpath:/templates/
    2. spring.thymeleaf.suffix=.html
    3. spring.thymeleaf.mode=LEGACYHTML5
    4. spring.thymeleaf.encoding=UTF-8
    5. spring.thymeleaf.content-type=text/html
    6. spring.thymeleaf.cache=false

  • test.html

    1. <!DOCTYPE HTML>
    2. <html xmlns="http://www.w3.org/1999/xhtml" xmlns:th="http://www.thymeleaf.org">
    3. <head>
    4.   <meta content="text/html;charset=UTF-8"/>
    5. </head>
    6. <body>
    7. <span th:text="'用户名：'+${name}+',年龄：'+${age}">
    8. </span>
    9. </body>
    10. </html>

  • Controller ```java @Controller public class MVCDemoController {

    @RequestMapping(value = “/testMVC”,method = RequestMethod.GET ) public String testMVC(Model model){

    1.   model.addAttribute("name","张三");
    2.   model.addAttribute("age","18");
    4.   return "test";

    }

}

  2. - 启动demo
  3. ```java
  5. @SpringBootApplication(scanBasePackages="cn.shiyujun.controller")
  6. public class MVCDemo {
  7.     public static void main (String args[]){
  8.         SpringApplication.run(MVCDemo.class, args);
  9.     }
  10. }