Spring WebApplicationContext 侵立删

转自：http://www.spring4all.com/article/1267

基于Spring4.0.5

ContextLoaderListener继承了ContextLoader同时实现了ServletContextListener接口,Spring通过ContextLoaderListener在ServletContext的两个生命周期函数contextInitialized()和contextDestroyed()对WebApplicationContext进行创建和销毁.

/**
 * Initialize the root web application context.
 */
@Override
public void contextInitialized(ServletContextEvent event) {
   initWebApplicationContext(event.getServletContext());
}


/**
 * Close the root web application context.
 */
@Override
public void contextDestroyed(ServletContextEvent event) {
   closeWebApplicationContext(event.getServletContext());
   ContextCleanupListener.cleanupAttributes(event.getServletContext());
}

initWebApplicationContext()是创建WebApplicationContext的核心函数.首先在ServletContext里通过WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE这个key尝试在ServletContext里获取WebApplicationContext,若成功获取则代表已经进行过初始化,所以会抛出一个IllegalStateException.

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!");
}

接下来是获得WebApplicationContext的实例并保存本地引用和放入ServletContext中.由于WebApplicationContext只是一个接口,实际上我们获取的是此接口的实现类的实例,而具体是获取什么实现类的逻辑则放在了createWebApplicationContext()中.先继续分析本方法的逻辑,在获得context实例后从第7行到第21行都是根据相关判断对context进行一些初始化工作.这里提一下,从第12行到17行的代码,对于单纯的Web应用来讲是不需要关心的,这个是针对EAR的设置,如果不是EJB开发,这段可以忽略掉,在loadParentContext()的注释里有说明这一点.然后重点在第18行的configureAndRefreshWebApplicationContext(),这里是对WebApplicationContext进行初始化的核心函数,我们稍后分析.这段逻辑结束后,把已经初始化结束的WebApplicationContext放入了servletContext中,key为WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE.

然后在第23行到第29行,这里是为了解决一个Spring类库的位置问题.在Tomcat中,假设你的Web应用都是使用了Spring,而且又都是同一个版本,那你可以把jar包放在Tomcat目录的lib文件夹里,Tomcat的Common ClassLoader在默认配置下会读取并加载此文件夹里的jar包,从而使所有的Web应用都能使用这些类库,详细的Tomcat加载类库的内容可以去搜索相关资料查阅,这里不再多提.回到原题,如果是这种情况,Spring的类是由Common ClassLoader加载的,但是具体的Web应用的类却是由Tomcat实例为每个Web应用创建的ClassLoader加载的.根据JVM ClassLoader的双亲委派模型,由Common ClassLoader载入的Spring类是无法获得由WebApp ClassLoader载入的相关应用类的.所以这里Spring使用了一个线程上下文ClassLoader,确保不管Spring类库放在Web应用下还是放在Tomcat的lib下,都能成功获取相关Web应用的业务类.在Web应用里,线程上下文ClassLoader在默认情况下就是Web应用的ClassLoader,自然能够获得Web应用下的各种类.然后到此WebApplicationContext的创建过程结束.

try {
   // Store context in local instance variable, to guarantee that
   // it is available on ServletContext shutdown.
   if (this.context == null) {
      this.context = createWebApplicationContext(servletContext);
   }
   if (this.context instanceof ConfigurableWebApplicationContext) {
      ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
      if (!cwac.isActive()) {
         // The context has not yet been refreshed -> provide services such as
         // setting the parent context, setting the application context id, etc
         if (cwac.getParent() == null) {
            // The context instance was injected without an explicit parent ->
            // determine parent for root web application context, if any.
            ApplicationContext parent = loadParentContext(servletContext);
            cwac.setParent(parent);
         }
         configureAndRefreshWebApplicationContext(cwac, 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;
}

接下来我们先分析createWebApplicationContext()函数,这里的逻辑很简答,通过determineContextClass()获得contextClass并且判断是否为ConfigurableWebApplicationContext的实现类,是则返回,否则抛出异常.而在determineContextClass()里,先判断开发者是否有设置contextClass参数,有的话根据参数使用自定义的上下文类,否则就使用默认的上下文类.目前Spring是通过在ContextLoader.properties里设置默认的上下文类,此文件包含在org.springframework.web.context包下,设置了XmlWebApplicationContext为默认的上下文类.而ContextLoader.properties的载入代码则是被写在ContextLoader的静态代码块中.

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

protected Class<?> determineContextClass(ServletContext servletContext) {
        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);
            }
        }
    }

接下来我们分析初始化WebApplicationContext的核心函数configureAndRefreshWebApplicationContext(),从第2行到第14行是对上下文的id作一个设置,比较简单.然后第16行到20行,设置应用上下文类的ServletContext并根据contextConfigLocation参数设置应用上下文的ConfigLocation,如果没设置的话,根据默认配置,XmlWebApplicationContext的ConfigLocation是/WEB-INF/applicationContext.xml,所以为什么大家默认都把Spring的配置文件这样命名并放在WEB-INF下就能解释了.在设置ConfigLocation的同时还设置好了Environment,例如Java自带的systemProperties和systemEnvironment.然后第24行到28行对Environment的PropertiesSources进行初始化,这里是设置了ServletContext进Environment的propertiesSourcesList里.然后customizeContext()里面主要是执行配置了的ApplicationContextInitializer的initialize(),对ApplicationContext进行一些自定义的操作,在Web应用下自然是WebApplicationContext.(这里提一下,单纯的SpringMVC貌似这里没有任何作用,如果开发者自己没有编写ApplicationContextInitializer的话,但是在SpringBoot的类库里则有用到这个特性.)

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
   if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
      // The application context id is still set to its original default value
      // -> assign a more useful id based on available information
      String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
      if (idParam != null) {
         wac.setId(idParam);
      }
      else {
         // Generate default id...
         wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
               ObjectUtils.getDisplayString(sc.getContextPath()));
      }
   }

   wac.setServletContext(sc);
   String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
   if (configLocationParam != null) {
      wac.setConfigLocation(configLocationParam);
   }

   // The wac environment's #initPropertySources will be called in any case when the context
   // is refreshed; do it eagerly here to ensure servlet property sources are in place for
   // use in any post-processing or initialization that occurs below prior to #refresh
   ConfigurableEnvironment env = wac.getEnvironment();
   if (env instanceof ConfigurableWebEnvironment) {
      ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
   }

   customizeContext(sc, wac);
   wac.refresh();
}

接下来重头戏来了,refresh()里面才是真正通过配置进行Spring IOC容器的初始化和加载代码,包括了BeanFactory的创建,BeanFactoryPostProcesser和BeanPostProcesser的注册和执行(这两个我的理解是一个hook,对BeanFactory和Bean的创建执行进行自定义操作),然后还有下面各种MessageSource,EventMuticaster,Listener的初始化,最后是单例Bean的初始化和refresh()的一些收尾工作,这里面初始化了LifecycleProcessor,这个Spring有提供一个默认的实现类,用于管理有生命周期的Bean,单例的则在前面已经被生成了并且不需要做声明周期的管理,所以这里如果开发者有需要还可以自定义LifecycleProcessor来管理Bean的声明周期.然后发布ContextRefreshedEvent,最后还有个LiveBeansView.registerApplicationContext(this)貌似是提供查看当前应用上下文里存活的Bean的.当前版本这个功能还处于beta状态,是设计给Spring Tool Suite 3.1及更高版本使用的.

public void refresh() throws BeansException, IllegalStateException {
   synchronized (this.startupShutdownMonitor) {
      // Prepare this context for refreshing.
      prepareRefresh();

      // Tell the subclass to refresh the internal bean factory.
      ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

      // Prepare the bean factory for use in this context.
      prepareBeanFactory(beanFactory);

      try {
         // Allows post-processing of the bean factory in context subclasses.
         postProcessBeanFactory(beanFactory);

         // Invoke factory processors registered as beans in the context.
         invokeBeanFactoryPostProcessors(beanFactory);

         // Register bean processors that intercept bean creation.
         registerBeanPostProcessors(beanFactory);

         // Initialize message source for this context.
         initMessageSource();

         // Initialize event multicaster for this context.
         initApplicationEventMulticaster();

         // Initialize other special beans in specific context subclasses.
         onRefresh();

         // Check for listener beans and register them.
         registerListeners();

         // Instantiate all remaining (non-lazy-init) singletons.
         finishBeanFactoryInitialization(beanFactory);

         // Last step: publish corresponding event.
         finishRefresh();
      }

      catch (BeansException ex) {
         // Destroy already created singletons to avoid dangling resources.
         destroyBeans();

         // Reset 'active' flag.
         cancelRefresh(ex);

         // Propagate exception to caller.
         throw ex;
      }
   }
}

到这里,WebApplicationContext的创建和初始化就结束了,至于销毁部分就不详细解释了,代码比较少(其实是我懒= =).源码阅读完后收获还是挺大的,了解了Spring IOC容器是怎么切入到Web应用中,并且有提供了哪些地方可以hook进行自定义操作的,还有Spring IOC容器的初始化流程等等.

阅读源码过程中查阅了不少网上的资料,包括各种个人博客以及官方文档,因为自己没有做记录也就没罗列出来.本文如有不妥之处,希望大家能提出宝贵的意见.