SpringMVC之DispatchServlet初始化过程
SpringMvc最核心的类就是前端控制器DispatchServlet，作为一个Servlet，是整个SpringMvc的入口，用于调度其他的各组件工作，如Controller、HandlerMapping、ViewResolver等，控制着整个处理用户请求的流程，本篇首先来总结一下DispatchServlet的初始化过程，及进行具体处理请求前的预准备
作为一个Servlet的主要继承关系：HttpServletBean -- > FrameworkServlet -- > DispatchServlet，分别分析这三个类，各自所做的工作，就基本上总结了整个DispatchServlet的初始过程
1、HttpServletBean
重写了GenericServlet的init方法,servelt实例化时init方法会被调用：
@Override
public final void init() throws ServletException {
if (logger.isDebugEnabled()) {
logger.debug("Initializing servlet '" + getServletName() + "'");
}
//将Servlet的初始化参数（initParam）保存在PropertyValues，并检查Servlet的初始化参数包含了所必须的参数，子类可以将在this.requiredProperties指定必须的参数
PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);
if (!pvs.isEmpty()) {
try {
//BeanWrapper就是对象的包裹者,主要用于对象的属性设置，这里的this，就是DispatchServlet
BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
//ServletContext的资源加载器，使用本质上是使用ServletContext对象来获取与当前Servlet相关的资源
ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
//自定义了属性编辑器，用于编辑被包裹对象的属性
bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
//空方法留给子类自定义初始化BeanWrapper
initBeanWrapper(bw);
//将Servlet的初始化参数设置到BeanWrapper中
bw.setPropertyValues(pvs, true);
}
catch (BeansException ex) {
if (logger.isErrorEnabled()) {
logger.error("Failed to set bean properties on servlet '" + getServletName() + "'", ex);
}
throw ex;
}
}
//在FrameworkServlet中实现
initServletBean();
if (logger.isDebugEnabled()) {
logger.debug("Servlet '" + getServletName() + "' configured successfully");
}
}
总结：主要使用ServletConfig配置信息初始化DispatchServlet的一些属性，如使用web.xml时配置的contextConfigLocation
2、FrameworkServlet
1)重写initServletBean（）初始化IOC容器
调用链：HttpServletBean.init()-->FrameworkServlet.initServletBean（）
@Override
protected final void initServletBean() throws ServletException {
getServletContext().log("Initializing Spring FrameworkServlet '" + getServletName() + "'");
if (this.logger.isInfoEnabled()) {
this.logger.info("FrameworkServlet '" + getServletName() + "': initialization started");
}
long startTime = System.currentTimeMillis();
try {
//初始化ioc容器（设置父子容器并刷新）
this.webApplicationContext = initWebApplicationContext();
//空方法，留给子类扩展
initFrameworkServlet();
}
...
}
核心方法initWebApplicationContext（）：
protected WebApplicationContext initWebApplicationContext() {
//根据ServletContext.getAttribute来获取到WebApplicationContext（根容器），而获取到的根容器是之前由ContextLoaderListener（ServletContextListener）的contextInitialized方法将根容器保存在了ServletContext
WebApplicationContext rootContext =
WebApplicationContextUtils.getWebApplicationContext(getServletContext());
WebApplicationContext wac = null;
//this.webApplicationContext为子容器（保存SpringMVC组件），如果我们使用的是配置类的方式即继承AbstractAnnotationConfigDispatcherServletInitializer来指定创建父子容器，那么在Servlet容器启动的时侯webApplicationContext就被创建了
if (this.webApplicationContext != null) {
wac = this.webApplicationContext;
if (wac instanceof ConfigurableWebApplicationContext) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
if (!cwac.isActive()) {
if (cwac.getParent() == null) {
//将根容器设置为子容器（保存SpringMVC组件）的父容器
cwac.setParent(rootContext);
}
//配置并且刷新容器（启动初始化容器过程）,之前的父子容器只是被创建没有调用refresh
configureAndRefreshWebApplicationContext(cwac);
}
}
}
if (wac == null) {
//如果子容器还没又被创建，尝试去ServletContext中以获取
wac = findWebApplicationContext();
}
if (wac == null) {
//如果子容器还为空，就通过web.xml配置的参数contextConfigLocation指定的Xml配置文件路径来创建一个XmlWebApplicationContext类型的ioc子容器，设置父子容器关系，并刷新。
wac = createWebApplicationContext(rootContext);
}
if (!this.refreshEventReceived) {
//在DispatchServlet中实现
onRefresh(wac);
}
//this.publishContext指定是否将web容器发布在ServletContext中，默认为ture
if (this.publishContext) {
String attrName = getServletContextAttributeName();
//将初始化好的ioc容器放入ServletContext中
getServletContext().setAttribute(attrName, wac);
if (this.logger.isDebugEnabled()) {
this.logger.debug("Published WebApplicationContext of servlet '" + getServletName() +
"' as ServletContext attribute with name [" + attrName + "]");
}
}
return wac;
}
FrameworkServlet的initServletBean方法主要就是初始化IOC容器，包括一个子容器（保存springmvc组件，如Controller、ViewResolver、HandlerMapping等等）和一个父容器（保存业务逻辑组件，如service,dao）,
2）重写了HttpServelt的service方法
@Override
protected void service(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
HttpMethod httpMethod = HttpMethod.resolve(request.getMethod());
if (HttpMethod.PATCH == httpMethod || httpMethod == null) {
//处理PATCH请求
processRequest(request, response);
}
else {
//如果不是PATCH请求，调用HttpServelt.service()
super.service(request, response);
}
}
FrameworkServlet也重写了doGet、doPost、xxx等对应处理各类型请求的方法，最终都是调用了processRequest(request, response)来处理：
protected final void processRequest(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
long startTime = System.currentTimeMillis();
Throwable failureCause = null;
//获取之前LocaleContext（主要作用是封装请求的 Locale 信息，主要就是语言信息）默认不存在
LocaleContext previousLocaleContext = LocaleContextHolder.getLocaleContext();
//创建本次请求的localeContext
LocaleContext localeContext = buildLocaleContext(request);
//获取之前RequestAttributes（封装request，response）默认不存在
RequestAttributes previousAttributes = RequestContextHolder.getRequestAttributes();
//创建本次请求的requestAttributes
ServletRequestAttributes requestAttributes = buildRequestAttributes(request, response, previousAttributes);
//与异步请求相关的处理
WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
asyncManager.registerCallableInterceptor(FrameworkServlet.class.getName(), new RequestBindingInterceptor());
//将localeContext、requestAttributes分别保存在LocaleContextHolder、RequestContextHolder中，两者都是使用ThreadLocal与当前线程绑定
initContextHolders(request, localeContext, requestAttributes);
try {
//真正的处理请求过程在DispatchServlet中实现
doService(request, response);
}
catch (ServletException ex) {
failureCause = ex;
throw ex;
}
catch (IOException ex) {
failureCause = ex;
throw ex;
}
catch (Throwable ex) {
failureCause = ex;
throw new NestedServletException("Request processing failed", ex);
}
finally {
//完成请求默认移除requestAttributes和localeContext
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);
}
}
总结：1、在Servlet初始化阶段，初始化了IOC容器
2、在处理请求阶段，做了一些提前的准备工作
3、DispatcherServlet
1）重写onRefresh,初始化SpringMvc工作组件
HttpServletBean.init()-->FrameworkServlet.initServletBean（）-->FrameworkServlet.initWebApplicationContext()-->DispatcherServlet.onRefresh(ApplicationContext context)
@Override
protected void onRefresh(ApplicationContext context) {
//context就是在FrameworkServlet.initWebApplicationContext()中完成初始化工作的IOC容器
initStrategies(context);
}
//完成各组件的初始化
protected void initStrategies(ApplicationContext context) {
//初始化文件上传的处理类
initMultipartResolver(context);
initLocaleResolver(context);
initThemeResolver(context);
initHandlerMappings(context);
initHandlerAdapters(context);
initHandlerExceptionResolvers(context);
initRequestToViewNameTranslator(context);
initViewResolvers(context);
initFlashMapManager(context);
}
这里我们以处理器映射器的初始化initHandlerMappings(context)为例分析，其他组件的初始化处理也类似
private void initHandlerMappings(ApplicationContext context) {
this.handlerMappings = null;
//this.detectAllHandlerMappings默认为true
if (this.detectAllHandlerMappings) {
//在容器中找到所有的HandlerMapping
Map<String, HandlerMapping> matchingBeans =
BeanFactoryUtils.beansOfTypeIncludingAncestors(context, HandlerMapping.class, true, false);
if (!matchingBeans.isEmpty()) {
//将所有的HandlerMapping保存在handlerMappings中
this.handlerMappings = new ArrayList<HandlerMapping>(matchingBeans.values());
// 排序
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.
}
}
//如果在IOC容器中没有找到任何的HandlerMapping，获取默认的HandlerMapping
if (this.handlerMappings == null) {
this.handlerMappings = getDefaultStrategies(context, HandlerMapping.class);
if (logger.isDebugEnabled()) {
logger.debug("No HandlerMappings found in servlet '" + getServletName() + "': using default");
}
}
}
getDefaultStrategies(context, HandlerMapping.class)获取默认的组件：
protected <T> List<T> getDefaultStrategies(ApplicationContext context, Class<T> strategyInterface) {
//这的key为org.springframework.web.servlet.HandlerMapping
String key = strategyInterface.getName();
//在defaultStrategies获取我们需要创建的组件的类型，多个的话，使用逗号隔开
String value = defaultStrategies.getProperty(key);
if (value != null) {
//使用逗号为分隔符，转化成数组
String[] classNames = StringUtils.commaDelimitedListToStringArray(value);
List<T> strategies = new ArrayList<T>(classNames.length);
//遍历classNames利用反射创建对象
for (String className : classNames) {
try {
Class<?> clazz = ClassUtils.forName(className, DispatcherServlet.class.getClassLoader());
//创建并添加到IOC容器中
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(
"Error loading DispatcherServlet's default strategy class [" + className +
"] for interface [" + key + "]: problem with class file or dependent class", err);
}
}
return strategies;
}
else {
return new LinkedList<T>();
}
}
//保存了各组件接口对应的默认实现类
private static final Properties defaultStrategies;
//静态代码块，用于初始化defaultStrategies
static {
try {
//private static final String DEFAULT_STRATEGIES_PATH = "DispatcherServlet.properties"，创建了一个与DispatcherServlet.class处于同一包下的DispatcherServlet.properties文件的资源对象
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, DispatcherServlet.class);
//创建Properties对象，保存了组件接口的对应的默认实现类
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load '" + DEFAULT_STRATEGIES_PATH + "': " + ex.getMessage());
}
}
DispatcherServlet.properties配置文件中指定了各组件的默认实现类的全类名：
# 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.annotation.DefaultAnnotationHandlerMapping
org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerAdapter
org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.annotation.AnnotationMethodHandlerExceptionResolver,\
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
各个SpringMvc工作组件的初始化过程为：首先从IOC容器中找对应接口类型的组件，如果没到，就创建一个在DispatcherServlet.properties中指定的默认组件接口实现类的实例
2）重写doService,进入核心方法doDispatch(request, response)
@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) + "]");
}
//这里与RequestDispatcher.include()相关
Map<String, Object> attributesSnapshot = null;
if (WebUtils.isIncludeRequest(request)) {
attributesSnapshot = new HashMap<String, Object>();
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));
}
}
}
//将一些组件设置到request中
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()) {
// Restore the original attribute snapshot, in case of an include.
if (attributesSnapshot != null) {
restoreAttributesAfterInclude(request, attributesSnapshot);
}
}
}
}
最终进入doDispatch(request, response)，作为DispatchServlet最核心方法，调度着各工作组件进行具体的请求处理。
