springmvc5源码

雨点打透心脏的1/2处 2022-02-21 02:49 269阅读 0赞

SpringMVC源码分析  
我们根据工作机制中三部分来分析SpringMVC的源代码。  
其一,ApplicationContext初始化时建立所有url和Controller类的对应关系(用Map保存);  
其二,根据请求url找到对应的Controller,并从Controller中找到处理请求的方法;反射调用方法，返回数据和视图，渲染视图和拦截器链处理  
分为7步  
1.检查是否文件上传  
2.根据handlerMapping获取handler执行链，包含handler和拦截器数组  
3.根据handler找到HandlerAdapter  
4.执行拦截器链的前处理  
5.调用handlerAdapter处理handler的方法，返回数据和视图  
6.拦截器链后处理  
7.渲染视图和拦截器链最终处理

## 第一个步骤,也就是建立Map<url,Controller>. ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmd3dWxpcG8_size_16_color_FFFFFF_t_70]  
入口类为ApplicationObjectSupport的setApplicationContext方法.  
setApplicationContext方法中核心部分就是初始化容器initApplicationContext(context),  
子类AbstractDetectingUrlHandlerMapping实现了该方法,所以我们直接看子类中的初始化容器方法。

public abstract class ApplicationObjectSupport implements ApplicationContextAware {
    
    	@Override
    	public final void setApplicationContext(@Nullable ApplicationContext context) throws BeansException {
    		if (context == null && !isContextRequired()) {
    			// Reset internal context state.
    			this.applicationContext = null;
    			this.messageSourceAccessor = null;
    		}
    		else if (this.applicationContext == null) {
    			// Initialize with passed-in context.
    			if (!requiredContextClass().isInstance(context)) {
    				throw new ApplicationContextException(
    						"Invalid application context: needs to be of type [" + requiredContextClass().getName() + "]");
    			}
    			this.applicationContext = context;
    			this.messageSourceAccessor = new MessageSourceAccessor(context);
    			initApplicationContext(context);
    		}
    		else {
    			// Ignore reinitialization if same context passed in.
    			if (this.applicationContext != context) {
    				throw new ApplicationContextException(
    						"Cannot reinitialize with different application context: current one is [" +
    						this.applicationContext + "], passed-in one is [" + context + "]");
    			}
    		}
    	}
    	protected void initApplicationContext(ApplicationContext context) throws BeansException {
    		initApplicationContext();
    	}
    
    	/**
    	 * Subclasses can override this for custom initialization behavior.
    	 */
    	protected void initApplicationContext() throws BeansException {
    	}

AbstractDetectingUrlHandlerMapping

@Override
    	public void initApplicationContext() throws ApplicationContextException {
    		super.initApplicationContext();
    		detectHandlers();
    	}
    	
    	protected void detectHandlers() throws BeansException {
    		ApplicationContext applicationContext = obtainApplicationContext();
    		if (logger.isDebugEnabled()) {
    			logger.debug("Looking for URL mappings in application context: " + applicationContext);
    		}
    		String[] beanNames = (this.detectHandlersInAncestorContexts ?
    				BeanFactoryUtils.beanNamesForTypeIncludingAncestors(applicationContext, Object.class) :
    				applicationContext.getBeanNamesForType(Object.class));
    
    		// Take any bean name that we can determine URLs for.
    		for (String beanName : beanNames) {
    			String[] urls = determineUrlsForHandler(beanName);
    			if (!ObjectUtils.isEmpty(urls)) {
    				// URL paths found: Let's consider it a handler.
    				registerHandler(urls, beanName);
    			}
    			else {
    				if (logger.isDebugEnabled()) {
    					logger.debug("Rejected bean name '" + beanName + "': no URL paths identified");
    				}
    			}
    		}
    	}
    	
    	protected abstract String[] determineUrlsForHandler(String beanName);

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

/**
    	 * Checks name and aliases of the given bean for URLs, starting with "/".
    	 */
    	@Override
    	protected String[] determineUrlsForHandler(String beanName) {
    		List<String> urls = new ArrayList<>();
    		if (beanName.startsWith("/")) {
    			urls.add(beanName);
    		}
    		String[] aliases = obtainApplicationContext().getAliases(beanName);
    		for (String alias : aliases) {
    			if (alias.startsWith("/")) {
    				urls.add(alias);
    			}
    		}
    		return StringUtils.toStringArray(urls);
    	}

AbstractUrlHandlerMapping

protected void registerHandler(String[] urlPaths, String beanName) throws BeansException, IllegalStateException {
    		Assert.notNull(urlPaths, "URL path array must not be null");
    		for (String urlPath : urlPaths) {
    			registerHandler(urlPath, beanName);
    		}
    	}
    	
    	protected void registerHandler(String urlPath, Object handler) throws BeansException, IllegalStateException {
    		Assert.notNull(urlPath, "URL path must not be null");
    		Assert.notNull(handler, "Handler object must not be null");
    		Object resolvedHandler = handler;
    
    		// Eagerly resolve handler if referencing singleton via name.
    		if (!this.lazyInitHandlers && handler instanceof String) {
    			String handlerName = (String) handler;
    			ApplicationContext applicationContext = obtainApplicationContext();
    			if (applicationContext.isSingleton(handlerName)) {
    				resolvedHandler = applicationContext.getBean(handlerName);
    			}
    		}
    
    		Object mappedHandler = this.handlerMap.get(urlPath);
    		if (mappedHandler != null) {
    			if (mappedHandler != resolvedHandler) {
    				throw new IllegalStateException(
    						"Cannot map " + getHandlerDescription(handler) + " to URL path [" + urlPath +
    						"]: There is already " + getHandlerDescription(mappedHandler) + " mapped.");
    			}
    		}
    		else {
    			if (urlPath.equals("/")) {
    				if (logger.isInfoEnabled()) {
    					logger.info("Root mapping to " + getHandlerDescription(handler));
    				}
    				setRootHandler(resolvedHandler);
    			}
    			else if (urlPath.equals("/*")) {
    				if (logger.isInfoEnabled()) {
    					logger.info("Default mapping to " + getHandlerDescription(handler));
    				}
    				setDefaultHandler(resolvedHandler);
    			}
    			else {
    				this.handlerMap.put(urlPath, resolvedHandler);
    				if (logger.isInfoEnabled()) {
    					logger.info("Mapped URL path [" + urlPath + "] onto " + getHandlerDescription(handler));
    				}
    			}
    		}
    	}

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

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmd3dWxpcG8_size_16_color_FFFFFF_t_70 1]  
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());
    		//freemarker页面
    		if (httpMethod == HttpMethod.PATCH || httpMethod == null) {
    			processRequest(request, response);
    		}
    		//前后端分离
    		else {
    			super.service(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);
    
    		RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
    		ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
    
    		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    		asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
    
    		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 {
    			resetContextHolders(request, previousLocaleContext, previousAttributes);
    			if (requestAttributes != null) {
    				requestAttributes.requestCompleted();
    			}
    
    			if (logger.isDebugEnabled()) {
    				if (failureCause != null) {
    					this.logger.debug("Could not complete request", failureCause);
    				}
    				else {
    					if (asyncManager.isConcurrentHandlingStarted()) {
    						logger.debug("Leaving response open for concurrent processing");
    					}
    					else {
    						this.logger.debug("Successfully completed request");
    					}
    				}
    			}
    
    			publishRequestHandledEvent(request, response, startTime, failureCause);
    		}
    	}
    
    	protected abstract void doService(HttpServletRequest request, HttpServletResponse response)
    			throws Exception;

doService模板方法

DispatcherServlet

@Override
    	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
    		if (logger.isDebugEnabled()) {
    			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
    			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
    					" processing " + request.getMethod() + " request for [" + getRequestUri(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));
    				}
    			}
    		}
    
    		// 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());
    
    		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 {
    			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);
    				}
    			}
    		}
    	}
    
    	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.检查是否文件上传
    				processedRequest = checkMultipart(request);
    				multipartRequestParsed = (processedRequest != request);
    
    				//2.根据handlerMapping获取handler执行链，包含handler和拦截器数组
    				// Determine handler for the current request.
    				mappedHandler = getHandler(processedRequest);
    				if (mappedHandler == null) {
    					noHandlerFound(processedRequest, response);
    					return;
    				}
    
    				//3. 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;
    					}
    				}
    
    				//4.执行拦截器链的前处理
    				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
    					return;
    				}
    
    				//5.调用handlerAdapter处理handler的方法，返回数据和视图
    				// Actually invoke the handler.
    				mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
    
    				if (asyncManager.isConcurrentHandlingStarted()) {
    					return;
    				}
    
    				applyDefaultViewName(processedRequest, mv);
    				//6.拦截器链后处理
    				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);
    			}
    			//7.渲染视图和拦截器链最终处理
    			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);
    				}
    			}
    		}
    	}

2.根据handlerMapping获取handler执行链，包含handler和拦截器数组  
遍历handlerMapping，获取handler执行链，包含handler（controller）和interceptor数组

protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    		if (this.handlerMappings != null) {
    			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;
    	}

AbstractHandlerMapping

@Override
    	@Nullable
    	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    		Object handler = getHandlerInternal(request);
    		if (handler == null) {
    			handler = getDefaultHandler();
    		}
    		if (handler == null) {
    			return null;
    		}
    		// Bean name or resolved handler?
    		if (handler instanceof String) {
    			String handlerName = (String) handler;
    			handler = obtainApplicationContext().getBean(handlerName);
    		}
    
    		HandlerExecutionChain executionChain = getHandlerExecutionChain(handler, request);
    		if (CorsUtils.isCorsRequest(request)) {
    			CorsConfiguration globalConfig = this.globalCorsConfigSource.getCorsConfiguration(request);
    			CorsConfiguration handlerConfig = getCorsConfiguration(handler, request);
    			CorsConfiguration config = (globalConfig != null ? globalConfig.combine(handlerConfig) : handlerConfig);
    			executionChain = getCorsHandlerExecutionChain(request, executionChain, config);
    		}
    		return executionChain;
    	}
    	
    	protected abstract Object getHandlerInternal(HttpServletRequest request) throws Exception;
    
    	/**
    	 * Build a {@link HandlerExecutionChain} for the given handler, including
    	 * applicable interceptors.
    	 */
    	protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
    		HandlerExecutionChain chain = (handler instanceof HandlerExecutionChain ?
    				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler));
    
    		String lookupPath = this.urlPathHelper.getLookupPathForRequest(request);
    		for (HandlerInterceptor interceptor : this.adaptedInterceptors) {
    			if (interceptor instanceof MappedInterceptor) {
    				MappedInterceptor mappedInterceptor = (MappedInterceptor) interceptor;
    				if (mappedInterceptor.matches(lookupPath, this.pathMatcher)) {
    					chain.addInterceptor(mappedInterceptor.getInterceptor());
    				}
    			}
    			else {
    				chain.addInterceptor(interceptor);
    			}
    		}
    		return chain;
    	}

AbstractUrlHandlerMapping从第一步ApplicationContext初始化建立的handlerMap中查询handler

protected Object lookupHandler(String urlPath, HttpServletRequest request) throws Exception {
    		// Direct match?
    		Object handler = this.handlerMap.get(urlPath);
    		if (handler != null) {
    			// Bean name or resolved handler?
    			if (handler instanceof String) {
    				String handlerName = (String) handler;
    				handler = obtainApplicationContext().getBean(handlerName);
    			}
    			validateHandler(handler, request);
    			return buildPathExposingHandler(handler, urlPath, urlPath, null);
    		}
    
    		// Pattern match?
    		List<String> matchingPatterns = new ArrayList<>();
    		for (String registeredPattern : this.handlerMap.keySet()) {
    			if (getPathMatcher().match(registeredPattern, urlPath)) {
    				matchingPatterns.add(registeredPattern);
    			}
    			else if (useTrailingSlashMatch()) {
    				if (!registeredPattern.endsWith("/") && getPathMatcher().match(registeredPattern + "/", urlPath)) {
    					matchingPatterns.add(registeredPattern +"/");
    				}
    			}
    		}
    
    		String bestMatch = null;
    		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
    		if (!matchingPatterns.isEmpty()) {
    			matchingPatterns.sort(patternComparator);
    			if (logger.isDebugEnabled()) {
    				logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
    			}
    			bestMatch = matchingPatterns.get(0);
    		}
    		if (bestMatch != null) {
    			handler = this.handlerMap.get(bestMatch);
    			if (handler == null) {
    				if (bestMatch.endsWith("/")) {
    					handler = this.handlerMap.get(bestMatch.substring(0, bestMatch.length() - 1));
    				}
    				if (handler == null) {
    					throw new IllegalStateException(
    							"Could not find handler for best pattern match [" + bestMatch + "]");
    				}
    			}
    			// Bean name or resolved handler?
    			if (handler instanceof String) {
    				String handlerName = (String) handler;
    				handler = obtainApplicationContext().getBean(handlerName);
    			}
    			validateHandler(handler, request);
    			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestMatch, urlPath);
    
    			// There might be multiple 'best patterns', let's make sure we have the correct URI template variables
    			// for all of them
    			Map<String, String> uriTemplateVariables = new LinkedHashMap<>();
    			for (String matchingPattern : matchingPatterns) {
    				if (patternComparator.compare(bestMatch, matchingPattern) == 0) {
    					Map<String, String> vars = getPathMatcher().extractUriTemplateVariables(matchingPattern, urlPath);
    					Map<String, String> decodedVars = getUrlPathHelper().decodePathVariables(request, vars);
    					uriTemplateVariables.putAll(decodedVars);
    				}
    			}
    			if (logger.isDebugEnabled()) {
    				logger.debug("URI Template variables for request [" + urlPath + "] are " + uriTemplateVariables);
    			}
    			return buildPathExposingHandler(handler, bestMatch, pathWithinMapping, uriTemplateVariables);
    		}
    
    		// No handler found...
    		return null;
    	}

3.DispatcherServlet根据handler获取handlerAdapter

protected HandlerAdapter getHandlerAdapter(Object handler) throws ServletException {
    		if (this.handlerAdapters != null) {
    			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 +
    				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
    	}

4.执行拦截器链的前处理

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
    		HandlerInterceptor[] interceptors = getInterceptors();
    		if (!ObjectUtils.isEmpty(interceptors)) {
    			for (int i = 0; i < interceptors.length; i++) {
    				HandlerInterceptor interceptor = interceptors[i];
    				if (!interceptor.preHandle(request, response, this.handler)) {
    					triggerAfterCompletion(request, response, null);
    					return false;
    				}
    				this.interceptorIndex = i;
    			}
    		}
    		return true;
    	}

5.调用handlerAdapter处理handler的方法，返回ModelAndView，数据和视图  
HttpRequestHandlerAdapter

@Override
    	public boolean supports(Object handler) {
    		return (handler instanceof HttpRequestHandler);
    	}
    	
    	@Override
    	@Nullable
    	public ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    			throws Exception {
    
    		((HttpRequestHandler) handler).handleRequest(request, response);
    		return null;
    	}

AbstractHandlerMethodAdapter

@Override
    	@Nullable
    	public final ModelAndView handle(HttpServletRequest request, HttpServletResponse response, Object handler)
    			throws Exception {
    
    		return handleInternal(request, response, (HandlerMethod) handler);
    	}
    	
    	protected abstract ModelAndView handleInternal(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception;

RequestMappingHandlerAdapter

@Override
    	protected ModelAndView handleInternal(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    
    		ModelAndView mav;
    		checkRequest(request);
    
    		// Execute invokeHandlerMethod in synchronized block if required.
    		if (this.synchronizeOnSession) {
    			HttpSession session = request.getSession(false);
    			if (session != null) {
    				Object mutex = WebUtils.getSessionMutex(session);
    				synchronized (mutex) {
    					mav = invokeHandlerMethod(request, response, handlerMethod);
    				}
    			}
    			else {
    				// No HttpSession available -> no mutex necessary
    				mav = invokeHandlerMethod(request, response, handlerMethod);
    			}
    		}
    		else {
    			// No synchronization on session demanded at all...
    			mav = invokeHandlerMethod(request, response, handlerMethod);
    		}
    
    		if (!response.containsHeader(HEADER_CACHE_CONTROL)) {
    			if (getSessionAttributesHandler(handlerMethod).hasSessionAttributes()) {
    				applyCacheSeconds(response, this.cacheSecondsForSessionAttributeHandlers);
    			}
    			else {
    				prepareResponse(response);
    			}
    		}
    
    		return mav;
    	}
    
    	/**
    	 * Invoke the {@link RequestMapping} handler method preparing a {@link ModelAndView}
    	 * if view resolution is required.
    	 */
    	@Nullable
    	protected ModelAndView invokeHandlerMethod(HttpServletRequest request,
    			HttpServletResponse response, HandlerMethod handlerMethod) throws Exception {
    
    		ServletWebRequest webRequest = new ServletWebRequest(request, response);
    		try {
    			WebDataBinderFactory binderFactory = getDataBinderFactory(handlerMethod);
    			ModelFactory modelFactory = getModelFactory(handlerMethod, binderFactory);
    
    			ServletInvocableHandlerMethod invocableMethod = createInvocableHandlerMethod(handlerMethod);
    			if (this.argumentResolvers != null) {
    				invocableMethod.setHandlerMethodArgumentResolvers(this.argumentResolvers);
    			}
    			if (this.returnValueHandlers != null) {
    				invocableMethod.setHandlerMethodReturnValueHandlers(this.returnValueHandlers);
    			}
    			invocableMethod.setDataBinderFactory(binderFactory);
    			invocableMethod.setParameterNameDiscoverer(this.parameterNameDiscoverer);
    
    			ModelAndViewContainer mavContainer = new ModelAndViewContainer();
    			mavContainer.addAllAttributes(RequestContextUtils.getInputFlashMap(request));
    			modelFactory.initModel(webRequest, mavContainer, invocableMethod);
    			mavContainer.setIgnoreDefaultModelOnRedirect(this.ignoreDefaultModelOnRedirect);
    
    			AsyncWebRequest asyncWebRequest = WebAsyncUtils.createAsyncWebRequest(request, response);
    			asyncWebRequest.setTimeout(this.asyncRequestTimeout);
    
    			WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
    			asyncManager.setTaskExecutor(this.taskExecutor);
    			asyncManager.setAsyncWebRequest(asyncWebRequest);
    			asyncManager.registerCallableInterceptors(this.callableInterceptors);
    			asyncManager.registerDeferredResultInterceptors(this.deferredResultInterceptors);
    
    			if (asyncManager.hasConcurrentResult()) {
    				Object result = asyncManager.getConcurrentResult();
    				mavContainer = (ModelAndViewContainer) asyncManager.getConcurrentResultContext()[0];
    				asyncManager.clearConcurrentResult();
    				if (logger.isDebugEnabled()) {
    					logger.debug("Found concurrent result value [" + result + "]");
    				}
    				invocableMethod = invocableMethod.wrapConcurrentResult(result);
    			}
    
    			invocableMethod.invokeAndHandle(webRequest, mavContainer);
    			if (asyncManager.isConcurrentHandlingStarted()) {
    				return null;
    			}
    
    			return getModelAndView(mavContainer, modelFactory, webRequest);
    		}
    		finally {
    			webRequest.requestCompleted();
    		}
    	}

ServletInvocableHandlerMethod

/**
    	 * Invoke the method and handle the return value through one of the
    	 * configured {@link HandlerMethodReturnValueHandler}s.
    	 */
    	public void invokeAndHandle(ServletWebRequest webRequest, ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception {
    
    		Object returnValue = invokeForRequest(webRequest, mavContainer, providedArgs);
    		setResponseStatus(webRequest);
    
    		if (returnValue == null) {
    			if (isRequestNotModified(webRequest) || getResponseStatus() != null || mavContainer.isRequestHandled()) {
    				mavContainer.setRequestHandled(true);
    				return;
    			}
    		}
    		else if (StringUtils.hasText(getResponseStatusReason())) {
    			mavContainer.setRequestHandled(true);
    			return;
    		}
    
    		mavContainer.setRequestHandled(false);
    		Assert.state(this.returnValueHandlers != null, "No return value handlers");
    		try {
    			this.returnValueHandlers.handleReturnValue(
    					returnValue, getReturnValueType(returnValue), mavContainer, webRequest);
    		}
    		catch (Exception ex) {
    			if (logger.isTraceEnabled()) {
    				logger.trace(getReturnValueHandlingErrorMessage("Error handling return value", returnValue), ex);
    			}
    			throw ex;
    		}
    	}

InvocableHandlerMethod执行请求

/**
    	 * Invoke the method after resolving its argument values in the context of the given request.
    	 */
    	@Nullable
    	public Object invokeForRequest(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception {
    
    		Object[] args = getMethodArgumentValues(request, mavContainer, providedArgs);
    		if (logger.isTraceEnabled()) {
    			logger.trace("Invoking '" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
    					"' with arguments " + Arrays.toString(args));
    		}
    		Object returnValue = doInvoke(args);
    		if (logger.isTraceEnabled()) {
    			logger.trace("Method [" + ClassUtils.getQualifiedMethodName(getMethod(), getBeanType()) +
    					"] returned [" + returnValue + "]");
    		}
    		return returnValue;
    	}
    
    
    	/**
    	 * Get the method argument values for the current request.
    	 */
    	private Object[] getMethodArgumentValues(NativeWebRequest request, @Nullable ModelAndViewContainer mavContainer,
    			Object... providedArgs) throws Exception {
    
    		MethodParameter[] parameters = getMethodParameters();
    		Object[] args = new Object[parameters.length];
    		for (int i = 0; i < parameters.length; i++) {
    			MethodParameter parameter = parameters[i];
    			parameter.initParameterNameDiscovery(this.parameterNameDiscoverer);
    			args[i] = resolveProvidedArgument(parameter, providedArgs);
    			if (args[i] != null) {
    				continue;
    			}
    			if (this.argumentResolvers.supportsParameter(parameter)) {
    				try {
    					args[i] = this.argumentResolvers.resolveArgument(
    							parameter, mavContainer, request, this.dataBinderFactory);
    					continue;
    				}
    				catch (Exception ex) {
    					if (logger.isDebugEnabled()) {
    						logger.debug(getArgumentResolutionErrorMessage("Failed to resolve", i), ex);
    					}
    					throw ex;
    				}
    			}
    			if (args[i] == null) {
    				throw new IllegalStateException("Could not resolve method parameter at index " +
    						parameter.getParameterIndex() + " in " + parameter.getExecutable().toGenericString() +
    						": " + getArgumentResolutionErrorMessage("No suitable resolver for", i));
    			}
    		}
    		return args;
    	}
    
    
    	/**
    	 * Attempt to resolve a method parameter from the list of provided argument values.
    	 */
    	@Nullable
    	private Object resolveProvidedArgument(MethodParameter parameter, @Nullable Object... providedArgs) {
    		if (providedArgs == null) {
    			return null;
    		}
    		for (Object providedArg : providedArgs) {
    			if (parameter.getParameterType().isInstance(providedArg)) {
    				return providedArg;
    			}
    		}
    		return null;
    	}
    
    
    	/**
    	 * Invoke the handler method with the given argument values.
    	 * 用反射调用方法
    	 */
    	protected Object doInvoke(Object... args) throws Exception {
    		ReflectionUtils.makeAccessible(getBridgedMethod());
    		try {
    			return getBridgedMethod().invoke(getBean(), args);
    		}
    		catch (IllegalArgumentException ex) {
    			assertTargetBean(getBridgedMethod(), getBean(), args);
    			String text = (ex.getMessage() != null ? ex.getMessage() : "Illegal argument");
    			throw new IllegalStateException(getInvocationErrorMessage(text, args), ex);
    		}
    		catch (InvocationTargetException ex) {
    			// Unwrap for HandlerExceptionResolvers ...
    			Throwable targetException = ex.getTargetException();
    			if (targetException instanceof RuntimeException) {
    				throw (RuntimeException) targetException;
    			}
    			else if (targetException instanceof Error) {
    				throw (Error) targetException;
    			}
    			else if (targetException instanceof Exception) {
    				throw (Exception) targetException;
    			}
    			else {
    				String text = getInvocationErrorMessage("Failed to invoke handler method", args);
    				throw new IllegalStateException(text, targetException);
    			}
    		}
    	}

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

5.拦截器链后处理  
HandlerExecutionChain

/**
    	 * Apply postHandle methods of registered interceptors.
    	 */
    	void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
    			throws Exception {
    
    		HandlerInterceptor[] interceptors = getInterceptors();
    		if (!ObjectUtils.isEmpty(interceptors)) {
    			for (int i = interceptors.length - 1; i >= 0; i--) {
    				HandlerInterceptor interceptor = interceptors[i];
    				interceptor.postHandle(request, response, this.handler, mv);
    			}
    		}
    	}

6.渲染视图和拦截器链最终处理  
DispatcherServlet

/**
    	 * Handle the result of handler selection and handler invocation, which is
    	 * either a ModelAndView or an Exception to be resolved to a ModelAndView.
    	 */
    	private void processDispatchResult(HttpServletRequest request, HttpServletResponse response,
    			@Nullable HandlerExecutionChain mappedHandler, @Nullable ModelAndView mv,
    			@Nullable Exception exception) throws Exception {
    
    		boolean errorView = false;
    
    		if (exception != null) {
    			if (exception instanceof ModelAndViewDefiningException) {
    				logger.debug("ModelAndViewDefiningException encountered", exception);
    				mv = ((ModelAndViewDefiningException) exception).getModelAndView();
    			}
    			else {
    				Object handler = (mappedHandler != null ? mappedHandler.getHandler() : null);
    				mv = processHandlerException(request, response, handler, exception);
    				errorView = (mv != null);
    			}
    		}
    
    		// Did the handler return a view to render?
    		if (mv != null && !mv.wasCleared()) {
    			render(mv, request, 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");
    			}
    		}
    
    		if (WebAsyncUtils.getAsyncManager(request).isConcurrentHandlingStarted()) {
    			// Concurrent handling started during a forward
    			return;
    		}
    
    		if (mappedHandler != null) {
    		//拦截器链最终处理
    			mappedHandler.triggerAfterCompletion(request, response, null);
    		}
    	}
    
    
    	/**
    	 * Render the given ModelAndView.
    	 * <p>This is the last stage in handling a request. It may involve resolving the view by name.
    	 */
    	protected void render(ModelAndView mv, HttpServletRequest request, HttpServletResponse response) throws Exception {
    		// Determine locale for request and apply it to the response.
    		Locale locale =
    				(this.localeResolver != null ? this.localeResolver.resolveLocale(request) : request.getLocale());
    		response.setLocale(locale);
    
    		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() + "'");
    			}
    		}
    		else {
    			// No need to lookup: the ModelAndView object contains the actual View object.
    			view = mv.getView();
    			if (view == null) {
    				throw new ServletException("ModelAndView [" + mv + "] neither contains a view name nor a " +
    						"View object in servlet with name '" + getServletName() + "'");
    			}
    		}
    
    		// Delegate to the View object for rendering.
    		if (logger.isDebugEnabled()) {
    			logger.debug("Rendering view [" + view + "] in DispatcherServlet with name '" + getServletName() + "'");
    		}
    		try {
    			if (mv.getStatus() != null) {
    				response.setStatus(mv.getStatus().value());
    			}
    			view.render(mv.getModelInternal(), request, response);
    		}
    		catch (Exception ex) {
    			if (logger.isDebugEnabled()) {
    				logger.debug("Error rendering view [" + view + "] in DispatcherServlet with name '" +
    						getServletName() + "'", ex);
    			}
    			throw ex;
    		}
    	}

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmd3dWxpcG8_size_16_color_FFFFFF_t_70]: /images/20220221/52362225b0e04fd6a87c4cea8115b546.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L21pbmd3dWxpcG8_size_16_color_FFFFFF_t_70 1]: /images/20220221/c828317c55d14a798474f5386e2c787a.png