SpringMvc之请求执行流程

布满荆棘的人生 2023-02-13 00:30 1阅读 0赞

## MVC思想 ##

模型-视图-控制器（MVC）是一个众所周知的以设计界面应用程序为基础的设计思想。它主要通过分离模型、视图及控制器在应用程序中的角色将业务逻辑从界面中解耦。通常，模型负责封装应用程序数据在视图层展示。视图仅仅只是展示这些数据，不包含任何业务逻辑。控制器负责接收来自用户的请求，并调用后台服务（service或者dao）来处理业务逻辑。处理后，后台业务层可能会返回了一些数据在视图层展示。控制器收集这些数据及准备模型在视图层展示。MVC模式的核心思想是将业务逻辑从界面中分离出来，允许它们单独改变而不会相互影响。

## SpringMVC请求流程 ##

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70][]

Spring MVC框架也是一个基于请求驱动的Web框架，并且使用了前端控制器模式（是用来提供一个集中的请求处理机制，所有的请求都将由一个单一的处理程序处理来进行设计，再根据请求映射规则分发给相应的页面控制器（动作/处理器）进行处理。首先让我们整体看一下Spring MVC处理请求的流程：

1.  首先用户发送请求,请求被SpringMvc前端控制器（DispatherServlet）捕获；
2.  前端控制器(DispatherServlet)对请求URL解析获取请求URI,根据URI, 调用HandlerMapping；
3.  前端控制器(DispatherServlet)获得返回的HandlerExecutionChain（包括Handler对象以及Handler对象对应的拦截器）；
4.  DispatcherServlet 根据获得的HandlerExecutionChain，选择一个合适的HandlerAdapter。（附注：如果成功获得HandlerAdapter后，此时将开始执行拦截器的preHandler(...)方法）；
5.  HandlerAdapter根据请求的Handler适配并执行对应的Handler；HandlerAdapter(提取Request中的模型数据，填充Handler入参，开始执行Handler（Controller)。 在填充Handler的入参过程中，根据配置，Spring将做一些额外的工作：
    
    HttpMessageConveter： 将请求消息（如Json、xml等数据）转换成一个对象，将对象转换为指定的响应信息。
    
    数据转换：对请求消息进行数据转换。如String转换成Integer、Double等数据格式化：
    
    数据格式化。 如将字符串转换成格式化数字或格式化日期等
    
    数据验证： 验证数据的有效性（长度、格式等），验证结果存储到BindingResult或Error中）
6.  Handler执行完毕，返回一个ModelAndView(即模型和视图)给HandlerAdaptor
7.  HandlerAdaptor适配器将执行结果ModelAndView返回给前端控制器。
8.  前端控制器接收到ModelAndView后，请求对应的视图解析器。
9.  视图解析器解析ModelAndView后返回对应View;
10. 渲染视图并返回渲染后的视图给前端控制器。
11. 最终前端控制器将渲染后的页面响应给用户或客户端

## SpringMVC请求执行源码解读 ##

对于SpringMvc 项目所有的请求入口(静态资源除外)这里都是从web.xml文件配置的前端控制器DispatcherServlet开始，

<servlet>
      <servlet-name>springMvc</servlet-name>
      <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
      <init-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:servlet-context.xml</param-value>
      </init-param>
      
      <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
      <servlet-name>springMvc</servlet-name>
      
      <url-pattern>/</url-pattern>
    </servlet-mapping>

DispatcherServlet UML继承关系图如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70 1][]

这里关注蓝线部分继承结构:DispatcherServlet-->FrameworkServlet-->HttpServletBean-->HttpServlet-->GenericServlet-->Servlet,对于请求核心时序图如下

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70 2][]

对于web 请求的处理，大家都知道是通过继承HttpServlet重写其service方法，这里打开DispatcherServlet源码发现这里并没有看到我们要找的service方法，此时到父类FrameworkServlet 查找如下:可以看到父类重写HttpServlet service方法。

### FrameworkServlet \#service ###

/**
     * Override the parent class implementation in order to intercept PATCH requests.
     */
    @Override
    protected void service(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
       HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
       if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
          processRequest(request, response);
       }
       else {
          super.service(request, response);
       }
    }
    复制代码

从源码分析来看当请求方法为patch请求或者为null时执行processRequest 方法，其他情况则调用父类service 方法，大家都知道SpringMvc 请求大多请求是get|post请求为主，此时继续向上查看FrameworkServlet 父类HttpServletBean（抽象类继承HttpServlet 并未重写service方法 所以向上继续寻找)-->HttpServlet service 方法

### HttpServlet\#service ###

@Override
        public void service(ServletRequest req, ServletResponse res)
            throws ServletException, IOException
        {
            HttpServletRequest  request;
            HttpServletResponse response;
            
            if (!(req instanceof HttpServletRequest &&
                    res instanceof HttpServletResponse)) {
                throw new ServletException("non-HTTP request or response");
            }
    
            request = (HttpServletRequest) req;
            response = (HttpServletResponse) res;
    
            service(request, response);
        }
    }
    
    
    protected void service(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException
        {
            String method = req.getMethod();
    
            if (method.equals(METHOD_GET)) {
                long lastModified = getLastModified(req);
                if (lastModified == -1) {
                    // servlet doesn't support if-modified-since, no reason
                    // to go through further expensive logic
                    doGet(req, resp);
                } else {
                    long ifModifiedSince = req.getDateHeader(HEADER_IFMODSINCE);
                    if (ifModifiedSince < lastModified) {
                        // If the servlet mod time is later, call doGet()
                        // Round down to the nearest second for a proper compare
                        // A ifModifiedSince of -1 will always be less
                        maybeSetLastModified(resp, lastModified);
                        doGet(req, resp);
                    } else {
                        resp.setStatus(HttpServletResponse.SC_NOT_MODIFIED);
                    }
                }
    
            } else if (method.equals(METHOD_HEAD)) {
                long lastModified = getLastModified(req);
                maybeSetLastModified(resp, lastModified);
                doHead(req, resp);
    
            } else if (method.equals(METHOD_POST)) {
                doPost(req, resp);
                
            } else if (method.equals(METHOD_PUT)) {
                doPut(req, resp);
                
            } else if (method.equals(METHOD_DELETE)) {
                doDelete(req, resp);
                
            } else if (method.equals(METHOD_OPTIONS)) {
                doOptions(req,resp);
                
            } else if (method.equals(METHOD_TRACE)) {
                doTrace(req,resp);
                
            } else {
                //
                // Note that this means NO servlet supports whatever
                // method was requested, anywhere on this server.
                //
    
                String errMsg = lStrings.getString("http.method_not_implemented");
                Object[] errArgs = new Object[1];
                errArgs[0] = method;
                errMsg = MessageFormat.format(errMsg, errArgs);
                
                resp.sendError(HttpServletResponse.SC_NOT_IMPLEMENTED, errMsg);
            }
        }
    复制代码

可以看到HttpServlet service 进行了重载，根据不同的请求类型然后调用不同处理方法，这里以get请求为例，当请求方法为get 请求时在重载service 方法中调用doGet 方法进行处理，这里需要特别注意的是:HttpServlet 存在doGet方法实现，然而在继承的子类中也存在doGet方法实现，到底调用哪个方法？很明显调用子类的doGet方法(面向对象多态思想!!!),从继承UML关系图上看，最外层子类实现doGet方法的为FrameworkServlet

### FrameworkServlet \#doGet&processRequest ###

@Override
    protected final void doGet(HttpServletRequest request, HttpServletResponse response)
          throws ServletException, IOException {
    
       processRequest(request, response);
    }
    
    	protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
    			throws ServletException, IOException {
    
            // 系统计时开始时间
    		long startTime = System.currentTimeMillis();
    		Throwable failureCause = null;
            // 国际化
    		LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
    		LocaleContext localeContext = buildLocaleContext(request);
            //构建ServletRequestAttributes对象
    		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    		ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
    		//异步管理
    		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
    		//初始化ContextHolders
    		initContextHolders(request, localeContext, requestAttributes);
    
    		try {
    			doService(request, response);
    		}
    		catch (ServletException | IOException ex) {
    			failureCause = ex;
    			throw ex;
    		}
    		catch (Throwable ex) {
    			failureCause = ex;
    			throw new NestedServletException("Request processing failed", ex);
    		}
    
    		finally {
                 //恢复原来的LocaleContext和ServiceRequestAttributes到LocaleContextHolder和RequestContextHolder，避免影响Servlet以外的处理，如Filter
    			resetContextHolders(request, previousLocaleContext, previousAttributes);
    			if (requestAttributes != null) {
    				requestAttributes.requestCompleted();
    			}
    			logResult(request, response, failureCause, asyncManager);
                //发布ServletRequestHandlerEvent消息，这个请求是否执行成功都会发布消息的
    			publishRequestHandledEvent(request, response, startTime, failureCause);
    		}
    	}
    
    
    
    
    // initContextHolders(request, localeContext, requestAttributes);
    	private void initContextHolders(HttpServletRequest request,
    			@Nullable LocaleContext localeContext, @Nullable RequestAttributes requestAttributes) {
    
    		if (localeContext != null) {
    			LocaleContextHolder.setLocaleContext(localeContext, this.threadContextInheritable);
    		}
    		if (requestAttributes != null) {
    			RequestContextHolder.setRequestAttributes(requestAttributes, this.threadContextInheritable);
    		}
    	}
    复制代码

该方法大概做了这几件事：国际化的设置，创建ServletRequestAttributes对象，初始化上下文holders(即将Request对象放入到线程上下文中，如后续想要在方法中获取request,response对象此时可以通过调用LocaleContextHolder对应方法即可)，然后调用doService方法。对于doService方法，FrameworkServlet 类并未提供实现，该方法由DispatcherServlet子类实现

### DispatcherServlet\#doService ###

DispatcherServlet里面执行处理的入口方法是doService，由于这个类继承于FrameworkServlet类，重写了doService()方法

@Override
    protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
       logRequest(request);
    
       // Keep a snapshot of the request attributes in case of an include,
       // to be able to restore the original attributes after the include.
       Map<String, Object> attributesSnapshot = null;
       if (WebUtils.isIncludeRequest(request)) {
          attributesSnapshot = new HashMap<>();
          Enumeration<?> attrNames = request.getAttributeNames();
          while (attrNames.hasMoreElements()) {
             String attrName = (String) attrNames.nextElement();
             if (this.cleanupAfterInclude || attrName.startsWith(DEFAULT_STRATEGIES_PREFIX)) {
                attributesSnapshot.put(attrName, request.getAttribute(attrName));
             }
          }
       }
    
        //Spring上下文
       request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
        //国际化解析器
       request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
        //主题解析器
       request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
        //主题
       request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());
    
        //重定向的数据  
       if (this.flashMapManager != null) {
          FlashMap inputFlashMap = this.flashMapManager.retrieveAndUpdate(request, response);
          if (inputFlashMap != null) {
             request.setAttribute(INPUT_FLASH_MAP_ATTRIBUTE, Collections.unmodifiableMap(inputFlashMap));
          }
          request.setAttribute(OUTPUT_FLASH_MAP_ATTRIBUTE, new FlashMap());
          request.setAttribute(FLASH_MAP_MANAGER_ATTRIBUTE, this.flashMapManager);
       }
    
       try {
          //request设置完相关的属性做真正的请求处理
          doDispatch(request, response);
       }
       finally {
          if (!WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
             // Restore the original attribute snapshot, in case of an include.
             if (attributesSnapshot != null) {
                restoreAttributesAfterInclude(request, attributesSnapshot);
             }
          }
       }
    }
    复制代码

整个方法看下来处理的操作有:处理include标签的请求，将上下文放到request的属性中，将国际化解析器放到request的属性中，将主题解析器放到request属性中，将主题放到request的属性中，处理重定向的请求数据最后调用doDispatch这个核心的方法对请求进行处理。

DispatcherServlet\#doDispatch

该方法是在doService方法中调用的，从底层设计了整个请求的处理流程:

*  根据request找到Handler
 *  根据Handler找到对应的HandlerAdapter
 *  用HandlerAdapter处理Handler
 *  调用 processDispatchResult方法处理上面之后的结果（包含View渲染并输出给用户）

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 {
              // 校验是否为上传请求 是上传请求执行解析 否则返回request
             processedRequest = checkMultipart(request);
             multipartRequestParsed = (processedRequest != request);
    
             // 根据访问的Handler 返回指定对应的HandlerExecutionChain对象 这里从HandlerMapping 集合中查找 HandlerExecutionChain 对象包含Handler与拦截器HandlerInterceptor列表
             mappedHandler = getHandler(processedRequest);
             if (mappedHandler == null) {
                noHandlerFound(processedRequest, response);
                return;
             }
    
             // 根据得到的Handler 获取对应的HandlerAdaptor对象
             HandlerAdapter ha = getHandlerAdapter(mappedHandler.getHandler());
    
             // 处理GET、HEAD请求的Last-Modified
             String method = request.getMethod();
             boolean isGet = "GET".equals(method);
             if (isGet || "HEAD".equals(method)) {
                long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
                //当数据没有更改时，就直接返回上次的数据，提高效率
                 if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
                   return;
                }
             }
    
             //执行Interceptor的preHandle 
             if (!mappedHandler.applyPreHandle(processedRequest, response)) {
                return;
             }
    
             // 执行Handler 返回ModelAndView
             mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
              //如果需要异步处理，直接返回
             if (asyncManager.isConcurrentHandlingStarted()) {
                return;
             }
    
             //当view为空时，根据request设置默认view，如Handler返回值为void
             applyDefaultViewName(processedRequest, mv);
             //执行相应Interceptor的postHandle 
             mappedHandler.applyPostHandle(processedRequest, response, mv);
          }
          catch (Exception ex) {
             dispatchException = ex;
          }
          catch (Throwable err) {
             // As of 4.3, we're processing Errors thrown from handler methods as well,
             // making them available for @ExceptionHandler methods and other scenarios.
             dispatchException = new NestedServletException("Handler dispatch failed", err);
          }
           //处理返回结果，包括处理异常、渲染页面，发出完成通知触发Interceptor的afterCompletion
          processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
       }
       catch (Exception ex) {
          triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
       }
       catch (Throwable err) {
          triggerAfterCompletion(processedRequest, response, mappedHandler,
                new NestedServletException("Handler processing failed", err));
       }
       finally {
          if (asyncManager.isConcurrentHandlingStarted()) {
             // Instead of postHandle and afterCompletion
             if (mappedHandler != null) {
                mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
             }
          }
          else {
             // Clean up any resources used by a multipart request.
             if (multipartRequestParsed) {
                cleanupMultipart(processedRequest);
             }
          }
       }
    }
    复制代码

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20210223203432581.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70 1]: https://img-blog.csdnimg.cn/2021022321021637.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1,size_16,color_FFFFFF,t_70
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1_size_16_color_FFFFFF_t_70 2]: https://img-blog.csdnimg.cn/20210223210422938.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzI0MzEzNjM1,size_16,color_FFFFFF,t_70