5.1 前端控制器 DispatcherServlet

继承结构：
5. MVC源码剖析 - 图1

  1. 前端请求进来，会执行FrameworkServlet的doGet/doPost方法，而doGet/doPost方法都会执行processRequest(request,response)方法，processRequest()主要做的事情有：

    • 获取到上一个请求保存的LocaleContext，建立新的LocaleContext
    • 获取到上一个请求保存的RequestAttributes，建立新的RequestAttributes

    • 调用抽象方法doService()，此方法由继承该类的DispatcherServlet类来实现

      1. protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
      2. throws ServletException, IOException {
      4. long startTime = System.currentTimeMillis();
      5. Throwable failureCause = null;
      7. // 获取到上一个请求保存的LocaleContext
      8. LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
      9. // 建立新的LocaleContext
      10. LocaleContext localeContext = buildLocaleContext(request);
      12. // 获取到上一个请求保存的RequestAttributes
      13. RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
      14. // 建立新的RequestAttributes
      15. ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
      17. WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
      18. asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
      20. // 新的RequestAttributes绑定到LocalThread
      21. initContextHolders(request, localeContext, requestAttributes);
      23. try {
      24.    doService(request, response);
      25. }
      26. catch (ServletException | IOException ex) {
      27.    failureCause = ex;
      28.    throw ex;
      29. }
      30. catch (Throwable ex) {
      31.    failureCause = ex;
      32.    throw new NestedServletException("Request processing failed", ex);
      33. }
      35. finally {
      36.    resetContextHolders(request, previousLocaleContext, previousAttributes);
      37.    if (requestAttributes != null) {
      38.        requestAttributes.requestCompleted();
      39.    }
      40.    logResult(request, response, failureCause, asyncManager);
      41.    publishRequestHandledEvent(request, response, startTime, failureCause);
      42. }
      43. }

  2. DisapatcherServlet类的doService方法主要做的事情：

    • 获取请求域中的属性名存起来做个副本
    • 往request设置一些属性值使框架对象可用于处理程序和视图对象
    • flashMapManager管理重定向参数携带

    • 执行doDispatcher()方法

      1. @Override
      2. protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
      3. logRequest(request);
      5. // Keep a snapshot of the request attributes in case of an include,
      6. // to be able to restore the original attributes after the include.
      7. Map<String, Object> attributesSnapshot = null;
      8. if (WebUtils.isIncludeRequest(request)) {
      9.    attributesSnapshot = new HashMap<>();
      10.    // 获取请求域中的属性名存起来做个副本
      11.    Enumeration<?> attrNames = request.getAttributeNames();
      12.    while (attrNames.hasMoreElements()) {
      13.        String attrName = (String) attrNames.nextElement();
      14.        if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
      15.            attributesSnapshot.put(attrName, request.getAttribute(attrName));
      16.        }
      17.    }
      18. }
      20. // 往request设置一些属性值使框架对象可用于处理程序和视图对象
      21. request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
      22. request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
      23. request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
      24. request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
      26. // flashMapManager管理重定向参数携带
      27. if (this.flashMapManager != null) {
      28.    FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
      29.    if (inputFlashMap != null) {
      30.        request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
      31.    }
      32.    request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
      33.    request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
      34. }
      36. try {
      37.    doDispatch(request, response);
      38. }
      39. finally {
      40.    if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
      41.        // Restore the original attribute snapshot, in case of an include.
      42.        if (attributesSnapshot != null) {
      43.            restoreAttributesAfterInclude(request, attributesSnapshot);
      44.        }
      45.    }
      46. }
      47. }

      5.2 核心方法doDisapatcher()分析

      该方法是SpringMVC的核心方法，具体做的事情如下：

      • 1. 检查是否文件上传的请求
      • 2. 取得当前请求的Controller，也称为Handler，即处理器。这里并不是直接返回Controller，而是返 回HandlerExecutionChain请求处理链对象，该对象封装了Handler和Interceptor。如果handler为空则返回404。
      • 3 .获取处理请求的处理器适配器HandlerAdapter，处理last-modified请求头。
      • 4. 实际处理器处理请求，返回结果视图对象ModelAndView，结果视图对象处理
      • 5. 最终会调用HandlerInterceptor的afterCompletion方法 ```java protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception { HttpServletRequest processedRequest = request; HandlerExecutionChain mappedHandler = null; boolean multipartRequestParsed = false;

      WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);

      try { ModelAndView mv = null; Exception dispatchException = null;

      try {

      1.    // 1.检查是否文件上传的请求
      2.    processedRequest = checkMultipart(request);
      3.    multipartRequestParsed = (processedRequest != request);
      5.    // Determine handler for the current request.
      6.    /**
      7.    * 2.取得当前请求的Controller，也称为Handler，即处理器
      8.    *      这里并不是直接返回Controller，而是返回HandlerExecutionChain请求处理链对象
      9.    *      该对象封装了Handler和Interceptor
      10.    */
      11.    mappedHandler = getHandler(processedRequest);
      12.    if (mappedHandler == null) {
      13.        // 如果handler为空则返回404
      14.        noHandlerFound(processedRequest, response);
      15.        return;
      16.    }
      18.    // Determine handler adapter for the current request.
      19.    // 3.获取处理请求的处理器适配器HandlerAdapter
      20.    HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
      22.    // Process last-modified header, if supported by the handler.
      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 (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
      29.            return;
      30.        }
      31.    }
      33.    if (!mappedHandler.applyPreHandle(processedRequest, response)) {
      34.        return;
      35.    }
      37.    // Actually invoke the handler.
      38.    // 4. 实际处理器处理请求，返回结果视图对象ModelAndView
      39.    mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
      41.    if (asyncManager.isConcurrentHandlingStarted()) {
      42.        return;
      43.    }
      44.    // 结果视图对象处理
      45.    applyDefaultViewName(processedRequest, mv);
      46.    mappedHandler.applyPostHandle(processedRequest, response, mv);

      } catch (Exception ex) {

      1.    dispatchException = ex;

      } catch (Throwable err) {

      1.    // As of 4.3, we're processing Errors thrown from handler methods as well,
      2.    // making them available for @ExceptionHandler methods and other scenarios.
      3.    dispatchException = new NestedServletException("Handler dispatch failed", err);

      } processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException); } catch (Exception ex) { // 最终会调用HandlerInterceptor的afterCompletion方法 triggerAfterCompletion(processedRequest, response, mappedHandler, ex); } catch (Throwable err) { triggerAfterCompletion(processedRequest, response, mappedHandler,

      1.                       new NestedServletException("Handler processing failed", err));

      } finally { if (asyncManager.isConcurrentHandlingStarted()) {

      1.    // Instead of postHandle and afterCompletion
      2.    if (mappedHandler != null) {
      3.        mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
      4.    }

      } else {

      1.    // Clean up any resources used by a multipart request.
      2.    if (multipartRequestParsed) {
      3.        cleanupMultipart(processedRequest);
      4.    }

      } } } ```

      5.3 SpringMVC的核心步骤

  3. 调⽤getHandler()获取到能够处理当前请求的执⾏链 HandlerExecutionChain（Handler+拦截器）

  4. 调⽤getHandlerAdapter()；获取能够执⾏1）中Handler的适配器
  5. 适配器调⽤Handler执⾏ha.handle（总会返回⼀个ModelAndView对象）

  6. 调⽤processDispatchResult()⽅法完成视图渲染跳转

    5.3.1 getHandler方法分析

    1. @Nullable
    2. protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    3.  // 遍历handlerMappings，里面有两个HandlerMapping的实现类
    4.  // 分别是BeanNameUrlHandlerMapping和RequestMappingHandlerMapping
    5.  if (this.handlerMappings != null) {
    6.      for (HandlerMapping mapping : this.handlerMappings) {
    7.          // 容器初始化的时候通过扫描注解，配置了url和handler的关系
    8.          HandlerExecutionChain handler = mapping.getHandler(request);
    9.          if (handler != null) {
    10.              // 返回的HandlerExecutionChain包含了Handler和Interceptor信息
    11.              return handler;
    12.          }
    13.      }
    14.  }
    15.  return null;
    16. }

    5.3.2 getHandlerAdapter方法分析

    1. // 通过Handler匹配到支持的Adapter适配器
    2. protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    3.  if (this.handlerAdapters != null) {
    4.      /**
    5.       * HandlerAdapter的三个实现类 判断支持那个然后返回
    6.       * 1.HttpRequestHandlerAdapter
    7.       * 2.SimpleControllerHandlerAdapter
    8.       * 3.RequestMappingHandlerAdapter
    9.       */
    10.      for (HandlerAdapter adapter : this.handlerAdapters) {
    11.          if (adapter.supports(handler)) {
    12.              return adapter;
    13.          }
    14.      }
    15.  }
    16.  throw new ServletException("No adapter for handler [" + handler +
    17.                             "]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
    18. }

    5.3.3 适配器调⽤Handler执⾏ha.handle()方法

  7. mav.invokeHandlerMethod(request,response,handlerMethod)

    • 对handlerMethod进行参数等的适配处理，并调用目标handler
  8. 对请求参数进行处理，调用目标HanderMethod，并且将返回值封装成MethodAndView对象
  9. 对目标handler的参数进行处理，并且调用目标handler
  10. 将request中参数转换成当前handler的参数形式
  11. doInvole()方法主要结合处理后的参数，使用反射对目标方法进行调用

    5.3.4 processDispatchResult()完成视图渲染跳转

    ```java private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
    1.                             @Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
    2.                             @Nullable Exception exception) throws Exception {
    // Did the handler return a view to render? if (mv != null && !mv.wasCleared()) {
    1.  // 是否处理返回渲染的视图
    2.  render(mv, request, response);
    3.  if (errorView) {
    4.      WebUtils.clearErrorRequestAttributes(request);
    5.  }
    }

}

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) { View view; String viewName = mv.getViewName(); if (viewName != null) { // We need to resolve the view name. // 解析封装视图 view = resolveViewName(viewName, mv.getModelInternal(), locale, request); if (view == null) { throw new ServletException(“Could not resolve view with name ‘“ + mv.getViewName() + “‘ in servlet with name ‘“ + getServletName() + “‘“); } } }

protected View resolveViewName(String viewName, @Nullable Map model, Locale locale, HttpServletRequest request) throws Exception { // 视图解析器解析视图对象 if (this.viewResolvers != null) { for (ViewResolver viewResolver : this.viewResolvers) { View view = viewResolver.resolveViewName(viewName, locale); if (view != null) { return view; } } } return null; }

  1. ```java
  2. // 在解析出View视图对象的过程中会判断是否重定向、是否转发等，不同的情况封装的是不同的
  3. // View实现
  4. @Override
  5. protected View createView(String viewName, Locale locale) throws Exception {
  6.     // If this resolver is not supposed to handle the given view,
  7.     // return null to pass on to the next resolver in the chain.
  8.     if (!canHandle(viewName, locale)) {
  9.         return null;
  10.     }
  12.     // Check for special "redirect:" prefix.
  13.     if (viewName.startsWith(REDIRECT_URL_PREFIX)) {
  14.         String redirectUrl = viewName.substring(REDIRECT_URL_PREFIX.length());
  15.         RedirectView view = new RedirectView(redirectUrl,
  16.                                              isRedirectContextRelative(), isRedirectHttp10Compatible());
  17.         String[] hosts = getRedirectHosts();
  18.         if (hosts != null) {
  19.             view.setHosts(hosts);
  20.         }
  21.         return applyLifecycleMethods(REDIRECT_URL_PREFIX, view);
  22.     }
  24.     // Check for special "forward:" prefix.
  25.     if (viewName.startsWith(FORWARD_URL_PREFIX)) {
  26.         String forwardUrl = viewName.substring(FORWARD_URL_PREFIX.length());
  27.         InternalResourceView view = new InternalResourceView(forwardUrl);
  28.         return applyLifecycleMethods(FORWARD_URL_PREFIX, view);
  29.     }
  31.     // Else fall back to superclass implementation: calling loadView.
  32.     return super.createView(viewName, locale);
  33.     }
  1. @Override
  2. public void render(@Nullable Map<String, ?> model, HttpServletRequest request,
  3.                    HttpServletResponse response) throws Exception {
  5.     if (logger.isDebugEnabled()) {
  6.         logger.debug("View " + formatViewName() +
  7.                      ", model " + (model != null ? model : Collections.emptyMap()) +
  8.                      (this.staticAttributes.isEmpty() ? "" : ", static attributes " + this.staticAttributes));
  9.     }
  11.     Map<String, Object> mergedModel = createMergedOutputModel(model, request, response);
  12.     prepareResponse(request, response);
  13.     // 把modelMap中的数据暴露到request请求域中
  14.     // 这也是后台model.add后视图可以从请求域中取出的原因
  15.     renderMergedOutputModel(mergedModel, getRequestToExpose(request), response);
  16. }

5.4 MVC九大组件分析

  1. MVC的九大组件在DispatcherServlet类中都有定义。 ```java /* MultipartResolver used by this servlet. / // 多部件解析器 @Nullable private MultipartResolver multipartResolver;

/* LocaleResolver used by this servlet. / // 区域化 国际化解析器 @Nullable private LocaleResolver localeResolver;

/* ThemeResolver used by this servlet. / // 主题解析器 @Nullable private ThemeResolver themeResolver;

/* List of HandlerMappings used by this servlet. / // 处理器映射器组件 @Nullable private List handlerMappings;

/* List of HandlerAdapters used by this servlet. / // 处理器适配器组件 @Nullable private List handlerAdapters;

/* List of HandlerExceptionResolvers used by this servlet. / // 异常解析器组件 @Nullable private List handlerExceptionResolvers;

/* RequestToViewNameTranslator used by this servlet. / // 默认视图名转换器组件 @Nullable private RequestToViewNameTranslator viewNameTranslator;

/* FlashMapManager used by this servlet. / // flash属性管理组件 重定向属性 @Nullable private FlashMapManager flashMapManager;

/* List of ViewResolvers used by this servlet. / // 视图解析器 @Nullable private List viewResolvers;

  2. 2. 九⼤组件都是定义了接⼝，接⼝其实就是定义了该组件的规范，⽐如ViewResolver、HandlerAdapter等都是接⼝
  3. 3. 九大组件初始化入口
  4. ```java
  5. @Override
  6. protected void onRefresh(ApplicationContext context) {
  7.     // 初始化策略
  8.     initStrategies(context);
  9. }
  11. protected void initStrategies(ApplicationContext context) {
  12.     // 初始化多文件上传组件
  13.     initMultipartResolver(context);
  14.     // 初始化本地语言环境
  15.     initLocaleResolver(context);
  16.     // 初始化主题模板处理器
  17.     initThemeResolver(context);
  18.     // 初始化处理器映射器
  19.     initHandlerMappings(context);
  20.     // 初始化处理器适配器
  21.     initHandlerAdapters(context);
  22.     // 初始化异常拦截器
  23.     initHandlerExceptionResolvers(context);
  24.     // 初始化视图预处理器
  25.     initRequestToViewNameTranslator(context);
  26.     // 初始化视图转换器
  27.     initViewResolvers(context);
  28.     // 初始化FlashMap管理器
  29.     initFlashMapManager(context);
  30. }

  1. 解析initHandlerMappings：如果按照类型和按照固定id从ioc容器中找不到对应组件，则会按照默认策略进⾏注册初始化，默认策略在DispatcherServlet.properties⽂件中配置

    1. private void initHandlerMappings(ApplicationContext context) {
    2.  this.handlerMappings = null;
    4.  if (this.detectAllHandlerMappings) {
    5.      // 按照HandlerMapping.class类型去ioc容器中找到所有的HandlerMapping
    6.      Map<String, HandlerMapping> matchingBeans =
    7.          BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
    8.      if (!matchingBeans.isEmpty()) {
    9.          this.handlerMappings = new ArrayList<>(matchingBeans.values());
    10.          // We keep HandlerMappings in sorted order.
    11.          AnnotationAwareOrderComparator.sort(this.handlerMappings);
    12.      }
    13.  }
    14.  else {
    15.      try {
    16.          // 否则在ioc中按照固定名称id（handlerMapping）去查找
    17.          HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
    18.          this.handlerMappings = Collections.singletonList(hm);
    19.      }
    20.      catch (NoSuchBeanDefinitionException ex) {
    21.          // Ignore, we'll add a default HandlerMapping later.
    22.      }
    23.  }
    25.  // 最后还为控则按照默认策略生成（按照默认方式实例化生成HandlerMapping）
    26.  if (this.handlerMappings == null) {
    27.      this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
    28.      if (logger.isTraceEnabled()) {
    29.          logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
    30.                       "': using default strategies from DispatcherServlet.properties");
    31.      }
    32.  }
    33. }