public void contextInitialized(ServletContextEvent event) {  
    //这个方法实现的本意是提供一个占位符方法createContextLoader（）给子类机会创建客户化的环境加载，但是，后来这个证明不是非常有用的，已经鼓励不再使用了，事实上，子类可以通过重写本方法达到同样的目的  
    this.contextLoader = createContextLoader();  
      
    //没有子类实现createContextLoader（）占位符 方法，则使用超类的缺省实现，超类 就是环境 加载类  
    if (this.contextLoader == null) {  
        //实际上是为了使用超类的默认实现  
        this.contextLoader = this;  
    }  
      
    //调用超类的加载根共享Web应用程序环境的默认实现  
    this.contextLoader.initWebApplicationContext(event.getServletContext());  
}  
  
public void contextDestroyed(ServletContextEvent event) {  
    //如果环境加载存在，那么关闭环境加载的Web应用程序环境  
    if (this.contextLoader != null) {  
        this.contextLoader.closeWebApplicationContext(event.getServletContext());  
    }  
      
    //清除保存在Servlet环境中的任何可释放的Bean  
    ContextCleanupListener.cleanupAttributes(event.getServletContext());  
}  
  
public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {  
    //如果已经存在了根共享Web应用程序环境，则抛出异常提示客户  
    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");  
    }  
      
    //记录创建根Web应用程序环境的开始时间  
    long startTime = System.currentTimeMillis();  
  
    try {  
        //决定根Web应用程序环境是否存在父应用程序环境  
        ApplicationContext parent = loadParentContext(servletContext);  
  
        //创建根Web应用程序环境，如果父环境存在则引用父环境，通常情况下父环境是不存在的  
        this.context = createWebApplicationContext(servletContext, parent);  
  
        //把创建的根Web应用程序环境保存到Servlet环境中，每个派遣器Servlet加载的子环境会应用这个环境作为父环境  
        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) {  
            //如果线程和本类拥有不同的类加载器，则使用线程的类加载器作为关键在保存在一个映射对象里，保证析构时能拿到Web应用程序环境进行关闭操作  
            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);  
        //如果产生任何异常，则保存异常对象到Servlet环境里  
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);  
        throw ex;  
    }  
    catch (Error err) {  
        logger.error("Context initialization failed", err);  
        //如果产生任何错误，则保存错误对象到Servlet环境里  
        servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);  
        throw err;  
    }  
}  
  
protected WebApplicationContext createWebApplicationContext(ServletContext sc, ApplicationContext parent) {  
    //取得配置的Web应用程序环境类，如果没有配置，则使用缺省的类XmlWebApplicationContext  
    Class<?> contextClass = determineContextClass(sc);  
      
    //如果配置的Web应用程序环境类不是可配置的Web应用程序环境的子类，则抛出异常，停止初始化  
    if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {  
        throw new ApplicationContextException("Custom context class [" + contextClass.getName() +  
                "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");  
    }  
      
    //否则实例化Web应用程序环境类  
    ConfigurableWebApplicationContext wac =  
            (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);  
  
    //设置Web应用程序环境的ID  
    if (sc.getMajorVersion() == 2 && sc.getMinorVersion() < 5) {  
        // 如果 Servlet规范 <= 2.4，则使用web.xml里定义的应用程序名字定义Web应用程序名  
        String servletContextName = sc.getServletContextName();  
          
        //设置ID  
        wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +  
                ObjectUtils.getDisplayString(servletContextName));  
    }  
    else {  
        // 如果Servlet规范是 2.5， 则使用配置的ContextPath定义Web应用程序名  
        try {  
            String contextPath = (String) ServletContext.class.getMethod("getContextPath").invoke(sc);  
              
            //设置ID  
            wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +  
                    ObjectUtils.getDisplayString(contextPath));  
        }  
        catch (Exception ex) {  
            //如果Servlet规范是2.5,但是不能取得ContextPath，抛出异常  
            throw new IllegalStateException("Failed to invoke Servlet 2.5 getContextPath method", ex);  
        }  
    }  
  
    //如果父环境存在，则引用使用父环境  
    wac.setParent(parent);  
      
    //保存Servlet环境  
    wac.setServletContext(sc);  
      
    //设置环境的位置  
    wac.setConfigLocation(sc.getInitParameter(CONFIG_LOCATION_PARAM));  
      
    //提供子类可互换Web应用程序环境的机会  
    customizeContext(sc, wac);  
      
    //刷新Web应用程序环境以加载Bean定义  
    wac.refresh();  
    return wac;  
}  
  
protected Class<?> determineContextClass(ServletContext servletContext) {  
    //首先检查是否初始化参数中定义了Web应用程序环境的类名  
    String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);  
    if (contextClassName != null) {  
        try {  
            //如果初始化参数中定义了Web应用程序环境的类名，加载定义的类名  
            return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());  
        }  
        catch (ClassNotFoundException ex) {  
            throw new ApplicationContextException(  
                    "Failed to load custom context class [" + contextClassName + "]", ex);  
        }  
    }  
    else {  
        //如果初始化参数中定义了Web应用程序环境的类名，加载缺省策略中定义的类名，缺省策略保存在ContextLoader.properties文件里  
        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);  
        }  
    }  
}  
  
public void closeWebApplicationContext(ServletContext servletContext) {  
    servletContext.log("Closing Spring root WebApplicationContext");  
    try {  
        //如果是可配置的Web应用程序环境  
        if (this.context instanceof ConfigurableWebApplicationContext) {  
            //关闭可配置的Web应用程序环境  
            ((ConfigurableWebApplicationContext) this.context).close();  
        }  
    }  
    finally {  
        //取得当前线程的类加载器  
        ClassLoader ccl = Thread.currentThread().getContextClassLoader();  
        if (ccl == ContextLoader.class.getClassLoader()) {  
            //如果当前线程和本类的公用一个类加载器，则清空静态变量引用  
            currentContext = null;  
        }  
        else if (ccl != null) {  
            //否则根据线程的类加载器移除保存的Web应用程序环境  
            currentContextPerThread.remove(ccl);  
        }  
          
        //移除Servlet环境中的Web应用程序环境的引用  
        servletContext.removeAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE);  
          
        //如果父环境存在则释放父环境  
        if (this.parentContextRef != null) {  
            this.parentContextRef.release();  
        }  
    }  
}