Spring WebMVC 源码分析(1)-请求处理主流程

Myth丶恋晨 2024-04-18 22:35 63阅读 0赞

#### 文章目录 ####

*  1. SpringMVC 配置
 *  2. 请求处理流程
 *   *   *  2.1 DispathcerServlet 初始化
         *  2.2 请求处理

## 1. SpringMVC 配置 ##

使用 `SpringMVC` 框架需要在 web.xml 文件中声明其核心的前端分发器 `DispatcherServlet`，并指定其匹配 URL 的 mapping 规则，以便所有请求通过匹配`/`路径进入框架，从而完成处理

<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:spring-mvc.xml</param-value>
    		</init-param>
    		<load-on-startup>1</load-on-startup>
    		<async-supported>true</async-supported>
    	</servlet>
    	<servlet-mapping>
    		<servlet-name>SpringMVC</servlet-name>
    		
    		<url-pattern>/</url-pattern>
    	</servlet-mapping>

## 2. 请求处理流程 ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70]

#### 2.1 DispathcerServlet 初始化 ####

大致流程可参见另一篇文章 [Spring 启动流程][Spring]，此处主要讨论 DispathcerServlet 内部 `initStrategies()` 方法所做的工作。从源码来看，此处主要做一些组件初始化工作：

>  *  **multipartResolver** 处理文件上传的表单的解析器
>  *  **localeResolver** 提供国际化功能 ：zh\_CN -> 中文提示信息 ，en\_US -> 美国英语
>  *  **handlerMapping** 处理浏览器的请求路径，对应控制器中哪个方法
>  *  **handlerAdapter** 用来真正执行控制器中的方法
>  *  **handlerExceptionResolver** （异常解析器） 负责处理控制器方法中异常， @ExceptionHandler
>  *  **viewNameTranslator** 解析视图名称, 例如：把方法的返回结果字符串当成视图名
>  *  **viewResolver** 视图解析器，将视图名解析为视图对象（如jsp视图对象）

protected void initStrategies(ApplicationContext context) {
        
     	initMultipartResolver(context);
     	initLocaleResolver(context);
     	initThemeResolver(context);
     	initHandlerMappings(context);
     	initHandlerAdapters(context);
     	initHandlerExceptionResolvers(context);
     	initRequestToViewNameTranslator(context);
     	initViewResolvers(context);
     	initFlashMapManager(context);
     }

#### 2.2 请求处理 ####

1.  request 请求到来时，首先根据请求的类型(Get / Post 等) 在 `DispathcerServlet` 父类 `FrameworkServlet` 执行对应的方法。以 get 请求为例，调用链如下, `FrameworkServlet` 中主要完成了一些保存最初属性的工作，真正对请求的处理是在 `doService` 方法中完成的。而该方法由 `DispathcerServlet` 重写，此处进入了 `DispathcerServlet` 实现
    
        FrameworkServlet # doGet--> processRequest --> doService
    
        @Override
         protected final void doGet(HttpServletRequest request, HttpServletResponse response)
         		throws ServletException, IOException {
              
         	processRequest(request, response);
        }
         // 	FrameworkServlet 执行
         protected final void processRequest(HttpServletRequest request,HttpServletResponse response)
         		throws ServletException, IOException {
              
             ......
         	try {
              
         		doService(request, response);
         	}
         	......
          }
2.  `DispathcerServlet#doService()` 方法中完成了一些保存属性的工作，对请求的分发处理逻辑在 `doDispatch()` 方法中
    
        protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
              
             ......
         	// Make framework objects available to handlers and view objects.
         	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());
        
         	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 {
              
         		doDispatch(request, response);
         	}
         	......
         }
3.  进入 doDispatch 方法，可以看到该方法大致做了以下工作：  
    【1】`checkMultipart()`判断这个请求是否是Multipart，比如文件上传就是Multipart 请求  
    【2】`getHandler()` 根据 request 进入 handlerMapping 进行路径匹配，匹配结束返回 `HandlerExecutionChain` 执行链。如该执行链为空或者其中的成员变量 `handler`为空的话，抛出NoHandlerFoundException异常，并结束此次请求处理。`handler`为 HandlerMethod 对象，封装了反射调用必须的信息，如方法名，方法的参数列表，bean名称等  
    【3】`getHandlerAdapter()` 根据 handler 获取 handlerAdapter对象，由它来解析请求中的参数，并使其入参调用控制器中方法  
    【4】`mappedHandler.applyPreHandle()`执行链里会调用拦截器的 `preHandle()`方法，如果有任一个拦截器该方法返回 false，就不会调用postHandle()，直接清理资源，然后返回  
    【5】`ha.handle()` 处理适配器（handlerAdapter）执行 `handlerMethod`,也就是 @Controller 中的功能方法 并返回一个 `ModelAndView`对象  
    【6】`applyDefaultViewName()` 设置视图（view）的默认名称  
    【7】`mappedHandler.applyPostHandle()`调用执行链中所有的拦截器的 `postHandle()`方法，对 handlerMethod 返回的结果进行加强处理  
    【8】`processDispatchResult()` 进入返回处理结果的步骤，通过 `render(mv, request, response)` 调用 `resolveViewName()`方法使用视图解析器（ViewResolver）解析 ModelAndView 对象获得一个视图对象 View，之后调用 `View 对象 render() 方法`，将数据填充到视图中，产生一个响应结果返回给客户端
    
        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 {
              
         			processedRequest = checkMultipart(request);
         			multipartRequestParsed = (processedRequest != request);
        
         			// Determine handler for the current request.
         			mappedHandler = getHandler(processedRequest);
         			if (mappedHandler == null || mappedHandler.getHandler() == null) {
              
         				noHandlerFound(processedRequest, response);
         				return;
         			}
        
         			// 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()) {
              
         					logger.debug("Last-Modified value for [" + getRequestUri(request) + "] is: " + lastModified);
         				}
         				if (new ServletWebRequest(request, response).checkNotModified(lastModified) && isGet) {
              
         					return;
         				}
         			}
        
         			if (!mappedHandler.applyPreHandle(processedRequest, response)) {
              
         				return;
         			}
        
         			// Actually invoke the handler.
         			mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
        
         			if (asyncManager.isConcurrentHandlingStarted()) {
              
         				return;
         			}
        
         			applyDefaultViewName(processedRequest, mv);
         			mappedHandler.applyPostHandle(processedRequest, response, mv);
         		}
         		catch (Exception ex) {
              
         			dispatchException = ex;
         		}
         		processDispatchResult(processedRequest, response, mappedHandler, mv, dispatchException);
         	}
         	catch (Exception ex) {
              
         		triggerAfterCompletion(processedRequest, response, mappedHandler, ex);
         	}
         	catch (Error err) {
              
         		triggerAfterCompletionWithError(processedRequest, response, mappedHandler, 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_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80NTUwNTMxMw_size_16_color_FFFFFF_t_70]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/18/783b5ea3a0b64eb7b63b5a6c705c76f7.png
[Spring]: https://blog.csdn.net/weixin_45505313/article/details/100782854