1 /*
2 Bootstrap listener to start up and shut down Spring‘s root WebApplicationContext. Simply delegates to ContextLoader as well as to ContextCleanupListener.
3 
4 This listener should be registered after org.springframework.web.util.Log4jConfigListener in web.xml, if the latter is used.
5 
6 */ 
7 
8 public class ContextLoaderListener extends ContextLoader implements ServletContextListener

public void contextInitialized(ServletContextEvent event) {

                   this.contextLoader = createContextLoader();

                   if (this.contextLoader == null) {

                            this.contextLoader = this;

                   }

                   this.contextLoader.initWebApplicationContext(event.getServletContext());

         }

/**
 * Performs the actual initialization work for the root application context.
 * Called by {@link ContextLoaderListener}.
 *
 * <p>Looks for a {@link #CONTEXT_CLASS_PARAM "contextClass"} parameter
 * at the <code>web.xml</code> context-param level to specify the context
 * class type, falling back to the default of
 * {@link org.springframework.web.context.support.XmlWebApplicationContext}
 * if not found. With the default ContextLoader implementation, any context class
 * specified needs to implement the ConfigurableWebApplicationContext interface.
 *
 * <p>Processes a {@link #CONFIG_LOCATION_PARAM "contextConfigLocation"}
 * context-param and passes its value to the context instance, parsing it into
 * potentially multiple file paths which can be separated by any number of
 * commas and spaces, e.g. "WEB-INF/applicationContext1.xml,
 * WEB-INF/applicationContext2.xml". Ant-style path patterns are supported as well,
 * e.g. "WEB-INF/*Context.xml,WEB-INF/spring*.xml" or "WEB-INF/&#42;&#42;/*Context.xml".
 * If not explicitly specified, the context implementation is supposed to use a
 * default location (with XmlWebApplicationContext: "/WEB-INF/applicationContext.xml").
 *
 * <p>Note: In case of multiple config locations, later bean definitions will
 * override ones defined in previously loaded files, at least when using one of
 * Spring‘s default ApplicationContext implementations. This can be leveraged
 * to deliberately override certain bean definitions via an extra XML file.
 *
 * <p>Above and beyond loading the root application context, this class
 * can optionally load or obtain and hook up a shared parent context to
 * the root application context. See the
 * {@link #loadParentContext(ServletContext)} method for more information.
*/

<context-param>

    <param-name>contextConfigLocation</param-name>

<param-value>WEB-INF/applicationContext1.xml,WEB-INF/applicationContext2.xml</param-value>

</context-param>

public static final String CONTEXT_CLASS_PARAM = "contextClass";

public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";

public WebApplicationContext initWebApplicationContext(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 {

// 看看有没有父上下文，如果有就会将父上下问的信息合并到本上下文中

                            // Determine parent for root web application context, if any.

                            ApplicationContext parent = loadParentContext(servletContext);

 

                            // Store context in local instance variable, to guarantee that

                            // it is available on ServletContext shutdown.

这行代码就是包含Spring加载并初始化bean的调用：

                            this.context = createWebApplicationContext(servletContext, parent);

                            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;

                   }

         }

protected WebApplicationContext createWebApplicationContext(ServletContext sc, ApplicationContext parent) {

// 判断自定义的WebContextContext类是否实现了ConfigurableWebApplicationContext接口：

                   Class<?> contextClass = determineContextClass(sc);

                   if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {

                            throw new ApplicationContextException("Custom context class [" + contextClass.getName() +

                                               "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");

                   }

// 利用反射创建WebApplicationContext实现类对象

                   ConfigurableWebApplicationContext wac =

                                     (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

 

                   // Assign the best possible id value.

                   if (sc.getMajorVersion() == 2 && sc.getMinorVersion() < 5) {

                            // Servlet <= 2.4: resort to name specified in web.xml, if any.

                            String servletContextName = sc.getServletContextName();

                            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +

                                               ObjectUtils.getDisplayString(servletContextName));

                   }

                   else {

                            // Servlet 2.5‘s getContextPath available!

                            try {

//  通过反射调用getContextPath方法。

// 怎么老感觉Java中的反射调用方法与JavaScript中的YourFunction.call(caller,params)是那么的相像呢，不过他们的本质是不一样的。

                                     String contextPath = (String) ServletContext.class.getMethod("getContextPath").invoke(sc);

                                     wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +

                                                        ObjectUtils.getDisplayString(contextPath));

                            }

                            catch (Exception ex) {

                                     throw new IllegalStateException("Failed to invoke Servlet 2.5 getContextPath method", ex);

                            }

                   }

 

                   wac.setParent(parent);

                   wac.setServletContext(sc);

                   wac.setConfigLocation(sc.getInitParameter(CONFIG_LOCATION_PARAM));

// 自定义的ContextLoader可以重写这个方法，以添加一些赋值工作。

// 使用了Template方法模式

                   customizeContext(sc, wac);

// 这里是真正的初始化配置的bean的操作。

                   wac.refresh();

                   return wac;

         }

static {

                   // Load default strategy implementations from properties file.

                   // This is currently strictly internal and not meant to be customized

                   // by application developers.

                   try {

                            ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);

                            defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);

                   }

                   catch (IOException ex) {

                            throw new IllegalStateException("Could not load ‘ContextLoader.properties‘: " + ex.getMessage());

                   }

         }

org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext

public static WebApplicationContext getCurrentWebApplicationContext() {

      ClassLoader ccl = Thread.currentThread().getContextClassLoader();

      if (ccl != null) {

        WebApplicationContext ccpt = currentContextPerThread.get(ccl);

        if (ccpt != null) {

           return ccpt;

        }

      }

      return currentContext;

   }
 

/**
 * {@link org.springframework.web.context.WebApplicationContext} implementation
 * which takes its configuration from XML documents, understood by an
 * {@link org.springframework.beans.factory.xml.XmlBeanDefinitionReader}.
 * This is essentially the equivalent of
 * {@link org.springframework.context.support.AbstractXmlApplicationContext}
 * for a web environment.
 *
 * <p>By default, the configuration will be taken from "/WEB-INF/applicationContext.xml"
 * for the root context, and "/WEB-INF/test-servlet.xml" for a context with the namespace
 * "test-servlet" (like for a DispatcherServlet instance with the servlet-name "test").
 *
 * <p>The config location defaults can be overridden via the "contextConfigLocation"
 * context-param of {@link org.springframework.web.context.ContextLoader} and servlet
 * init-param of {@link org.springframework.web.servlet.FrameworkServlet}. Config locations
 * can either denote concrete files like "/WEB-INF/context.xml" or Ant-style patterns
 * like "/WEB-INF/*-context.xml" (see {@link org.springframework.util.PathMatcher}
 * javadoc for pattern details).
 *
 * <p>Note: In case of multiple config locations, later bean definitions will
 * override ones defined in earlier loaded files. This can be leveraged to
 * deliberately override certain bean definitions via an extra XML file.
 *
 * <p><b>For a WebApplicationContext that reads in a different bean definition format,
 * create an analogous subclass of {@link AbstractRefreshableWebApplicationContext}.</b>
 * Such a context implementation can be specified as "contextClass" context-param
 * for ContextLoader or "contextClass" init-param for FrameworkServlet.
 */

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;

        }

      }

   }