Spring源代码分析之Spring MVC之HanderMapping请求映射处理

向右看齐 2022-08-27 14:59 193阅读 0赞

AbstractHandlerMappig调用getHandler()

/**
    	 * Look up a handler for the given request, falling back to the default
    	 * handler if no specific one is found.
    	 * @param request current HTTP request
    	 * @return the corresponding handler instance, or the default handler
    	 * @see #getHandlerInternal
    	 */
    	public final HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {
    		Object handler = getHandlerInternal(request);
    		//使用默认的Handler
    		if (handler == null) {
    			handler = getDefaultHandler();
    		}
    		if (handler == null) {
    			return null;
    		}
    		// Bean name or resolved handler?
      		//这里根据名称来取出相应的Handler Bean
    		if (handler instanceof String) {
    			String handlerName = (String) handler;
    			handler = getApplicationContext().getBean(handlerName);
    		}
    		//封装成HandlerExecutionChain
    		return getHandlerExecutionChain(handler, request);
    	}

具体获取getHandlerExecutionChain：

protected HandlerExecutionChain getHandlerExecutionChain(Object handler, HttpServletRequest request) {
    		HandlerExecutionChain chain =
    			(handler instanceof HandlerExecutionChain) ?
    				(HandlerExecutionChain) handler : new HandlerExecutionChain(handler);
    
    		chain.addInterceptors(getAdaptedInterceptors());
    
    		String lookupPath = urlPathHelper.getLookupPathForRequest(request);
    		for (MappedInterceptor mappedInterceptor : mappedInterceptors) {
    			if (mappedInterceptor.matches(lookupPath, pathMatcher)) {
    				chain.addInterceptor(mappedInterceptor.getInterceptor());
    			}
    		}
    
    		return chain;
    	}

具体的获取Handler的过程

/**
    	 * Look up a handler for the URL path of the given request.
    	 * @param request current HTTP request
    	 * @return the handler instance, or {@code null} if none found
    	 */
    	@Override
    	protected Object getHandlerInternal(HttpServletRequest request) throws Exception {
    		//对请求的参数进行分析，得到具体的参数信息
    		String lookupPath = getUrlPathHelper().getLookupPathForRequest(request);
    		//将得到的URL路径与handler进行匹配，得到对应的handler，不匹配，就返回默认的handler
    		Object handler = lookupHandler(lookupPath, request);
    		if (handler == null) {
    			// We need to care for the default handler directly, since we need to
    			// expose the PATH_WITHIN_HANDLER_MAPPING_ATTRIBUTE for it as well.
                            //这里需要注意的是对默认的handler的处理
    			Object rawHandler = null;
    			if ("/".equals(lookupPath)) {
    				rawHandler = getRootHandler();
    			}
    			if (rawHandler == null) {
    				rawHandler = getDefaultHandler();
    			}
    			if (rawHandler != null) {
    				// Bean name or resolved handler?
    				if (rawHandler instanceof String) {
    					String handlerName = (String) rawHandler;
    					rawHandler = getApplicationContext().getBean(handlerName);
    				}
    				validateHandler(rawHandler, request);
    				handler = buildPathExposingHandler(rawHandler, lookupPath, lookupPath, null);
    			}
    		}
    		if (handler != null && logger.isDebugEnabled()) {
    			logger.debug("Mapping [" + lookupPath + "] to " + handler);
    		}
    		else if (handler == null && logger.isTraceEnabled()) {
    			logger.trace("No handler mapping found for [" + lookupPath + "]");
    		}
    		return handler;
    	}

根据路径来查找Handler

/**
 	 * Look up a handler instance for the given URL path.
 	 * Supports direct matches, e.g. a registered "/test" matches "/test",
 	 * and various Ant-style pattern matches, e.g. a registered "/t*" matches
 	 * both "/test" and "/team". For details, see the AntPathMatcher class.
 	 * Looks for the most exact pattern, where most exact is defined as
 	 * the longest path pattern.
 	 * @param urlPath URL the bean is mapped to
 	 * @param request current HTTP request (to expose the path within the mapping to)
 	 * @return the associated handler instance, or {@code null} if not found
 	 * @see #exposePathWithinMapping
 	 * @see org.springframework.util.AntPathMatcher
 	 */
 	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 = getApplicationContext().getBean(handlerName);
 			}
 			validateHandler(handler, request);
 			return buildPathExposingHandler(handler, urlPath, urlPath, null);
 		}
 		// Pattern match?
 		List<String> matchingPatterns = new ArrayList<String>();
 		for (String registeredPattern : this.handlerMap.keySet()) {
 			if (getPathMatcher().match(registeredPattern, urlPath)) {
 				matchingPatterns.add(registeredPattern);
 			}
 		}
 		String bestPatternMatch = null;
 		Comparator<String> patternComparator = getPathMatcher().getPatternComparator(urlPath);
 		if (!matchingPatterns.isEmpty()) {
 			Collections.sort(matchingPatterns, patternComparator);
 			if (logger.isDebugEnabled()) {
 				logger.debug("Matching patterns for request [" + urlPath + "] are " + matchingPatterns);
 			}
 			bestPatternMatch = matchingPatterns.get(0);
 		}
 		if (bestPatternMatch != null) {
 			handler = this.handlerMap.get(bestPatternMatch);
 			// Bean name or resolved handler?
 			if (handler instanceof String) {
 				String handlerName = (String) handler;
 				handler = getApplicationContext().getBean(handlerName);
 			}
 			validateHandler(handler, request);
 			String pathWithinMapping = getPathMatcher().extractPathWithinPattern(bestPatternMatch, 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<String, String>();
 			for (String matchingPattern : matchingPatterns) {
 				if (patternComparator.compare(bestPatternMatch, 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, bestPatternMatch, pathWithinMapping, uriTemplateVariables);
 		}
 		// No handler found...
 		return null;
 	}

Dispatcher是通过doService()来相应HTTP的请求。

/**
 	 * Exposes the DispatcherServlet-specific request attributes and delegates to {@link #doDispatch}
 	 * for the actual dispatching.
 	 */
 	@Override
 	protected void doService(HttpServletRequest request, HttpServletResponse response) throws Exception {
 		if (logger.isDebugEnabled()) {
 			String requestUri = urlPathHelper.getRequestUri(request);
 			String resumed = WebAsyncUtils.getAsyncManager(request).hasConcurrentResult() ? " resumed" : "";
 			logger.debug("DispatcherServlet with name '" + getServletName() + "'" + resumed +
 					" processing " + request.getMethod() + " request for [" + requestUri + "]");
 		}
 
 		// Keep a snapshot of the request attributes in case of an include,
 		// to be able to restore the original attributes after the include.
 		//对HTTP参数进行快照处理
 		Map<String, Object> attributesSnapshot = null;
 		if (WebUtils.isIncludeRequest(request)) {
 			logger.debug("Taking snapshot of request attributes before include");
 			attributesSnapshot = new HashMap<String, Object>();
 			Enumeration<?> attrNames = request.getAttributeNames();
 			while (attrNames.hasMoreElements()) {
 				String attrName = (String) attrNames.nextElement();
 				if (this.cleanupAfterInclude || attrName.startsWith("org.springframework.web.servlet")) {
 					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());
 
 		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()) {
 				return;
 			}
 			// Restore the original attribute snapshot, in case of an include.
 			if (attributesSnapshot != null) {
 				restoreAttributesAfterInclude(request, attributesSnapshot);
 			}
 		}
 	}

![SouthEast][]  
Dispatcher的过程：

准备ModelAndView,调用getHandler来相应HTTP请求，然后通过执行handler的处理来得到返回的ModelAndView,然后把这个ModelAndView交给相应的视图对象去呈现。

/**
 	 * Process the actual dispatching to the handler.
 	 * The handler will be obtained by applying the servlet's HandlerMappings in order.
 	 * The HandlerAdapter will be obtained by querying the servlet's installed HandlerAdapters
 	 * to find the first that supports the handler class.
 	 * All HTTP methods are handled by this method. It's up to HandlerAdapters or handlers
 	 * themselves to decide which methods are acceptable.
 	 * @param request current HTTP request
 	 * @param response current HTTP response
 	 * @throws Exception in case of any kind of processing failure
 	 */
 	protected void doDispatch(HttpServletRequest request, HttpServletResponse response) throws Exception {
 		HttpServletRequest processedRequest = request;
 		HandlerExecutionChain mappedHandler = null;
 		boolean multipartRequestParsed = false;
 
 		WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
 		//这里为视图准备好一个ModelAndView,这个model持有handler处理的结果
 		try {
 			ModelAndView mv = null;
 			Exception dispatchException = null;
 
 			try {
 				processedRequest = checkMultipart(request);
 				multipartRequestParsed = processedRequest != request;
 
 				// Determine handler for the current request.
 				//根据请求获取对应的handler
 				mappedHandler = getHandler(processedRequest, false);
 				if (mappedHandler == null || mappedHandler.getHandler() == null) {
 					noHandlerFound(processedRequest, response);
 					return;
 				}
 				//这里是实际调用handler的方法，在执行handler之前，使用HandlerAdapter来检查handler的合法性，是
 				//不是按Spring的要求编写的handler
 				// 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;
 					}
 				}
 
 				if (!mappedHandler.applyPreHandle(processedRequest, response)) {
 					return;
 				}
 
 				try {
 					// Actually invoke the handler.
 					//实际上触发方法执行
 					mv = ha.handle(processedRequest, response, mappedHandler.getHandler());
 				}
 				finally {
 					if (asyncManager.isConcurrentHandlingStarted()) {
 						return;
 					}
 				}
 
 				applyDefaultViewName(request, 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
 				mappedHandler.applyAfterConcurrentHandlingStarted(processedRequest, response);
 				return;
 			}
 			// Clean up any resources used by a multipart request.
 			if (multipartRequestParsed) {
 				cleanupMultipart(processedRequest);
 			}
 		}
 	}

获取handler

/**
 	 * Return the HandlerExecutionChain for this request.
 	 * Tries all handler mappings in order.
 	 * @param request current HTTP request
 	 * @return the HandlerExecutionChain, or {@code null} if no handler could be found
 	 */
 	protected HandlerExecutionChain getHandler(HttpServletRequest request) throws Exception {

从handlerMappings获取handler

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;
    	}

获取HandlerAdapter

/**
    	 * Return the HandlerAdapter for this handler object.
    	 * @param handler the handler object to find an adapter for
    	 * @throws ServletException if no HandlerAdapter can be found for the handler. This is a fatal error.
    	 */
    	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 +
    				"]: The DispatcherServlet configuration needs to include a HandlerAdapter that supports this handler");
    	}

[SouthEast]: /images/20220823/a8df4efe4a6e459a884e6cb76a9962b1.png