Spring MVC 初始化源码分析

前言：

相信从事 Java 开发的小伙伴都使用用过 Spring MVC，同时我们知道 Spirng MVC 有 9 大组件，Spring MVC 的初始化其实就是对这些组件的初始化，前面我们分析了 Sping 的初始化，Spring 的初始化是Spring 在启动时候调用了 AbstractApplicationContext#refresh 方法完成初始化的，那 Sping MVC 又是什么时候完成初始化的？本篇我们将剖析一下 Spring MVC 的初始化过程。

Spring MVC 9 大组件

我们都知道 Spring MVC 有 9 大组件，Spring MVC 的 9 大组件定义在 DispatcherServlet 中，一下代码摘自 DispatcherServlet。

   //文件解析器
	@Nullable
    private MultipartResolver multipartResolver;
	
	//国际化解析器
    @Nullable
    private LocaleResolver localeResolver;
	
	//主题解析器
    @Nullable
    private ThemeResolver themeResolver;
	
	//处理器映射器
    @Nullable
    private List<HandlerMapping> handlerMappings;
	
	//处理器适配器
    @Nullable
    private List<HandlerAdapter> handlerAdapters;
	
	//异常解析器
    @Nullable
    private List<HandlerExceptionResolver> handlerExceptionResolvers;
	
	//视图名称解析器
    @Nullable
    private RequestToViewNameTranslator viewNameTranslator;
	
	//FlashMapManager 用于重定向时参数管理
    @Nullable
    private FlashMapManager flashMapManager;
	
	//视图解析器
    @Nullable
    private List<ViewResolver> viewResolvers;

Spring MVC 初始化源码分析

我们知道 DispatcherServlet 是 Spring MVC 的核心，Spring MVC 的初始化是不是也是在 DispatcherServlet 中进行的呢，阅读 DispatcherServlet 源码我们发现该类中有一个叫做 onRefresh 的方法，refresh 我们很熟悉，Spring 的初始化就是通过这个方法进行的，由此可以推断 DispatcherServlet #onRefresh 方法就是 Spring MVC 的初始化方法。

Spring MVC 初始简图

Spring MVC 的初始化本质上是 Servlet 的初始化，因此我们的入口是 Servlet，我们跟着这简图来走一遍源码，其中 Servlet#init、GenericsServlet#init、HttpServletBean#initServletBean都是空实现、我们就不分析了。

HttpServletBean#init 源码分析

HttpServletBean#init 方法的作用就是加载 Spring MVC 的配置文件，并没有真正的完成初始化操作，大量使用了模板方法，具体的实现由子类来实现，我们重点关注这行代码 this.initServletBean()，调用的是子类 FrameworkServlet 的 initServletBean 方法。

//org.springframework.web.servlet.HttpServletBean#init
//Spring MVC 初始化
public final void init() throws ServletException {
	//加载配置文件  也就是 web.xml 文件  Spring MVC 的配置文件
	PropertyValues pvs = new HttpServletBean.ServletConfigPropertyValues(this.getServletConfig(), this.requiredProperties);
	//配置文件是否为空
	if (!pvs.isEmpty()) {
		try {
			//获取目标对的 beanWrapper 对象
			BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
			//加载各种资源信息
			ResourceLoader resourceLoader = new ServletContextResourceLoader(this.getServletContext());
			//注册自定义编辑器
			bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, this.getEnvironment()));
			//模板方法 空实现
			this.initBeanWrapper(bw);
			//设置属性
			bw.setPropertyValues(pvs, true);
		} catch (BeansException var4) {
			if (this.logger.isErrorEnabled()) {
				this.logger.error("Failed to set bean properties on servlet '" + this.getServletName() + "'", var4);
			}

			throw var4;
		}
	}
	//模板方法 空实现
	this.initServletBean();
}

FrameworkServlet#initServletBean 方法源码分析

FrameworkServlet#initServletBean 主要作用是创建容器并刷新容器，这里面会涉及到查找 Spring Web 容器、创建容器、设置父容器、刷新容器等，简单来说就是完成 Spring MVC 容器的创建，并没有完成容器的组件初始化，真正完成 Spring MVC 9大组件初始化的是 DispatchServlet#onRefresh方法。

//org.springframework.web.servlet.FrameworkServlet#initServletBean
//初始化 ServletBean
protected final void initServletBean() throws ServletException {
	this.getServletContext().log("Initializing Spring " + this.getClass().getSimpleName() + " '" + this.getServletName() + "'");
	if (this.logger.isInfoEnabled()) {
		this.logger.info("Initializing Servlet '" + this.getServletName() + "'");
	}

	long startTime = System.currentTimeMillis();

	try {
		//创建 Spring MVC 容器 并赋值
		this.webApplicationContext = this.initWebApplicationContext();
		//没有任何实现的代码
		this.initFrameworkServlet();
	} catch (RuntimeException | ServletException var4) {
		this.logger.error("Context initialization failed", var4);
		throw var4;
	}

	if (this.logger.isDebugEnabled()) {
		String value = this.enableLoggingRequestDetails ? "shown which may lead to unsafe logging of potentially sensitive data" : "masked to prevent unsafe logging of potentially sensitive data";
		this.logger.debug("enableLoggingRequestDetails='" + this.enableLoggingRequestDetails + "': request parameters and headers will be " + value);
	}

	if (this.logger.isInfoEnabled()) {
		this.logger.info("Completed initialization in " + (System.currentTimeMillis() - startTime) + " ms");
	}

}


//org.springframework.web.servlet.FrameworkServlet#initWebApplicationContext
//初始化化 web 应用上下文 也就是 Spring MVC 容器 
protected WebApplicationContext initWebApplicationContext() {
	//获取 Spring 的根容器
	WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(this.getServletContext());
	WebApplicationContext wac = null;
	//webApplicationContext 是否为空
	if (this.webApplicationContext != null) {
		//webApplicationContext 不为空 webApplicationContext 是通过编程式注入到容器中  完成赋值
		wac = this.webApplicationContext;
		//wac 是否实现了 ConfigurableWebApplicationContext 接口
		if (wac instanceof ConfigurableWebApplicationContext) {
			//强转
			ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext)wac;
			//cwac 不是活跃的
			if (!cwac.isActive()) {
				//父容器是否为空  
				if (cwac.getParent() == null) {
					//父容器为空 设置父容器为 rootContext
					cwac.setParent(rootContext);
				}
				//配置并刷新 Web 应用程序上下文 也就是重新回到可用的状态
				this.configureAndRefreshWebApplicationContext(cwac);
			}
		}
	}
	//wac 容器是否为空 
	if (wac == null) {
		//去当前容器中查找 Spring MVC 容器
		wac = this.findWebApplicationContext();
	}
	//wac 容器是否为空 
	if (wac == null) {
		//还为空 就去创建了
		wac = this.createWebApplicationContext(rootContext);
	}
	
	//是否刷新了
	if (!this.refreshEventReceived) {
		//没有刷新就刷新创建
		synchronized(this.onRefreshMonitor) {
			this.onRefresh(wac);
		}
	}
	//是否发布
	if (this.publishContext) {
		//没有发布 就发布到 ServletContext
		String attrName = this.getServletContextAttributeName();
		//设置为 ServletContext 的一个属性
		this.getServletContext().setAttribute(attrName, wac);
	}

	return wac;
}


//org.springframework.web.servlet.FrameworkServlet#configureAndRefreshWebApplicationContext
//刷新容器
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
	//Spring MVC 容器 id
	if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
		//id 不为空
		if (this.contextId != null) {
			//设置容器id
			wac.setId(this.contextId);
		} else {
			//为空设置默认的容器id
			wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(this.getServletContext().getContextPath()) + '/' + this.getServletName());
		}
	}
	//设置容器的 ServletContext 属性
	wac.setServletContext(this.getServletContext());
	//设置容器的 ServletConfig 属性
	wac.setServletConfig(this.getServletConfig());
	//设置容器的 namespace
	wac.setNamespace(this.getNamespace());
	//给容器注册监听器 
	//SourceFilteringListener 可以根据入参数选择具体的监听器 这里实际使用的是 ContextRefreshListener 
    //ContextRefreshListener 是 FrameworkServlet 的内部类 监听 ContextRefreshedEvent 事件 也就是容器刷新事件
	//当监听到消息时调用 FrameworkServlet 的 onApplicationEvent 方法 在 onApplicationEvent 中会调用 onRefresh 方法 完成容器的组件初始化 
	//并将 refreshEventReceived 标志设置为true 表示已经容器已经被刷新过 保证了容器只会被刷一次                   
	wac.addApplicationListener(new SourceFilteringListener(wac, new FrameworkServlet.ContextRefreshListener()));
	//获取环境配置
	ConfigurableEnvironment env = wac.getEnvironment();
	if (env instanceof ConfigurableWebEnvironment) {
		//初始化属性
		((ConfigurableWebEnvironment)env).initPropertySources(this.getServletContext(), this.getServletConfig());
	}
	//空方法 子类自己扩展
	this.postProcessWebApplicationContext(wac);
	//应用初始化
	this.applyInitializers(wac);
	//刷新容器 初始化组件
	wac.refresh();
}



//org.springframework.web.servlet.FrameworkServlet#createWebApplicationContext(org.springframework.context.WebApplicationContext)
protected WebApplicationContext createWebApplicationContext(@Nullable WebApplicationContext parent) {
	return this.createWebApplicationContext((ApplicationContext)parent);
}


//org.springframework.web.servlet.FrameworkServlet#createWebApplicationContext(org.springframework.context.ApplicationContext)
protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
	//获取 contextClass  默认为XmlWebApplicationContext.class  
	Class<?> contextClass = this.getContextClass();
	//是否自定义了 Spring Web 容器
	if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
		//如果自定义了 那必须是 ConfigurableWebApplicationContext 类型 否则抛出异常
		throw new ApplicationContextException("Fatal initialization error in servlet with name '" + this.getServletName() + "': custom WebApplicationContext class [" + contextClass.getName() + "] is not of type ConfigurableWebApplicationContext");
	} else {
		//使用 BeanUtils 根据 contextClass 创建 Spring Web 容器对象  反射创建对象
		ConfigurableWebApplicationContext wac = (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
		//设置环境
		wac.setEnvironment(this.getEnvironment());
		//设置父容器
		wac.setParent(parent);
		//获取 web.xml中 DispatcherServlet 配置的 configLocation 值
		String configLocation = this.getContextConfigLocation();
		//为空判断
		if (configLocation != null) {
			//设置值
			wac.setConfigLocation(configLocation);
		}
		//刷新容器
		this.configureAndRefreshWebApplicationContext(wac);
		return wac;
	}
}

DispatcherServlet#onRefresh 源码分析

DispatcherServlet#onRefresh 方法没有太过复杂的逻辑，就是调用了 9 大组件的初始化方法，我们会对 9 大组件的初始化方法逐个分析，我们要注意 onRefresh 方法的入参是 ApplicationContext ，学过 Spring 的都知道 ApplicationContext 是一个容器接口，也就是说我们在往容器中初始化一些属性值。

//org.springframework.web.servlet.DispatcherServlet#onRefresh
//刷新 也是 Spring MVC 的初始化方法
protected void onRefresh(ApplicationContext context) {
	//初始化策略  就是初始化方法
	this.initStrategies(context);
}

//org.springframework.web.servlet.DispatcherServlet#initStrategies
//Spring MVC 初始化方法
protected void initStrategies(ApplicationContext context) {
	//初始化文件上传组件
	this.initMultipartResolver(context);
	//初始化国际化
	this.initLocaleResolver(context);
	//初始化主题解析器
	this.initThemeResolver(context);
	//初始化映射器处理器
	this.initHandlerMappings(context);
	//初始化映射器适配器
	this.initHandlerAdapters(context);
	//初始化异常解析器
	this.initHandlerExceptionResolvers(context);
	//初始化视图名称解析器
	this.initRequestToViewNameTranslator(context);
	//初始化视图解析器
	this.initViewResolvers(context);
	//初始化 FlashMapManager 用于重定向时参数管理
	this.initFlashMapManager(context);
}

DispatcherServlet#initMultipartResolver 方法源码分析

DispatcherServlet#initMultipartResolver 方法没有太多逻辑，就是从容器中获取值，完成属性赋值。

//org.springframework.web.servlet.DispatcherServlet#initMultipartResolver
//初始化文件上传组件
private void initMultipartResolver(ApplicationContext context) {
	try {
		//从容器中获取文件上传组件 并赋值
		this.multipartResolver = (MultipartResolver)context.getBean("multipartResolver", MultipartResolver.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("Detected " + this.multipartResolver);
		} else if (this.logger.isDebugEnabled()) {
			this.logger.debug("Detected " + this.multipartResolver.getClass().getSimpleName());
		}
	} catch (NoSuchBeanDefinitionException var3) {
		//发生异常 赋值为空
		this.multipartResolver = null;
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No MultipartResolver 'multipartResolver' declared");
		}
	}

}

DispatcherServlet#initLocaleResolver 方法源码分析

DispatcherServlet#initLocaleResolver 方法没有太多逻辑，就是从容器中获取值，完成属性赋值。

//org.springframework.web.servlet.DispatcherServlet#initLocaleResolver
//初始化国际化组件
private void initLocaleResolver(ApplicationContext context) {
	try {
		//从容器中获取国际化组件 并赋值
		this.localeResolver = (LocaleResolver)context.getBean("localeResolver", LocaleResolver.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("Detected " + this.localeResolver);
		} else if (this.logger.isDebugEnabled()) {
			this.logger.debug("Detected " + this.localeResolver.getClass().getSimpleName());
		}
	} catch (NoSuchBeanDefinitionException var3) {
		//发生异常 就获取默认的组件
		this.localeResolver = (LocaleResolver)this.getDefaultStrategy(context, LocaleResolver.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No LocaleResolver 'localeResolver': using default [" + this.localeResolver.getClass().getSimpleName() + "]");
		}
	}

}

//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategy
//获取默认的 LocaleResolver
protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
	//获取默认的 LocaleResolver
	List<T> strategies = this.getDefaultStrategies(context, strategyInterface);
	//不等于1 抛出异常 因为文件中只有一个
	if (strategies.size() != 1) {
		throw new BeanInitializationException("DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");
	} else {
		//返回 LocaleResolver
		return strategies.get(0);
	}
}


//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategies
//获取默认的策略
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
	//默认策略为空
	if (defaultStrategies == null) {
		try {
			//去  DispatcherServlet.properties 中读取
			ClassPathResource resource = new ClassPathResource("DispatcherServlet.properties", DispatcherServlet.class);
			//加载 DispatcherServlet.properties 文件
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		} catch (IOException var15) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + var15.getMessage());
		}
	}
	
	//获取类名 就是 LocaleResolver 名称
	String key = strategyInterface.getName();
	//从 Spring MVC jar 包中 \org\springframework\web\servlet DispatcherServlet.properties 文件中读取到的 LocaleResolver
	String value = defaultStrategies.getProperty(key);
	//为空判断
	if (value == null) {
		return Collections.emptyList();
	} else {
		//使用 value 逗号分割 得到 LocaleResolver 因为 DispatcherServlet.properties 文件中有多个 LocaleResolver
		String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
		//LocaleResolver List
		List<T> strategies = new ArrayList(classNames.length);
		String[] var7 = classNames;
		int var8 = classNames.length;
		//遍历
		for(int var9 = 0; var9 < var8; ++var9) {
			String className = var7[var9];

			try {
				//通过全类名反射实例化 LocaleResolver
				Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
				Object strategy = this.createDefaultStrategy(context, clazz);
				strategies.add(strategy);
			} catch (ClassNotFoundException var13) {
				throw new BeanInitializationException("Could not find DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var13);
			} catch (LinkageError var14) {
				throw new BeanInitializationException("Unresolvable class definition for DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var14);
			}
		}
		//返回
		return strategies;
	}
}

以下文字摘录自 \org\springframework\web\servlet\DispatcherServlet.properties 文件，文件中给了一个默认的AcceptHeaderLocaleResolver。

# 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#initThemeResolver 方法源码分析

DispatcherServlet#initThemeResolver 方法没有太多逻辑，就是从容器中获取值，完成属性赋值。

//org.springframework.web.servlet.DispatcherServlet#initThemeResolver
//初始化主题解析器
private void initThemeResolver(ApplicationContext context) {
	try {
		//从容器中获取主题解析器 并赋值
		this.themeResolver = (ThemeResolver)context.getBean("themeResolver", ThemeResolver.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("Detected " + this.themeResolver);
		} else if (this.logger.isDebugEnabled()) {
			this.logger.debug("Detected " + this.themeResolver.getClass().getSimpleName());
		}
	} catch (NoSuchBeanDefinitionException var3) {
		发生异常 就获取默认的组件
		this.themeResolver = (ThemeResolver)this.getDefaultStrategy(context, ThemeResolver.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No ThemeResolver 'themeResolver': using default [" + this.themeResolver.getClass().getSimpleName() + "]");
		}
	}

}

//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategy
//获取默认的 ThemeResolver
protected <T> T getDefaultStrategy(ApplicationContext context, Class<T> strategyInterface) {
	//获取默认的 ThemeResolver
	List<T> strategies = this.getDefaultStrategies(context, strategyInterface);
	//不等于1 抛出异常 因为文件中只有一个
	if (strategies.size() != 1) {
		throw new BeanInitializationException("DispatcherServlet needs exactly 1 strategy for interface [" + strategyInterface.getName() + "]");
	} else {
		//返回 ThemeResolver
		return strategies.get(0);
	}
}


//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategies
//获取默认的策略
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
	//默认策略为空
	if (defaultStrategies == null) {
		try {
			//去  DispatcherServlet.properties 中读取
			ClassPathResource resource = new ClassPathResource("DispatcherServlet.properties", DispatcherServlet.class);
			//加载 DispatcherServlet.properties 文件
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		} catch (IOException var15) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + var15.getMessage());
		}
	}
	
	//获取类名 就是 ThemeResolver 名称
	String key = strategyInterface.getName();
	//从 Spring MVC jar 包中 \org\springframework\web\servlet DispatcherServlet.properties 文件中读取到的 ThemeResolver
	String value = defaultStrategies.getProperty(key);
	//为空判断
	if (value == null) {
		return Collections.emptyList();
	} else {
		//使用 value 逗号分割 得到 ThemeResolver 因为 DispatcherServlet.properties 文件中有多个 ThemeResolver
		String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
		//ThemeResolver List
		List<T> strategies = new ArrayList(classNames.length);
		String[] var7 = classNames;
		int var8 = classNames.length;
		//遍历
		for(int var9 = 0; var9 < var8; ++var9) {
			String className = var7[var9];

			try {
				//通过全类名反射实例化 ThemeResolver
				Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
				Object strategy = this.createDefaultStrategy(context, clazz);
				strategies.add(strategy);
			} catch (ClassNotFoundException var13) {
				throw new BeanInitializationException("Could not find DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var13);
			} catch (LinkageError var14) {
				throw new BeanInitializationException("Unresolvable class definition for DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var14);
			}
		}
		//返回
		return strategies;
	}
}

以下文字摘录自 \org\springframework\web\servlet\DispatcherServlet.properties 文件，文件中给了一个默认的FixedThemeResolver。

# 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#initHandlerMappings 源码分析

DispatcherServlet#initHandlerMappings 方法会先从容器中获取 HandlerMapping，如果没有获取到回去加载默认的 HandlerMapping，并完成属性赋值。

//org.springframework.web.servlet.DispatcherServlet#initHandlerMappings
//初始化映射器处理器
private void initHandlerMappings(ApplicationContext context) {
	this.handlerMappings = null;
	//检测所有映射器处理器 this.detectAllHandlerMappings 默认值为 true
	if (this.detectAllHandlerMappings) {
		//从容器中获取所有映射器处理器
		Map<String, HandlerMapping> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
		if (!matchingBeans.isEmpty()) {
			//不为空 赋值给映射器处理器
			this.handlerMappings = new ArrayList(matchingBeans.values());
			//对映射器处理器排序
			AnnotationAwareOrderComparator.sort(this.handlerMappings);
		}
	} else {
		//没有检测到映射器处理器
		try {
			//获取指定 beanName 的 HandlerMapping
			HandlerMapping hm = (HandlerMapping)context.getBean("handlerMapping", HandlerMapping.class);
			//赋值给映射器处理器
			this.handlerMappings = Collections.singletonList(hm);
		} catch (NoSuchBeanDefinitionException var4) {
		}
	}

	if (this.handlerMappings == null) {
		//如果映射器处理器为空 再次从容器中获取默认的映射器处理器
		this.handlerMappings = this.getDefaultStrategies(context, HandlerMapping.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No HandlerMappings declared for servlet '" + this.getServletName() + "': using default strategies from DispatcherServlet.properties");
		}
	}
	//迭代处理映射器处理器
	Iterator var6 = this.handlerMappings.iterator();

	while(var6.hasNext()) {
		//获取映射器处理器 
		HandlerMapping mapping = (HandlerMapping)var6.next();
		//使用 路径匹配模式
		if (mapping.usesPathPatterns()) {
			//如果匹配到了 赋值为 true 并返回
			this.parseRequestPath = true;
			break;
		}
	}

}

//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategies
//获取默认的策略
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
	//默认策略为空
	if (defaultStrategies == null) {
		try {
			//去  DispatcherServlet.properties 中读取
			ClassPathResource resource = new ClassPathResource("DispatcherServlet.properties", DispatcherServlet.class);
			//加载 DispatcherServlet.properties 文件
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		} catch (IOException var15) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + var15.getMessage());
		}
	}
	
	//获取类名 就是 HandlerMapping 名称
	String key = strategyInterface.getName();
	//从 Spring MVC jar 包中 \org\springframework\web\servlet DispatcherServlet.properties 文件中读取到的 HandlerMapping
	String value = defaultStrategies.getProperty(key);
	//为空判断
	if (value == null) {
		return Collections.emptyList();
	} else {
		//使用 value 逗号分割 得到 HandlerMapping 因为 DispatcherServlet.properties 文件中有多个 HandlerMapping
		String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
		//HandlerMapping List
		List<T> strategies = new ArrayList(classNames.length);
		String[] var7 = classNames;
		int var8 = classNames.length;
		//遍历
		for(int var9 = 0; var9 < var8; ++var9) {
			String className = var7[var9];

			try {
				//通过全类名反射实例化 HandlerMapping
				Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
				Object strategy = this.createDefaultStrategy(context, clazz);
				strategies.add(strategy);
			} catch (ClassNotFoundException var13) {
				throw new BeanInitializationException("Could not find DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var13);
			} catch (LinkageError var14) {
				throw new BeanInitializationException("Unresolvable class definition for DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var14);
			}
		}
		//返回
		return strategies;
	}
}

以下文字摘录自 \org\springframework\web\servlet\DispatcherServlet.properties 文件，文件中给了三个默认的 HandlerMapping，分別是 BeanNameUrlHandlerMapping、RequestMappingHandlerMapping、RouterFunctionMapping。

# 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#initHandlerAdapters 方法源码分析

DispatcherServlet#initHandlerAdapters 方法会先从容器中获取 HandlerAdapter，如果没有获取到回去加载默认的 HandlerAdapter，并完成属性赋值。

//org.springframework.web.servlet.DispatcherServlet#initHandlerAdapters
//获取默认的策略 其实就是获取默认的 HandlerAdapter
private void initHandlerAdapters(ApplicationContext context) {
	this.handlerAdapters = null;
	//检测所有的映射器适配器  this.detectAllHandlerAdapters 默认值 true
	if (this.detectAllHandlerAdapters) {
		从容器中获取所有映射器适配器
		Map<String, HandlerAdapter> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerAdapter.class, true, false);
		if (!matchingBeans.isEmpty()) {
			//不为空 进行 映射器是配置复制 
			this.handlerAdapters = new ArrayList(matchingBeans.values());
			//排序
			AnnotationAwareOrderComparator.sort(this.handlerAdapters);
		}
	} else {
		try {
			//为空 获取 指定的 handlerAdapter
			HandlerAdapter ha = (HandlerAdapter)context.getBean("handlerAdapter", HandlerAdapter.class);
			//进行属性赋值
			this.handlerAdapters = Collections.singletonList(ha);
		} catch (NoSuchBeanDefinitionException var3) {
		}
	}

	//映射器适配器是否为空
	if (this.handlerAdapters == null) {
		//为空 获取默认的映射器是配置  和映射器处理器一个套路
		this.handlerAdapters = this.getDefaultStrategies(context, HandlerAdapter.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No HandlerAdapters declared for servlet '" + this.getServletName() + "': using default strategies from DispatcherServlet.properties");
		}
	}

}


//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategies
//获取默认的策略
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
	//默认策略为空
	if (defaultStrategies == null) {
		try {
			//去  DispatcherServlet.properties 中读取
			ClassPathResource resource = new ClassPathResource("DispatcherServlet.properties", DispatcherServlet.class);
			//加载 DispatcherServlet.properties 文件
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		} catch (IOException var15) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + var15.getMessage());
		}
	}
	
	//获取类名 就是 HandlerAdapter 名称
	String key = strategyInterface.getName();
	//从 Spring MVC jar 包中 \org\springframework\web\servlet DispatcherServlet.properties 文件中读取到的 HandlerAdapter
	String value = defaultStrategies.getProperty(key);
	//为空判断
	if (value == null) {
		return Collections.emptyList();
	} else {
		//使用 value 逗号分割 得到 HandlerAdapter 因为 DispatcherServlet.properties 文件中有多个 HandlerAdapter
		String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
		//HandlerAdapter List
		List<T> strategies = new ArrayList(classNames.length);
		String[] var7 = classNames;
		int var8 = classNames.length;
		//遍历
		for(int var9 = 0; var9 < var8; ++var9) {
			String className = var7[var9];

			try {
				//通过全类名反射实例化 HandlerAdapter
				Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
				Object strategy = this.createDefaultStrategy(context, clazz);
				strategies.add(strategy);
			} catch (ClassNotFoundException var13) {
				throw new BeanInitializationException("Could not find DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var13);
			} catch (LinkageError var14) {
				throw new BeanInitializationException("Unresolvable class definition for DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var14);
			}
		}
		//返回
		return strategies;
	}
}

以下文字摘录自 \org\springframework\web\servlet\DispatcherServlet.properties 文件，可以看到文件中也给了三个默认的 HandlerAdapter，分別是 SimpleControllerHandlerAdapter、RequestMappingHandlerAdapter、HandlerFunctionAdapter。

# 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#initHandlerExceptionResolvers方法源码分析

DispatcherServlet#initHandlerExceptionResolvers方法会先从容器中获取 HandlerExceptionResolver，如果没有获取到回去加载默认的 HandlerExceptionResolver，并完成属性赋值。

//org.springframework.web.servlet.DispatcherServlet#initHandlerExceptionResolvers
//初始化异常处理解析器
private void initHandlerExceptionResolvers(ApplicationContext context) {
	this.handlerExceptionResolvers = null;
	//检测所有的异常处理器解析器  this.handlerExceptionResolvers 默认值 true
	if (this.detectAllHandlerExceptionResolvers) {
		//从容器中获取所有映射器适配器
		Map<String, HandlerExceptionResolver> matchingBeans = BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerExceptionResolver.class, true, false);
		//为空判断
		if (!matchingBeans.isEmpty()) {
			//不为空 完成赋值
			this.handlerExceptionResolvers = new ArrayList(matchingBeans.values());
			//排序
			AnnotationAwareOrderComparator.sort(this.handlerExceptionResolvers);
		}
	} else {
		//为空
		try {
			//去容器中获取指定的 HandlerExceptionResolver
			HandlerExceptionResolver her = (HandlerExceptionResolver)context.getBean("handlerExceptionResolver", HandlerExceptionResolver.class);
			this.handlerExceptionResolvers = Collections.singletonList(her);
		} catch (NoSuchBeanDefinitionException var3) {
		}
	}
	//为空判断 
	if (this.handlerExceptionResolvers == null) {
		//为空 加载默认的 HandlerExceptionResolver 也是一样的套路
		this.handlerExceptionResolvers = this.getDefaultStrategies(context, HandlerExceptionResolver.class);
		if (this.logger.isTraceEnabled()) {
			this.logger.trace("No HandlerExceptionResolvers declared in servlet '" + this.getServletName() + "': using default strategies from DispatcherServlet.properties");
		}
	}

}



//org.springframework.web.servlet.DispatcherServlet#getDefaultStrategies
//获取默认的策略
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
	//默认策略为空
	if (defaultStrategies == null) {
		try {
			//去  DispatcherServlet.properties 中读取
			ClassPathResource resource = new ClassPathResource("DispatcherServlet.properties", DispatcherServlet.class);
			//加载 DispatcherServlet.properties 文件
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		} catch (IOException var15) {
			throw new IllegalStateException("Could not load 'DispatcherServlet.properties': " + var15.getMessage());
		}
	}
	
	//获取类名 就是 HandlerExceptionResolver 名称
	String key = strategyInterface.getName();
	//从 Spring MVC jar 包中 \org\springframework\web\servlet DispatcherServlet.properties 文件中读取到的 HandlerExceptionResolver
	String value = defaultStrategies.getProperty(key);
	//为空判断
	if (value == null) {
		return Collections.emptyList();
	} else {
		//使用 value 逗号分割 得到 HandlerExceptionResolver 因为 DispatcherServlet.properties 文件中有多个 HandlerExceptionResolver
		String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
		//HandlerExceptionResolver List
		List<T> strategies = new ArrayList(classNames.length);
		String[] var7 = classNames;
		int var8 = classNames.length;
		//遍历
		for(int var9 = 0; var9 < var8; ++var9) {
			String className = var7[var9];

			try {
				//通过全类名反射实例化 HandlerExceptionResolver
				Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
				Object strategy = this.createDefaultStrategy(context, clazz);
				strategies.add(strategy);
			} catch (ClassNotFoundException var13) {
				throw new BeanInitializationException("Could not find DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var13);
			} catch (LinkageError var14) {
				throw new BeanInitializationException("Unresolvable class definition for DispatcherServlet's default strategy class [" + className + "] for interface [" + key + "]", var14);
			}
		}
		//返回
		return strategies;
	}
}

以下文字摘录自 \org\springframework\web\servlet\DispatcherServlet.properties 文件，可以看到文件中也给了三个默认的 HandlerExceptionResolver，分別是 ExceptionHandlerExceptionResolver、ResponseStatusExceptionResolver、DefaultHandlerExceptionResolver。

# 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.properties 文件的默认配置，完成属性赋值，RequestToViewNameTranslator、ViewResolver、FlashMapManager 的初始化不在分析了，有兴趣的小伙伴可以自己研究，最后提醒一下伙伴们，Spring MVC 的初始化并不是在项目启动时候初始化的，而是在第一次调用接口的时候完成初始化的，有兴趣的小伙伴可以去 debug 验证一下，Spring MVC 的初始化源码就分析到这里，希望可以帮助到有需要的小伙伴。

欢迎提出建议及对错误的地方指出纠正。