SPRing在web应用中的默认容器类为xmlWebapplicationContext，这个容器类通过xml文件获取所有的配置信息。它的继承结构如下图，（点此查看大图） 
在web应用中，不管是ContextLoaderListener，还是DispatcherServlet初始化的时候，都是以XmlWebApplicationContext为默认容器。在下面的研究中，我将以ContextLoaderListener的初始化过程介绍spring容器在web应用的初始化。
ContextLoaderListener的初始化过程中最主要的任务时加载spring容器，并把此容器加入到ServletContext中作为整个web应用的跟容器。ContextLoaderListener加载spring容器大致分为两个阶段，第一个阶段是解析web.xml文件中的初始化参数以对spring容器做定制化操作，简单的说就是定制spring容器；第二阶段是spring容器的刷新过程。下面分别对这两个阶段进行探讨。
ContextLoaderListener实现了ServletContextListener，因此web容器启动的时候就会执行它的contextInitialized方法，此方法的代码如下。
public void contextInitialized(ServletContextEvent event) { // 获取ContextLoader对象 this.contextLoader = createContextLoader(); if (this.contextLoader == null) { this.contextLoader = this; } this.contextLoader.initWebApplicationContext(event.getServletContext()); } @Override public void contextInitialized(ServletContextEvent event) { // 执行父类ContextLoader的initWebApplicationContext方法 initWebApplicationContext(event.getServletContext()); }这段代码主要是调用父类ContextLoader的initWebApplicationContext(ServletContext servletContext)方法，下面是initWebApplicationContext方法在ContextLoader类中的代码。
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) { // 检查ServletContext是否已经有了根容器 if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) { throw new IllegalStateException( "Cannot initialize context because there is already a root application context present - " + "check whether you have multiple ContextLoader* definitions in your web.xml!"); } Log logger = LogFactory.getLog(ContextLoader.class); servletContext.log("Initializing Spring root WebApplicationContext"); if (logger.isInfoEnabled()) { logger.info("Root WebApplicationContext: initialization started"); } long startTime = System.currentTimeMillis(); try { if (this.context == null) { // 创建容器，据contextClass初始化参数指定或者使用默认的XmlWebApplicationContext类 this.context = createWebApplicationContext(servletContext); } if (this.context instanceof ConfigurableWebApplicationContext) { ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context; if (!cwac.isActive()) { // 如果容器没有被刷新，执行以下操作 // 设置父容器 if (cwac.getParent() == null) { // 加载父容器。 // 通过locatorFactorySelector上下文初始化参数指定父容器所在的配置文件路径 // 通过parentContextKey上下文初始化参数指定父容器的名称 ApplicationContext parent = loadParentContext(servletContext); cwac.setParent(parent); } // 配置并执行容器刷新操作 configureAndRefreshWebApplicationContext(cwac, servletContext); } } // 把spring容器加入到ServletContext中作为根容器 servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context); ClassLoader ccl = Thread.currentThread().getContextClassLoader(); if (ccl == ContextLoader.class.getClassLoader()) { currentContext = this.context; } else if (ccl != null) { currentContextPerThread.put(ccl, this.context); } if (logger.isDebugEnabled()) { logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" + WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]"); } if (logger.isInfoEnabled()) { long elapsedTime = System.currentTimeMillis() - startTime; logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms"); } return this.context; } catch (RuntimeException ex) { logger.error("Context initialization failed", ex); servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex); throw ex; } catch (Error err) { logger.error("Context initialization failed", err); servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err); throw err; } }这段代码分成4步，首先通过调用ContextLoader的createWebApplicationContext(ServletContext sc)方法来创建spring容器，然后设置spring容器的父容器，接着调用ContextLoader的configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc)方法来配置并刷新spring容器，最后把容器保存到servlet容器中。最后一步的代码已经在上面体现了，下面我们来解析前三步的代码。
调用ContextLoader的createWebApplicationContext(ServletContext sc)方法，这个方法的代码如下。
protected WebApplicationContext createWebApplicationContext(ServletContext sc) { // 获取容器类对象 Class<?> contextClass = determineContextClass(sc); if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) { throw new ApplicationContextException("Custom context class [" + contextClass.getName() + "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]"); } // 使用容器类对象来实例化容器 return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass); }上面主要是通过ContextLoader的determineContextClass(ServletContext servletContext)方法获取容器类对象，然后实例化容器。下面是determineContextClass方法的代码。
/** * 获取容器类对象 **/ protected Class<?> determineContextClass(ServletContext servletContext) { // 声明：public static final String CONTEXT_CLASS_PARAM = "contextClass"; String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM); if (contextClassName != null) { try { return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader()); } catch (ClassNotFoundException ex) { throw new ApplicationContextException( "Failed to load custom context class [" + contextClassName + "]", ex); } } else { contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName()); try { return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader()); } catch (ClassNotFoundException ex) { throw new ApplicationContextException( "Failed to load default context class [" + contextClassName + "]", ex); } } }determineContextClass从ServletContext对象中获取contextClass初始化参数的值，如果这个参数有值，则使用这个参数指定的容器类，否则使用默认的容器类XmlWebApplicationContext。如果不使用spring的默认容器，可以在web.xml中通过配置contextClass指定其他容器类，比如。
<!-- 定义contextClass参数 --> <context-param> <param-name>contextClass</param-name> <param-value> com.chyohn.context.XmlWebApplicationContext </param-value> </context-param>创建完spring容器后，initWebApplicationContext中会调用ContextLoader的 loadParentContext(ServletContext servletContext)方法来获取父容器，并把这个父容器与刚创建的容器关联上。loadParentContext方法的代码如下。
protected ApplicationContext loadParentContext(ServletContext servletContext) { ApplicationContext parentContext = null; // 声明：public static final String LOCATOR_FACTORY_SELECTOR_PARAM = "locatorFactorySelector"; String locatorFactorySelector = servletContext.getInitParameter(LOCATOR_FACTORY_SELECTOR_PARAM); // 声明：public static final String LOCATOR_FACTORY_KEY_PARAM = "parentContextKey"; String parentContextKey = servletContext.getInitParameter(LOCATOR_FACTORY_KEY_PARAM); if (parentContextKey != null) { // locatorFactorySelector可能会为null, 则会使用默认的 "classpath*:beanRefContext.xml" BeanFactoryLocator locator = ContextSingletonBeanFactoryLocator.getInstance(locatorFactorySelector); Log logger = LogFactory.getLog(ContextLoader.class); if (logger.isDebugEnabled()) { logger.debug("Getting parent context definition: using parent context key of '" + parentContextKey + "' with BeanFactoryLocator"); } this.parentContextRef = locator.useBeanFactory(parentContextKey); parentContext = (ApplicationContext) this.parentContextRef.getFactory(); } return parentContext; }这里通过ServletContext 获取初始化参数locatorFactorySelector指定的定义父容器的xml文件的地址，同时获取初始化参数parentContextKey指定的父容器在前面xml文件中设置的bean名称。下面是一个列子。
第一步在classes路径下创建名为parentBeanRefContext.xml的xml文件(名称可以随便取)，我这里的内容如下。
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <!-- 指定容器 --> <bean id="parentContext" class="org.springframework.context.support.ClassPathXmlApplicationContext"> <constructor-arg> <list> <value>parentOfRootContext.xml</value> </list> </constructor-arg> </bean></beans>其中parentOfRootContext.xml文件为一个普通的spring配置文件，这里就不举例了。
第二步，在web.xml文件中做如下配置。
<!-- 定义locatorFactorySelector参数 --> <context-param> <param-name>locatorFactorySelector</param-name> <param-value> classpath:parentBeanRefContext.xml </param-value> </context-param> <!-- 定义parentContextKey参数 --> <context-param> <param-name>parentContextKey</param-name> <param-value>parentContext</param-value> </context-param>这样就向容器中指定了一个父容器。在这里如果在第一步中创建的xml文件的名称为beanRefContext.xml，那么在web.xml文件中就不用配置locatorFactorySelector参数。
设置了父容器后，执行ContextLoader的configureAndRefreshWebApplicationContext方法，在容器刷新前对容器进行初始化配置，代码如下
protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) { if (ObjectUtils.identityToString(wac).equals(wac.getId())) { // 为容器设置一个有用的ID // 声明：public static final String CONTEXT_ID_PARAM = "contextId"; String idParam = sc.getInitParameter(CONTEXT_ID_PARAM); if (idParam != null) { wac.setId(idParam); } else { // 生成一个默认ID if (sc.getMajorVersion() == 2 && sc.getMinorVersion() < 5) { // servlet 2.5以前的版本 wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getServletContextName())); } else { // servlet 2.5及其以上的版本wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getContextPath())); } } } // 把ServletContext保存到容器中 wac.setServletContext(sc); // 设置容器要加载的配置文件所在的路径 // 通过contextConfigLocation上下文参数指定配置文件路径 // 声明：public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation"; String initParameter = sc.getInitParameter(CONFIG_LOCATION_PARAM); if (initParameter != null) { wac.setConfigLocation(initParameter); } // 在容器刷新前，自定义容器。 // 执行用户通过contextInitializerClasses上下文参数指定的容器初始化器 customizeContext(sc, wac); // 刷新容器 wac.refresh(); } protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) { if (ObjectUtils.identityToString(wac).equals(wac.getId())) { // 为容器设置一个有用的ID // 声明：public static final String CONTEXT_ID_PARAM = "contextId"; String idParam = sc.getInitParameter(CONTEXT_ID_PARAM); if (idParam != null) { wac.setId(idParam); } else { // 创建一个默认的id wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX + ObjectUtils.getDisplayString(sc.getContextPath())); } } // 把ServletContext保存到容器中 wac.setServletContext(sc); // 设置容器要加载的配置文件所在的路径 // 通过contextConfigLocation上下文参数指定配置文件路径 // 声明：public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation"; String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM); if (configLocationParam != null) { wac.setConfigLocation(configLocationParam); } // 提前执行容器环境对象的initPropertySources方法，以确保servlet属性资源可应用于容器刷新前的任何初始化操作。 ConfigurableEnvironment env = wac.getEnvironment(); if (env instanceof ConfigurableWebEnvironment) { ((ConfigurableWebEnvironment) env).initPropertySources(sc, null); } // 在容器刷新前，自定义容器。 // 执行用户通过contextInitializerClasses上下文参数指定的容器初始化器 customizeContext(sc, wac); // 刷新容器 wac.refresh(); }这段代码处理配置在web.xml中的2个初始化参数，第一个是用于标志容器id的contextId初始化参数，第二是用于指定配置文件地址的contextConfigLocation初始化参数。对于contextId参数没有过多的探讨，至于contextConfigLocation参数，可以配置，也可以不配置。如果需要通过contextConfigLocation参数指定多个配置文件，配置文件地址之间可以通过英文逗号、分号、空格、制表符、换行符隔开。如果没有配置contextConfigLocation参数，XmlWebApplicationContext将使用WEB-INF目录下的默认配置文件地址，代码如下。
/** Default config location for the root context */ public static final String DEFAULT_CONFIG_LOCATION = "/WEB-INF/applicationContext.xml"; /** Default prefix for building a config location for a namespace */ public static final String DEFAULT_CONFIG_LOCATION_PREFIX = "/WEB-INF/"; /** Default suffix for building a config location for a namespace */ public static final String DEFAULT_CONFIG_LOCATION_SUFFIX = ".xml"; @Override protected String[] getDefaultConfigLocations() { if (getNamespace() != null) { return new String[] {DEFAULT_CONFIG_LOCATION_PREFIX + getNamespace() + DEFAULT_CONFIG_LOCATION_SUFFIX}; } else { // 返回配置地址/WEB-INF/applicationContext.xml return new String[] {DEFAULT_CONFIG_LOCATION}; } }根据这段代码，可以获得两个信息。 其一：如果spring容器有命名空间，则开发者可以在WEB-INF目录下创建以命名空间为名称的xml配置文件。 其二：如果spring容器没有命名空间，则开发者可以在WEB-INF目录下创建以applicationContext为名称的xml配置文件。
在configureAndRefreshWebApplicationContext方法中还调用ContextLoader的customizeContext方法来执行用户指定ApplicationContextInitializer对象，下面是customizeContext方法的代码。
protected void customizeContext(ServletContext servletContext, ConfigurableWebApplicationContext applicationContext) { // 获取ApplicationContextInitializer类对象列表 List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses = determineContextInitializerClasses(servletContext); if (initializerClasses.size() == 0) { // 没有指定任何 ApplicationContextInitializers对象，则什么都不做，直接返回 return; } Class<?> contextClass = applicationContext.getClass(); ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerInstances = new ArrayList<ApplicationContextInitializer<ConfigurableApplicationContext>>(); for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) { // 从initializerClass对象获取ApplicationContextInitializer的泛型类对象 Class<?> initializerContextClass = GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class); // 检查contextClass是否是initializerContextClass类对象指定的类的实现 Assert.isAssignable(initializerContextClass, contextClass, String.format( "Could not add context initializer [%s] as its generic parameter [%s] " + "is not assignable from the type of application context used by this " + "context loader [%s]: ", initializerClass.getName(), initializerContextClass.getName(), contextClass.getName())); initializerInstances.add(BeanUtils.instantiateClass(initializerClass)); } ConfigurableEnvironment env = applicationContext.getEnvironment(); if (env instanceof ConfigurableWebEnvironment) { // 初始化Property资源 ((ConfigurableWebEnvironment)env).initPropertySources(servletContext, null); } // 一个一个的执行ApplicationContextInitializer对象 Collections.sort(initializerInstances, new AnnotationAwareOrderComparator()); for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : initializerInstances) { initializer.initialize(applicationContext); } }这段代码主要是调用ContextLoader对象的determineContextInitializerClasses方法来获取ApplicationContextInitializer类对象列表，并使用每个ApplicationContextInitializer对象来对spring容器做更多的初始化操作。下面是determineContextInitializerClasses的代码。
protected List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> determineContextInitializerClasses(ServletContext servletContext) { List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> classes = new ArrayList<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>(); // 从ServletContext中获取应用于所有spring web应用容器的ApplicationContextInitializer实现类全名称 // 声明有：public static final String GLOBAL_INITIALIZER_CLASSES_PARAM = "globalInitializerClasses"; String globalClassNames = servletContext.getInitParameter(GLOBAL_INITIALIZER_CLASSES_PARAM); if (globalClassNames != null) { for (String className : StringUtils.tokenizeToStringArray(globalClassNames, INIT_PARAM_DELIMITERS)) { classes.add(loadInitializerClass(className)); } } // 从ServletContext中获取专为为此容器指定的ApplicationContextInitializer实现类全名称 // 声明：public static final String CONTEXT_INITIALIZER_CLASSES_PARAM = "contextInitializerClasses"; String localClassNames = servletContext.getInitParameter(CONTEXT_INITIALIZER_CLASSES_PARAM); if (localClassNames != null) { for (String className : StringUtils.tokenizeToStringArray(localClassNames, INIT_PARAM_DELIMITERS)) { classes.add(loadInitializerClass(className)); } } return classes; } private Class<ApplicationContextInitializer<ConfigurableApplicationContext>> loadInitializerClass(String className) { try { Class<?> clazz = ClassUtils.forName(className, ClassUtils.getDefaultClassLoader()); Assert.isAssignable(ApplicationContextInitializer.class, clazz); return (Class<ApplicationContextInitializer<ConfigurableApplicationContext>>) clazz; } catch (ClassNotFoundException ex) { throw new ApplicationContextException("Failed to load context initializer class [" + className + "]", ex); } }determineContextInitializerClasses方法从ServletContext中获取初始化参数contextInitializerClasses和globalInitializerClasses的值，这个值指定了用户自定义的ApplicationContextInitializer实现类全名称。然后根据类的全名称创建Class对象。其中如果需要指定多个ApplicationContextInitializer实现类，那么实现类的全名称之间使用英文逗号隔开，比如下面的配置。
<!-- 定义globalInitializerClasses参数 --> <context-param> <param-name>globalInitializerClasses</param-name> <param-value> com.damuzee.web.app.GlobalApplicationContextInitializer1, com.damuzee.web.app.GlobalApplicationContextInitializer2, com.damuzee.web.app.GlobalApplicationContextInitializer3 </param-value> </context-param> <!-- 定义contextInitializerClasses参数 --> <context-param> <param-name>contextInitializerClasses</param-name> <param-value> com.damuzee.web.app.XmlApplicationContextInitializer1, com.damuzee.web.app.XmlApplicationContextInitializer2, com.damuzee.web.app.XmlApplicationContextInitializer3 </param-value> </context-param>到此，在web应用中spring容器初始化的第一个阶段就完成了。configureAndRefreshWebApplicationContext方法通过调用容器的refresh()方法进入容器初始化的第二阶段——容器的刷新过程
关于spring容器的刷新过程已经在另一篇文章中描述了，详见 Spring ApplicationContext的刷新过程
在spring容器初始化的第一个阶段，我们可以通过web.xml文件的配置来定制spring容器。通过web.xml文件，我们可以指定其他容器类、父容器、容器的id、需要加载的配置文件地址、以及自定义容器初始化器ApplicationContextInitializer对象。具体例子如下。
通过设置contextClass参数指定容器，例如 <context-param> <param-name>contextClass</param-name> <param-value> com.chyohn.context.XmlWebApplicationContext </param-value> </context-param>设置locatorFactorySelector和parentContextKey参数指定父容器，例如 <!-- 定义locatorFactorySelector参数 --> <context-param> <param-name>locatorFactorySelector</param-name> <param-value> classpath:parentBeanRefContext.xml </param-value> </context-param> <!-- 定义parentContextKey参数 --> <context-param> <param-name>parentContextKey</param-name> <param-value>parentContext</param-value> </context-param>上面的parentBeanRefContext.xml配置如下
<?xml version="1.0" encoding="UTF-8"?><beans xmlns="http://www.springframework.org/schema/beans" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.1.xsd"> <!-- 指定容器 --> <bean id="parentContext" class="org.springframework.context.support.ClassPathXmlApplicationContext"> <constructor-arg> <list> <value>parentOfRootContext.xml</value> </list> </constructor-arg> </bean></beans> 设置contextId参数指定容器的Id，配置如下。 <context-param> <param-name>contextId</param-name> <param-value>myContextId</param-value> </context-param>设置contextConfigLocation参数指定加载的配置文件地址，配置如下。 <context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath:webApplicationContent.xml classpath:application-service.xml </param-value> </context-param>设置contextInitializerClasses参数指定容器初始化器，该初始化器将在容器刷新前执行，如果有多个初始化器，使用英文逗号“,”隔开，例如 <!-- 定义contextInitializerClasses参数 --> <context-param> <param-name>contextInitializerClasses</param-name> <param-value> com.damuzee.web.app.XmlApplicationContextInitializer1, com.damuzee.web.app.XmlApplicationContextInitializer2, com.damuzee.web.app.XmlApplicationContextInitializer3 </param-value> </context-param>设置globalInitializerClasses参数指定所有容器公共的初始化器，该初始化器将在容器刷新前执行，如果有多个初始化器，使用英文逗号“,”隔开，例如 <!-- 定义globalInitializerClasses参数 --> <context-param> <param-name>globalInitializerClasses</param-name> <param-value> com.damuzee.web.app.GlobalApplicationContextInitializer1, com.damuzee.web.app.GlobalApplicationContextInitializer2, com.damuzee.web.app.GlobalApplicationContextInitializer3 </param-value> </context-param>有了ApplicationContextInitializer对象，可以对容器的初始化做更多操作，比如设置容器id、设置父容器、设置加载的配置文件地址、添加容器级的bean工厂后处理器、监听器等等。
新闻热点
疑难解答
