SpringMvc学习笔记----DispatcherServlet

SpringMVC学习笔记

DispatcherServlet

DispatcherServlet初始化过程

DispatcherServlet的初始化调用了重写父类的onRefresh方法，该方法中又调用了initStrategies方法

@Override
	protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}

	/**
	 * Initialize the strategy objects that this servlet uses.
	 * <p>May be overridden in subclasses in order to initialize further strategy objects.
	 */
	protected void initStrategies(ApplicationContext context) {
        //处理二进制文件的请求处理器初始化
		initMultipartResolver(context);
        //语言处理器
		initLocaleResolver(context);
        //主题处理器，css、js
		initThemeResolver(context);
        //映射器
		initHandlerMappings(context);
        //适配器
		initHandlerAdapters(context);
        //异常处理器
		initHandlerExceptionResolvers(context);
        //处理默认视图
		initRequestToViewNameTranslator(context);
        //视图处理器
		initViewResolvers(context);
		initFlashMapManager(context);
	}

以视图处理器为例分析DispatcherServlet加载它的过程。

先从DispatcherServlet所维护的容器中读取，如果没有则去默认的资源路径下创建。默认路径为DispatcherServlet类路径下的DispatcherServlet.properties文件。最后将这些handlerMapping都添加到DispatcherServlet的this.handlerMappings集合中。

private void initHandlerMappings(ApplicationContext context) {
		this.handlerMappings = null;

    //从容器中读取
		if (this.detectAllHandlerMappings) {
			// Find all HandlerMappings in the ApplicationContext, including ancestor contexts.
			Map<String, HandlerMapping> matchingBeans =
					BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
			if (!matchingBeans.isEmpty()) {
				this.handlerMappings = new ArrayList<>(matchingBeans.values());
				// We keep HandlerMappings in sorted order.
				AnnotationAwareOrderComparator.sort(this.handlerMappings);
			}
		}
		else {
			try {
				HandlerMapping hm = context.getBean(HANDLER_MAPPING_BEAN_NAME, HandlerMapping.class);
				this.handlerMappings = Collections.singletonList(hm);
			}
			catch (NoSuchBeanDefinitionException ex) {
				// Ignore, we'll add a default HandlerMapping later.
			}
		}

		// Ensure we have at least one HandlerMapping, by registering
		// a default HandlerMapping if no other mappings are found.
   
    	//从默认路径下读取
		if (this.handlerMappings == null) {
			this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
			if (logger.isTraceEnabled()) {
				logger.trace("No HandlerMappings declared for servlet '" + getServletName() +
						"': using default strategies from DispatcherServlet.properties");
			}
		}

		for (HandlerMapping mapping : this.handlerMappings) {
			if (mapping.usesPathPatterns()) {
				this.parseRequestPath = true;
				break;
			}
		}
	}

从默认文件中读取配置

	protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
			if (defaultStrategies == null) {
				try {
					// Load default strategy implementations from properties file.
					// This is currently strictly internal and not meant to be customized
					// by application developers.
					ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
					defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
				}
				catch (IOException ex) {
					throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
				}
			}		
		String key = strategyInterface.getName();
		String value = defaultStrategies.getProperty(key);
		if (value != null) {
			String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
			List<T> strategies = new ArrayList<>(classNames.length);
			for (String className : classNames) {
				try {
					Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
					Object strategy = createDefaultStrategy(context, clazz);
					strategies.add((T) strategy);
				}
				catch (ClassNotFoundException ex) {
					throw new BeanInitializationException(
							"Could not find DispatcherServlet's default strategy class [" + className +
							"] for interface [" + key + "]", ex);
				}
				catch (LinkageError err) {
					throw new BeanInitializationException(
							"Unresolvable class definition for DispatcherServlet's default strategy class [" +
							className + "] for interface [" + key + "]", err);
				}
			}
			return strategies;
		}
		else {
			return Collections.emptyList();
		}
	}

默认配置文件，包含了DispatcherServlet中的默认组件信息。

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping,\
	org.springframework.web.servlet.function.support.RouterFunctionMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter,\
	org.springframework.web.servlet.function.support.HandlerFunctionAdapter


org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

DispatcherServlet处理请求流程分析

HttpServlet的service方法接收请求，丢弃掉不是HttpServlet类型的请求，将符合的请求传递给子类的service方法。FrameworkServlet判断HttpMethod的类型是否为PATCH ，是则直接加工该请求，否则传回给父类，父类根据该请求的HttpMethod的类型再进行分发。FrameworkServlet中的doXX承接到父类的请求,最后它们都流向了processRequest(request, response)。processRequest中进行一次请求加工调用到DispatcherServlet的doService，再流入到doDispatch。

为什么设计的这么绕，我个人的理解是相比于httpServlet中的GET, HEAD, POST, PUT, DELETE, OPTIONS, TRACE等请求方式,SpringMVC多提供了一种PATCH的方式。为了处理这种请求方式。框架设计者并没有选择直观的在FrameworkServlet中的重写的service方法中支持对SpringMVC中所有HttpMethod的类型判断，再增加一个doDispatch方法。而是只判断了一种类型再交给父类，最后都流向了processRequest方法。这样写代码的精妙之处我现在还体会不出。。。

doDispatch方法

doDispatch方法名副其实的在dispatch。它主要干了这些事：根据request调用维护的HandlerMapping集合的getHandler进行匹配，一旦有一个匹配成功就停止匹配。这时候会拿到一个HandlerExecutionChain。HandlerExecutionChain中有一个handler和interceptorList(拦截器集合)。前者还要去匹配一个适配器，由适配器负责handler(业务逻辑)的执行。后者在接下来可以被直接调用。

关于request和HandlerMapping匹配根据HandlerMapping的类型不同有不同方式。

Return a handler and any interceptors for this request. The choice may be made on request URL, session state, or any factor the implementing class chooses.

再去找RequestMappingHandlerMapping的具体匹配方式，发现在它的父类中维护着一个内部类MappingRegistry。然后是大概通过查表匹配。源码翻到这翻不下去了，发现想彻底弄清源码实在太难了，又想到弄懂了就能找到工作吗？看这玩意有意义吗？一阵迷茫。。。

但是又又想想这种无意义不才是人生的主题嘛，欣然接受吧。

class MappingRegistry {

		private final Map<T, MappingRegistration<T>> registry = new HashMap<>();

		private final MultiValueMap<String, T> pathLookup = new LinkedMultiValueMap<>();

		private final Map<String, List<HandlerMethod>> nameLookup = new ConcurrentHashMap<>();

		private final Map<HandlerMethod, CorsConfiguration> corsLookup = new ConcurrentHashMap<>();

		private final ReentrantReadWriteLock readWriteLock = new ReentrantReadWriteLock();

doDispatch源码

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.
          //拿到HandlerExecutionChain
         mappedHandler = getHandler(processedRequest);
         if (mappedHandler == 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 = HttpMethod.GET.matches(method);
         if (isGet || HttpMethod.HEAD.matches(method)) {
            long lastModified = ha.getLastModified(request, mappedHandler.getHandler());
            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;
      }
      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);
      }
      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);
         }
      }
   }
}

从源码理解拦截器执行顺序

从拦截器链拿出拦截器挨个执行前置方法，处理失败前先把异常后方法执行了再返回一个false。this.interceptorIndex = i。这个i决定了等等后置方法和异常后方法从哪里开始执行。i由HandlerExecutionChain对象维护。

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
   for (int i = 0; i < this.interceptorList.size(); i++) {
      HandlerInterceptor interceptor = this.interceptorList.get(i);
      if (!interceptor.preHandle(request, response, this.handler)) {
         triggerAfterCompletion(request, response, null);
         return false;
      }
      this.interceptorIndex = i;
   }
   return true;
}


void applyPostHandle(HttpServletRequest request, HttpServletResponse response, @Nullable ModelAndView mv)
			throws Exception {

		for (int i = this.interceptorList.size() - 1; i >= 0; i--) {
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			interceptor.postHandle(request, response, this.handler, mv);
		}
	}


void triggerAfterCompletion(HttpServletRequest request, HttpServletResponse response, @Nullable Exception ex) {
		for (int i = this.interceptorIndex; i >= 0; i--) {
			HandlerInterceptor interceptor = this.interceptorList.get(i);
			try {
				interceptor.afterCompletion(request, response, this.handler, ex);
			}
			catch (Throwable ex2) {
				logger.error("HandlerInterceptor.afterCompletion threw exception", ex2);
			}
		}
	}

画图梳理整个doDispatch过程