说明：本文所用的SpringMVC版本为4.3.4.RELEASE，应用服务器为TomCat8.0.33。下面我们先回顾一下我们在用SpringMVC进行开发时在web.xml中进行的一些配置：

    <!-- 配置Spring上下文配置文件 -->
    <context-param>
        <param-name>contextConfigLocation</param-name>
        <param-value>classpath:applicationContext.xml</param-value>
    </context-param>
    <!-- 配置SpringMVC Servlet -->
    <servlet>
        <servlet-name>spring-miscellaneous</servlet-name>
        <!-- SpringMVC 分发器 -->
        <servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>
        <!-- 更改SpringMVC配置文件的名字 默认的是spring-mvc-servlet.xml -->
        <init-param>
            <param-name>contextConfigLocation</param-name>
            <param-value>classpath:spring-miscellaneous-mvc.xml</param-value>
        </init-param>
        <load-on-startup>1</load-on-startup>
    </servlet>
    <servlet-mapping>
        <servlet-name>spring-miscellaneous</servlet-name>
        <url-pattern>/</url-pattern>
    </servlet-mapping>
    <!-- 配置监听器 用来载入上下文配置文件 -->
    <listener>
        <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
    </listener>

上面的代码，基本上是我们用哪个SpringMVC开发时进行的一些配置。那么这些配置都用什么用呢？下面我们来一点一点进行分析:

ContextLoaderListener

。从图中我们可以看出ContextLoaderListener实现了ServletContextListener(Servlet上下文监听器)接口。我们简单说一下ServletContextListener的作用：ServletContextListener中有两个方法，一个是contextInitialized一个是contextDestroyed。每一个应用都有ServletContext与之相关联，ServletContext中存放了一些web应用全局性的配置。当Servlet容器启动的时候，会实例化和ServletContext相关的一些类。如ApplicationContext（注意不是Spring中的那个ApplicationContext）、ApplicationContexFacade、ServletConfig、ServletContextEvent以及ServletContextListener的实现类等等，并调用contextInitialized方法进行一些上下文初始化相关的动作。当Servlet容器关闭的时候，会调用contextDestroyed销毁上下文相关的内容。即ServletContextListener是和ServletContext的生命周期相关联的。ContextLoaderListener实现了ServletContextListener接口，所以当容器启动的时候，会调用ContextLoaderListener中的contextInitialized方法，进行一系列的初始化的动作。
而<context-param>中的内容即是ServletContext中的一些配置信息。
下面我们看一下从容器启动到调用到contextInitialized方法的调用链：

    @Override
    public void contextInitialized(ServletContextEvent event) {
        initWebApplicationContext(event.getServletContext());
    }

ContextLoaderListener中的内容很简单，就是调用了initWebApplicationContext这个方法，并把ServletContext的实现类(ApplicationContextFacade)传进去。initWebApplicationContext这个方法在ContextLoader这个类中，ContextLoaderListener继承了ContextLoader这个类，其实主要的调用逻辑都在ContextLoader这个类中。我们就进入到initWebApplicationContext这个方法中，看看代码中是怎么写的（去掉了无关的代码）：

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");
        long startTime = System.currentTimeMillis();
        try {
            //如果context为空的话，则创建Spring上下文 因为这里有一个带WebApplicationContext参数的构造函数
            if (this.context == null) {
                this.context = createWebApplicationContext(servletContext);
            }
            //如果Spring web上下文为可配置的web上下文
            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
                    //在Spring上下文还未刷新完之前  ApplicationContext是通过调用refresh方法来进行bean的加载初始化装配等一系列动作
                    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);
                }
            }
            //把Spring中的web上下文放到ServletContext中，  在程序中可以通过ServletContext获取到Spring中的web上下文
            servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
            //获取线程上下文加载器
            ClassLoader ccl = Thread.currentThread().getContextClassLoader();
            //如果线程上下文加载器和当前类加载器是同一个类加载器，则当前上下文和Context是一个东西
            if (ccl == ContextLoader.class.getClassLoader()) {
                currentContext = this.context;
            }
            //如果不是同一个类加载器加载的，则把刚实例化的上下文放到currentContextPerThread中 key是线程上下文加载器 value是当前实例化的context
            else if (ccl != null) {
                currentContextPerThread.put(ccl, this.context);
            }
            return this.context;
        }
    }

假设我们的this.context为null(这里我们只考虑正常的一般场景)，我们继续到createWebApplicationContext方法中，看一下是怎么创建Spring web上下文的:

protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
        //查找WebApplicationContext的实现类
        Class<?> contextClass = determineContextClass(sc);
        if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {//获取到的Class必须是ConfigurableWebApplicationContext的子类
            throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
                    "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
        }
        //实例化WebApplicationContext的实现类 注意的是这个实现类一定是实现了ConfigurableWebApplicationContext的接口的
        return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
    }

上面的代码很简单：查找WebApplicationContext的实现类，然后通过反射的方式实例化。实例化的过程不用多说，我们看一下determineContextClass这个方法。

protected Class<?> determineContextClass(ServletContext servletContext) {
        //从ServletContext中获取key为contextClass的配置信息
        String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
        //如果在web.xml中配置了WebApplicationContext的实现类，则获取配置的实现类的类信息
        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);
            }
        }
    }

从上面的代码中我们可以看出，我们可以配置在web.xml中配置WebApplicationContext的实现类，如果没有在web.xml中进行配置的话，则取默认的实现类。下面我们看一下是怎么去默认的实现类的：
在ContextLoader中有这样的一段代码：

static {
       //从类路径下获取ContextLoader.properties
       //Spring的Resource相关的类非常好用
       try {
           ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
           //加载ContextLoader.properties
           defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
       }
       catch (IOException ex) {
           throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
       }
   }

静态代码块，我们知道在类初始化的时候会执行静态代码块。所以在ContextLoader实例化之前已经加载过了ContextLoader.properties配置文件。我们看一下ContextLoader.properties中的内容：

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

我们发现这里就一个配置项，默认配置了一个WebApplicationContext的实现类：XmlWebApplicationContext。所以如果我们没有在web.xml中进行配置的话，这里就会实例化XmlWebApplicationContext这个类。
下面我们回到initWebApplicationContext这个方法中继续分析。因为我们的Context是刚实例化的，而active的默认值是false，所以会进入到if中，同样cwac.getParent()==null成立，所以会执行loadParentContext()这个方法。我们看看这个方法中做了什么操作：

protected ApplicationContext loadParentContext(ServletContext servletContext) {
        ApplicationContext parentContext = null;
        //从ServletContext中加载配置项为locatorFactorySelector的信息
        String locatorFactorySelector = servletContext.getInitParameter(LOCATOR_FACTORY_SELECTOR_PARAM);
        //从ServletContext中加载配置项为parentContextKey的新
        String parentContextKey = servletContext.getInitParameter(LOCATOR_FACTORY_KEY_PARAM);
        //如果设置了parentContextKey的信息
        if (parentContextKey != null) {
            // locatorFactorySelector may be null, indicating the default "classpath*:beanRefContext.xml"
            //实例化一个单例的BeanFactoryLocator
            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;
    }

loadParentContext主要做的就是从web.xml中加载父应用上下文。
下面就到了我们最重要的一个方法了configureAndRefreshWebApplicationContext了。接下来我们的分析也就是围绕这个类了：

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
        //这里判断wac有没有被初始化 设置过
        if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
            //如果ServletContext中配置了contextId，则获取配置的值，并设置为id的值
            String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
            if (idParam != null) {
                wac.setId(idParam);
            }
            else {
                // Generate default id...
                //生成一个默认的ID值
                wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
                        ObjectUtils.getDisplayString(sc.getContextPath()));
            }
        }
        //把ServletContext设置到Spring的Web上下文中
        wac.setServletContext(sc);
        //获取contextConfigLocation的值， 这个值就是我们的Spring的配置文件
        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);
        //调用上下文的刷新的方法，这里就开始bean的加载初始化实例化装配等一系列的动作
        wac.refresh();
    }

在上面的代码中我们分析一下customizeContext这个方法，对于wac.refresh();这个方法我们这里就先不展开了。因为这个方法是SpringIOC容器初始化的入口。内容太多了，我们以后在分析Spring的源码时再详细的说明。

   //获取配置的初始化的类
       List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> initializerClasses =
               determineContextInitializerClasses(sc);
       for (Class<ApplicationContextInitializer<ConfigurableApplicationContext>> initializerClass : initializerClasses) {
           Class<?> initializerContextClass =
                   GenericTypeResolver.resolveTypeArgument(initializerClass, ApplicationContextInitializer.class);
           if (initializerContextClass != null && !initializerContextClass.isInstance(wac)) {
               throw new ApplicationContextException(String.format(
                       "Could not apply context initializer [%s] since its generic parameter [%s] " +
                       "is not assignable from the type of application context used by this " +
                       "context loader: [%s]", initializerClass.getName(), initializerContextClass.getName(),
                       wac.getClass().getName()));
           }
           this.contextInitializers.add(BeanUtils.instantiateClass(initializerClass));
       }
       //进行排序操作  即上面得到的进行初始化的类 需要实现Ordered的接口或者配置@Order注解
       AnnotationAwareOrderComparator.sort(this.contextInitializers);
       for (ApplicationContextInitializer<ConfigurableApplicationContext> initializer : this.contextInitializers) {
           //调用初始化方法 进行初始化
           initializer.initialize(wac);
       }
   }

下面我们看一下determineContextInitializerClasses这个查找初始化类的方法

protected List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>
            determineContextInitializerClasses(ServletContext servletContext) {

        List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> classes =
                new ArrayList<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>();
        //从ServletContext中获取初始化参数为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中获取初始化参数为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;
    }

OK，到这里我们关于Spring Web上下文的分析就先到这里了。这里初始化了一个父的IOC容器。下篇文章我们接着分析DispatcherServlet的初始化过程。其时序图如下：