【Spring MVC 源码学习一】核心流程

╰+攻爆jí腚メ 2021-12-22 13:01 234阅读 0赞

## 流程说明 ##

直接看源码理解起来会比较吃力，先放张图在这，让我们对spring mvc核心处理流程有个初步印象。  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xhbWJfSVQ_size_16_color_FFFFFF_t_70]  
前端控制器`DispacherServlet`是spring mvc框架的核心类，控制整个请求处理的逻辑，由它调用`HanlderMapping` 、 `HandlerAdapter`、`ViewResolver`和`View`组件的方法完成请求的处理流程。

## 开始读源码 ##

### 1，准备工作 ###

首先spring mvc框架把刚用户请求交给`DispacherServlet`类的doService方法对请求进行初步加工

@Override
    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    	//一些准备工作
    	...
    	//将spring上下文信息存储至request，方便后面的处理器和视图用到
    	request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
    	// 存储其他框架信息
    	...
    	//分发请求
        try {
          doDispatch(request, response);
        }
        // 后续工作
        ...
    }

### 2，开始分发请求 ###

protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
    HttpServletRequest processedRequest = request;
       HandlerExecutionChain mappedHandler = null;
       int interceptorIndex = -1;
    
       try {
          ModelAndView mv;
          boolean errorView = false;
    
          try {
             processedRequest = checkMultipart(request);
    
             // 步骤1，获取请求的处理器(handler)
             // Determine handler for the current request
             mappedHandler = getHandler(processedRequest, false);
             if (mappedHandler == null || mappedHandler.getHandler() == null) {
                noHandlerFound(processedRequest, response);
                return;
             }
    
             // 步骤2，获取支持处理器的适配器(handlerAdapter)
             // Determine handler adapter for the current request.
             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
             // Process last-modified header, if supported by the handler.
             String method = request.getMethod();
             boolean isGet = "GET".equals(method);
             if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                if (logger.isDebugEnabled()) {
                   String requestUri = urlPathHelper.getRequestUri(request);
                   logger.debug("Last-Modified value for [" + requestUri + "] is: " + lastModified);
                }
                if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                   return;
                }
             }
    
             // Apply preHandle methods of registered interceptors.
             HandlerInterceptor[] interceptors = mappedHandler.getInterceptors();
             if (interceptors != null) {
                for (int i = 0; i < interceptors.length; i++) {
                   HandlerInterceptor interceptor = interceptors[i];
                   if (!interceptor.preHandle(processedRequest, response, mappedHandler.getHandler())) {
                      triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
                      return;
                   }
                   interceptorIndex = i;
                }
             }
    
             // 步骤3，调用适配器的handle方法处理请求
             // Actually invoke the handler.
             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
             // Do we need view name translation?
             if (mv != null && !mv.hasView()) {
                mv.setViewName(getDefaultViewName(request));
             }
    
             // Apply postHandle methods of registered interceptors.
             if (interceptors != null) {
                for (int i = interceptors.length - 1; i >= 0; i--) {
                   HandlerInterceptor interceptor = interceptors[i];
                   interceptor.postHandle(processedRequest, response, mappedHandler.getHandler(), mv);
                }
             }
          }
          catch (ModelAndViewDefiningException ex) {
             logger.debug("ModelAndViewDefiningException encountered", ex);
             mv = ex.getModelAndView();
          }
          catch (Exception ex) {
             Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
             mv = processHandlerException(processedRequest, response, handler, ex);
             errorView = (mv != null);
          }
    
          // 步骤4，将mv中的模型数据填充(渲染)到response中
          // Did the handler return a view to render?
          if (mv != null && !mv.wasCleared()) {
             render(mv, processedRequest, response);
             if (errorView) {
                WebUtils.clearErrorRequestAttributes(request);
             }
          }
          else {
             if (logger.isDebugEnabled()) {
                logger.debug("Null ModelAndView returned to DispatcherServlet with name '" + getServletName() +
                      "': assuming HandlerAdapter completed request handling");
             }
          }
    
          // Trigger after-completion for successful outcome.
          triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, null);
       }
    
       catch (Exception ex) {
          // Trigger after-completion for thrown exception.
          triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
          throw ex;
       }
       catch (Error err) {
          ServletException ex = new NestedServletException("Handler processing failed", err);
          // Trigger after-completion for thrown exception.
          triggerAfterCompletion(mappedHandler, interceptorIndex, processedRequest, response, ex);
          throw ex;
       }
    
       finally {
          // Clean up any resources used by a multipart request.
          if (processedRequest != request) {
             cleanupMultipart(processedRequest);
          }
       }
    }

步骤1

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
       for (HandlerMapping hm : this.handlerMappings) {
          if (logger.isTraceEnabled()) {
             logger.trace(
                   "Testing handler map [" + hm + "] in DispatcherServlet with name '" + getServletName() + "'");
          }
          HandlerExecutionChain handler = hm.getHandler(request);
          if (handler != null) {
             return handler;
          }
       }
       return null;
    }

`HandlerMapping`是一个请求路径(URL)与处理器(Handler)的映射表。spring有多种处理请求的处理器，常用的如`HttpRequestHandler`, `Controller`等，因此也有多个HandlerMapping。*getHandler*方法中，遍历每种HandlerMapping直到获取到，获取的结果是一个`HandlerExecutionChain`对象，他包含了`Handler`和各种配置的处理器拦截器(`HandlerInterceptor`)

步骤2

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
       for (HandlerAdapter ha : this.handlerAdapters) {
          if (logger.isTraceEnabled()) {
             logger.trace("Testing handler adapter [" + ha + "]");
          }
          if (ha.supports(handler)) {
             return ha;
          }
       }
       throw new ServletException("No adapter for handler [" + handler +
             "]: Does your handler implement a supported interface like Controller?");
    }

根据处理器获取处理器适配器（HandlerAdaptor），这里用到了适配器模式，我另外一篇学习笔记中单独写了[SpringMVC中的适配器模式][SpringMVC]，这里就不展开了。也是用遍历的方法，调用处理器适配器的*supports*方法判断适配器是否支持处理器，直到找到为止

步骤3  
调用处理器适配器的handler方法，内部是调用具体处理器的处理方法，返回`ModelAndView`对象。此时ModelAndView中，只有`Model`即数据对象，没有视图对象`View`

步骤4

protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
            Locale locale = this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale();
            response.setLocale(locale);
            String viewName = mv.getViewName();
            View view;
            if (viewName != null) {
               // 步骤4.1 根据视图名称，获取视图对象View
                view = this.resolveViewName(viewName, mv.getModelInternal(), locale, request);
                if (view == null) {
                    throw new ServletException("Could not resolve view with name '" + mv.getViewName() + "' in servlet with name '" + this.getServletName() + "'");
                }
            } else {
                view = mv.getView();
                if (view == null) {
                    throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a View object in servlet with name '" + this.getServletName() + "'");
                }
            }
    
            if (this.logger.isDebugEnabled()) {
                this.logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + this.getServletName() + "'");
            }
    
            try {
                if (mv.getStatus() != null) {
                    response.setStatus(mv.getStatus().value());
                }
                // 步骤4.2 调用视图对象的render方法，将数据模型model以视图规定的格式填充到response中
                view.render(mv.getModelInternal(), request, response);
            } catch (Exception var8) {
                if (this.logger.isDebugEnabled()) {
                    this.logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '" + this.getServletName() + "'", var8);
                }
    
                throw var8;
            }
        }

步骤4.1

@Nullable
        protected View resolveViewName(String viewName, @Nullable Map<String, Object> model, Locale locale, HttpServletRequest request) throws Exception {
            if (this.viewResolvers != null) {
                Iterator var5 = this.viewResolvers.iterator();
    
                while(var5.hasNext()) {
                    ViewResolver viewResolver = (ViewResolver)var5.next();
                    View view = viewResolver.resolveViewName(viewName, locale);
                    if (view != null) {
                        return view;
                    }
                }
            }
    
            return null;
        }

遍历视图解析器集合ViewResolvers获取视图。视图解析器使用到了策略模式，在我的另外一篇学习笔记中有关于[SpingMVC中策略模式][SpingMVC]的说明。  
常用的视图解析器是内容协商解析器`ContentNegotiatingViewResolver`，它不自己解析视图，而是委托给defaultViews属性中关联的视图去解析。可以自己实现`View`接口加到defaultViews中。

步骤4.2  
视图对象的render方法，将数据Model按照视图规定的格式填充到response中。到此已经得到可以返回给客户的响应。

## 总结流程及组件 ##

spring mvc处理请求的流程和用到的组件，总结为如下脑图  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xhbWJfSVQ_size_16_color_FFFFFF_t_70 1]

## 参考资料 ##

1, [SpringMVC 官方中文文档][SpringMVC 1]  
2, [SpringMVC系列（一）核心：处理请求流程][SpringMVC 2]  
3, [SpringMVC执行流程及工作原理][SpringMVC 3]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xhbWJfSVQ_size_16_color_FFFFFF_t_70]: /images/20211220/b6d33d9148f84fbebe8ea0117a624a66.png
[SpringMVC]: https://blog.csdn.net/Lamb_IT/article/details/94359195
[SpingMVC]: https://blog.csdn.net/Lamb_IT/article/details/94360785
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0xhbWJfSVQ_size_16_color_FFFFFF_t_70 1]: /images/20211220/d169a91f46524b91ba1ccb7e8f86b1ce.png
[SpringMVC 1]: http://blog.didispace.com/books/spring-mvc-4-tutorial/publish/21-1/introduction-to-spring-web-mvc-framework.html
[SpringMVC 2]: https://blog.csdn.net/zhaolijing2012/article/details/41596803
[SpringMVC 3]: https://www.jianshu.com/p/8a20c547e245