【小家Spring】Spring容器（含父子容器）的启动过程源码级别分析（含web.xml启动以及全注解驱动，和ContextLoader源码分析）

if (!waiClass.isInterface() && !Modifier.isAbstract(waiClass.getModifiers()) &&
						WebApplicationInitializer.class.isAssignableFrom(waiClass)) {
	try {
		initializers.add((WebApplicationInitializer)
				ReflectionUtils.accessibleConstructor(waiClass).newInstance());
	} catch (Throwable ex) {
		throw new ServletException("Failed to instantiate WebApplicationInitializer class", ex);
	}
}

...

//排序后，循环调用onStartup方法 进行初始化
AnnotationAwareOrderComparator.sort(initializers);
for (WebApplicationInitializer initializer : initializers) {
	initializer.onStartup(servletContext);
}

@Override
public void onStartup(ServletContext servletContext) throws ServletException {
	super.onStartup(servletContext);
	registerDispatcherServlet(servletContext);
}

super如下：
@Override
public void onStartup(ServletContext servletContext) throws ServletException {
	registerContextLoaderListener(servletContext);
}

protected void registerContextLoaderListener(ServletContext servletContext) {
	WebApplicationContext rootAppContext = createRootApplicationContext();
	if (rootAppContext != null) {
		// 创建listener 并且把已经创建好的容器放进去
		ContextLoaderListener listener = new ContextLoaderListener(rootAppContext);
		//放入监听器需要的一些上下文，此处木有。一般都为null即可~~~。若有需要（自己定制），子类复写此方法即可
		listener.setContextInitializers(getRootApplicationContextInitializers());
		// 把监听器加入进来  这样该监听器就能监听ServletContext了，并且执行contextInitialized方法
		servletContext.addListener(listener);
	}
}

@Override
@Nullable //Spring告诉我们，这个是允许返回null的，也就是说是允许我们返回null的，后面会专门针对这里如果返回null，后面会是怎么样的流程的一个说明
protected WebApplicationContext createRootApplicationContext() {
	Class<?>[] configClasses = getRootConfigClasses();
	if (!ObjectUtils.isEmpty(configClasses)) {
		AnnotationConfigWebApplicationContext context = new AnnotationConfigWebApplicationContext();
		//配置文件可以有多个  会以累加的形式添加进去
		context.register(configClasses);
		return context;
	}
	else {
		return null;
	}
}

protected void registerDispatcherServlet(ServletContext servletContext) {
	//Servlet名称 一般用系统默认的即可，否则自己复写此方法也成
	String servletName = getServletName();
	Assert.hasLength(servletName, "getServletName() must not return null or empty");
	
	//创建web的子容易。创建的代码和上面差不多，也是使用调用者提供的配置文件，创建AnnotationConfigWebApplicationContext.  备注：此处不可能为null哦
	WebApplicationContext servletAppContext = createServletApplicationContext();
	Assert.notNull(servletAppContext, "createServletApplicationContext() must not return null");
	
	//创建DispatcherServlet，并且把子容器传进去了。其实就是new一个出来，最后加到容器里，就能够执行一些init初始化方法了~
	FrameworkServlet dispatcherServlet = createDispatcherServlet(servletAppContext);
	Assert.notNull(dispatcherServlet, "createDispatcherServlet(WebApplicationContext) must not return null");
	//同样的 getServletApplicationContextInitializers()一般也为null即可
	dispatcherServlet.setContextInitializers(getServletApplicationContextInitializers());
	
	//注册servlet到web容器里面，这样就可以接收请求了
	ServletRegistration.Dynamic registration = servletContext.addServlet(servletName, dispatcherServlet);
	if (registration == null) {
		throw new IllegalStateException("Failed to register servlet with name '" + servletName + "'. " +
				"Check if there is another servlet registered under the same name.");
	}
	
	//1表示立马执行哦，没有第一次惩罚了
	registration.setLoadOnStartup(1);
	registration.addMapping(getServletMappings()); //调用者必须实现
	registration.setAsyncSupported(isAsyncSupported()); //默认就是开启了支持异步的

	//处理自定义的Filter进来，一般我们Filter不这么加进来，而是自己@WebFilter，或者借助Spring，  备注：这里添加进来的Filter都仅仅只拦截过滤上面注册的dispatchServlet
	Filter[] filters = getServletFilters();
	if (!ObjectUtils.isEmpty(filters)) {
		for (Filter filter : filters) {
			registerServletFilter(servletContext, filter);
		}
	}
	
	//这个很清楚：调用者若相对dispatcherServlet有自己更个性化的参数设置，复写此方法即可
	customizeRegistration(registration);
}

public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
	// 虽然注解驱动传进来的监听器对象持有WebApplicationContext的引用，但是并没有放进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!");
	}

	
	long startTime = System.currentTimeMillis();

	try {
		// 这句特别重要，兼容了web.xml的方式以及注解驱动的方式。本文中是注解驱动的方式，所以此处不会null。下面讲解web.xml的方式的时候，我再会去详细讲解createWebApplicationContext(servletContext)这个方法~~~
		if (this.context == null) {
			this.context = createWebApplicationContext(servletContext);
		}
		
		//从上图可以看出：XmlWebApplicationContext(xml驱动)和AnnotationConfigWebApplicationContext(注解驱动)都是复合的，都会进来
		if (this.context instanceof ConfigurableWebApplicationContext) {
			ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
				
			//一般来说刚创建的context并没有处于激活状态,所以会进来完善一些更多的容器信息。比如刷新容器等等
			if (!cwac.isActive()) {
				if (cwac.getParent() == null) {
					//在web.xml中配置了<context-param>的parentContextKey才会指定父级应用(或者我们自己复写此方法)   绝大多数情况下，Spring容器不用再给设置父容器
					ApplicationContext parent = loadParentContext(servletContext);
					cwac.setParent(parent);
				}
				
				//读取相应的配置并且刷新context对象   这一步就极其重要了，因为刷新容器做了太多的事，属于容器的最最最核心逻辑（详解且见下问分解）
				configureAndRefreshWebApplicationContext(cwac, servletContext);
			}
		}
		//放进ServletContext上下文，避免再次被初始化，也让我们能更加方便的获取到容器
		servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);

		//此处把容器和当前线程绑定，public static WebApplicationContext getCurrentWebApplicationContext()这样就可以更加方便得得到容器.类为：ContextLoader
		ClassLoader ccl = Thread.currentThread().getContextClassLoader();
		if (ccl == ContextLoader.class.getClassLoader()) {
			currentContext = this.context;
		}
		else if (ccl != null) {
			currentContextPerThread.put(ccl, this.context);
		}
}

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc){
     //一般此处为真，给ApplicationContext设置一个id
     if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
           //获取servletContext中的contextId属性  contextId,可在web.xml里配置,一般也不用配置，采用else里的默认值即可
           String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
           if (idParam != null) {
               //存在则设为指定的id名
               wac.setId(idParam);
           } else {
               // 生成默认id... 一般为org.springframework.web.context.WebApplicationContext:${contextPath}
               wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
                       ObjectUtils.getDisplayString(sc.getContextPath()));
           }
       }
		
	   //让容器关联上servlet上下文
       wac.setServletContext(sc);
       
       //读取contextConfigLocation属性(在web.xml配置，但是注解驱动里没有,因此为null)
       String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
       if (configLocationParam != null) {
           //设置指定的spring文件所在地，支持classpath前缀并多文件，以,;为分隔符
           wac.setConfigLocation(configLocationParam);
       }
       //这里有一个注意的地方，ConfigurableEnvironment生成的地方
       //====wac.setConfigLocation(configLocationParam); 时根据 configLocationParam设置配置参数路径时就会初始化StandardServletEnvironment（ConfigurableEnvironment的子类)

       //StandardServletEnvironment符合条件，因此会执行initPropertySources方法。只与此方法的作用，后面再有相关文章详解
       ConfigurableEnvironment env = wac.getEnvironment();
       if (env instanceof ConfigurableWebEnvironment) {
           ((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
       }
       //检查web.xml是否有一些其余初始化类的配置，极大多数情况都不需要，所以粗暴理解为没什么卵用
       customizeContext(sc, wac);
       
       //容器的核心方法，也是最难的一个方法，这个在Spring容器详解中，会继续降到此方法
       //这里先理解为就是初始化容器，比如加载bean、拦截器、各种处理器的操作就够了~（也是最耗时的一步操作）
       wac.refresh();
}

Root WebApplicationContext: initialization completed in 75383 ms

	@Override
	public final void init() throws ServletException {
		// 把servlet的初始化参数封装进来...
		PropertyValues pvs = new ServletConfigPropertyValues(getServletConfig(), this.requiredProperties);

		//这里面我们并没有给此Servlet初始化的一些参数，所以此处为空，为false
		//若进来了，可以看到里面会做一些处理：将这个DispatcherServlet转换成一个BeanWrapper对象，从而能够以spring的方式来对初始化参数的值进行注入。这些属性如contextConfigLocation、namespace等等。
		//同时注册一个属性编辑器，一旦在属性注入的时候遇到Resource类型的属性就会使用ResourceEditor去解析。再留一个initBeanWrapper(bw)方法给子类覆盖，让子类处真正执行BeanWrapper的属性注入工作。
		//但是HttpServletBean的子类FrameworkServlet和DispatcherServlet都没有覆盖其initBeanWrapper(bw)方法，所以创建的BeanWrapper对象没有任何作用。
		
		//备注：此部分把当前Servlet封装成一个BeanWrapper在把它交给Spring管理部分非常重要，比如后续我们讲到SpringBoot源码的时候，会看出来这部分代码的重要性了。。。
		if (!pvs.isEmpty()) {
			try {
				BeanWrapper bw = PropertyAccessorFactory.forBeanPropertyAccess(this);
				ResourceLoader resourceLoader = new ServletContextResourceLoader(getServletContext());
				bw.registerCustomEditor(Resource.class, new ResourceEditor(resourceLoader, getEnvironment()));
				initBeanWrapper(bw);
				bw.setPropertyValues(pvs, true);
			} catch (BeansException ex) {
				throw ex;
			}
		}

		// Let subclasses do whatever initialization they like.
		// 从官方注解也能读懂。它把这个init方法给final掉了，然后开了这个口，子类可以根据自己的需要，在初始化的的时候可以复写这个方法，而不再是init方法了~ 
		initServletBean();
	}

	@Override
	protected final void initServletBean() throws ServletException {
		long startTime = System.currentTimeMillis();

		try {
			// 这是重点，开始初始化这个子容器了
			this.webApplicationContext = initWebApplicationContext();
			//继续留一个口，给子类去复写初始化所需要的操作  一般都为空实现即可，除非自己要复写DispatcherServlet，做自己需要做的事
			initFrameworkServlet();
		}
		
		//当我们看到这句日志，就能知道dispatcherServlet已经初始化完成，web子容器也就初始化完成了
		if (this.logger.isInfoEnabled()) {
			long elapsedTime = System.currentTimeMillis() - startTime;
			this.logger.info("FrameworkServlet '" + getServletName() + "': initialization completed in " +
					elapsedTime + " ms");
		}
	}

	protected WebApplicationContext initWebApplicationContext() {
		// 从ServletContext中把上面已经创建好的根容器拿到手
		WebApplicationContext rootContext = WebApplicationContextUtils.getWebApplicationContext(getServletContext());
		WebApplicationContext wac = null;
		
		//但是，但是，但是此处需要注意了，因为本处我们是注解驱动的，在上面已经看到了，我们new DispatcherServlet出来的时候，已经传入了根据配置文件创建好的子容器web容器，因此此处肯定是不为null的，因此此处会进来，和上面一样，完成容器的初始化、刷新工作，因此就不再解释了~
		if (this.webApplicationContext != null) {
			// A context instance was injected at construction time -> use it
			wac = this.webApplicationContext;
			if (wac instanceof ConfigurableWebApplicationContext) {
				ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) wac;
				if (!cwac.isActive()) {
					if (cwac.getParent() == null) {
						//此处吧根容器，设置为自己的父容器
						cwac.setParent(rootContext);
					}
					//根据绑定的配置，初始化、刷新容器
					configureAndRefreshWebApplicationContext(cwac);
				}
			}
		}

		//若是web.xml方式，会走这里，进而走findWebApplicationContext(),因此此方法，我会在下面详细去说明，这里占时略过
		if (wac == null) {
			wac = findWebApplicationContext();
		}
		if (wac == null) {
			wac = createWebApplicationContext(rootContext);
		}

		// 此处需要注意了：下面有解释，refreshEventReceived和onRefresh方法，不会重复执行~
		if (!this.refreshEventReceived) {
			onRefresh(wac);
		}

		//我们是否需要吧我们的容器发布出去，作为ServletContext的一个属性值呢？默认值为true哦，一般情况下我们就让我true就好
		if (this.publishContext) {
			// Publish the context as a servlet context attribute.
			// 这个attr的key的默认值，就是FrameworkServlet.SERVLET_CONTEXT_PREFIX，保证了全局唯一性
			// 这么一来，我们的根容器、web子容器其实就都放进ServletContext上下文里了，拿取都非常的方便了。   只是我们一般拿这个容器的情况较少，一般都是拿跟容器，比如那个工具类就是获取根容器的~~~~~~
			String attrName = getServletContextAttributeName();
			getServletContext().setAttribute(attrName, wac);
		}
		return wac;
	}

		request.setAttribute(WEB_APPLICATION_CONTEXT_ATTRIBUTE, getWebApplicationContext());
		request.setAttribute(LOCALE_RESOLVER_ATTRIBUTE, this.localeResolver);
		request.setAttribute(THEME_RESOLVER_ATTRIBUTE, this.themeResolver);
		request.setAttribute(THEME_SOURCE_ATTRIBUTE, getThemeSource());

	@Override
	protected void onRefresh(ApplicationContext context) {
		initStrategies(context);
	}
	
	//初始化Spring MVC的9大组件(至此，才算全部初始化完成了~不容器啊)
	protected void initStrategies(ApplicationContext context) {
		initMultipartResolver(context);
		initLocaleResolver(context);
		initThemeResolver(context);
		initHandlerMappings(context);
		initHandlerAdapters(context);
		initHandlerExceptionResolvers(context);
		initRequestToViewNameTranslator(context);
		initViewResolvers(context);
		initFlashMapManager(context);
	}

14:42:47.354 [RMI TCP Connection(2)-127.0.0.1] INFO  o.s.web.servlet.DispatcherServlet - FrameworkServlet 'dispatcher': initialization completed in 1674475 ms

	// init-param定义root根容器id的key
	public static final String CONTEXT_ID_PARAM = "contextId";
	// init-param 定义root根容器的配置文件的路径地址的key
	public static final String CONFIG_LOCATION_PARAM = "contextConfigLocation";
	// init-param 自己可以指定一个WebApplicationContext的实现类（一般都不需要~）
	public static final String CONTEXT_CLASS_PARAM = "contextClass";
	// init-param 可以伴随着容器初始化的时候，我们自己做一些工作的类们。注意需要实现对应接口哦~ key
	public static final String CONTEXT_INITIALIZER_CLASSES_PARAM = "contextInitializerClasses";
	// 基本同上
	public static final String GLOBAL_INITIALIZER_CLASSES_PARAM = "globalInitializerClasses";
	// 多值分隔符号
	private static final String INIT_PARAM_DELIMITERS = ",; \t\n";
	// 默认的配置文件  里面内容只有一句话： org.springframework.web.context.WebApplicationContext=org.springframework.web.context.support.XmlWebApplicationContext
	// 由此课件，它默认是采用XmlWebApplicationContext来初始化上下文的
	private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";

	// ContextLoader在被实例化的时候，会执行下面的这个静态代码块。做了一件事：把默认的配置文件加载进来而已
	private static final Properties defaultStrategies;
	static {
		try {
			ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
			defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
		}
	}

	// 这两个属性主要拿到当前的容器上下文。其中static的工具方法ContextLoader.getCurrentWebApplicationContext是基于此的
	private static final Map<ClassLoader, WebApplicationContext> currentContextPerThread = new ConcurrentHashMap<>(1);
	@Nullable
	private static volatile WebApplicationContext currentContext;

if (this.context == null) {
    this.context = createWebApplicationContext(servletContext);
}

	public static WebApplicationContext getCurrentWebApplicationContext() {
		ClassLoader ccl = Thread.currentThread().getContextClassLoader();
		if (ccl != null) {
			WebApplicationContext ccpt = currentContextPerThread.get(ccl);
			if (ccpt != null) {
				return ccpt;
			}
		}
		return currentContext;
	}

ApplicationContext ctx = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext()); 

    @Autowired
    private HttpServletRequest request;

    @Override
    public Object hello() {

        ApplicationContext ctx1 = WebApplicationContextUtils.getWebApplicationContext(request.getSession().getServletContext());
        WebApplicationContext ctx2 = ContextLoader.getCurrentWebApplicationContext();
        System.out.println(ctx1); //Root WebApplicationContext: startup date ...
        System.out.println(ctx1 == ctx2); //true

        return "service hello";
    }

	@Override
	public void setApplicationContext(ApplicationContext applicationContext) {
		if (this.webApplicationContext == null && applicationContext instanceof WebApplicationContext) {
			this.webApplicationContext = (WebApplicationContext) applicationContext;
			this.webApplicationContextInjected = true;
		}
	}

//getNameSpace会返回你在web.xml中配置的servlet-name加上"-servlet"，这个namespace会在之后application context加载spring MVC配置文件时候用到
//比如你给servlet取名叫 SpringMVCServlet，那么当Spring MVC初始化的时候，会去寻找名为/WEB-INF/SpringMVCServlet-servlet.xml的配置文件。  
// 不过个人建议：还是配置上配置文件比较好  不要用默认的
public static final String DEFAULT_NAMESPACE_SUFFIX = "-servlet";
public String getNamespace() {
	return (this.namespace != null ? this.namespace : getServletName() + DEFAULT_NAMESPACE_SUFFIX);
}

// 默认的容器类型。若没有配置contextClass就用它
public static final Class<?> DEFAULT_CONTEXT_CLASS = XmlWebApplicationContext.class;


// 这些值，都可以通过将Servlet初始化参数（init-param）设置到该组件上（如contextAttribute、contextClass、namespace、contextConfigLocation）
@Nullable
private String contextAttribute;
private Class<?> contextClass = DEFAULT_CONTEXT_CLASS;
@Nullable
private String contextId;
@Nullable
private String namespace;
@Nullable
private String contextConfigLocation;

<listener>  
    <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
</listener>
<context-param>  
    <param-name>contextConfigLocation</param-name>  
    <param-value>classpath:spring/applicationContext.xml</param-value>  
</context-param>

<!-- 配置DispatcherServlet -->  
<servlet>  
　　<servlet-name>springMvc</servlet-name>  
　　<servlet-class>org.springframework.web.servlet.DispatcherServlet</servlet-class>  
　　<!-- 指定spring mvc配置文件位置 不指定使用默认情况 -->  
　　<init-param>     
    　　<param-name>contextConfigLocation</param-name>
    　　<param-value>classpath:spring/spring-mvc.xml</param-value>
　　 </init-param>  
　　<!-- 设置启动顺序 1表示立即启动，而不是首次访问再启动-->  
　　<load-on-startup>1</load-on-startup>  
　　<async-supported>true</async-supported>
</servlet>
<servlet-mapping>
　　<servlet-name>springMvc</servlet-name>
　　<url-pattern>/</url-pattern>
</servlet-mapping>

# Default implementation classes for DispatcherServlet's strategy interfaces.
# Used as fallback when no matching beans are found in the DispatcherServlet context.
# Not meant to be customized by application developers.

org.springframework.web.servlet.LocaleResolver=org.springframework.web.servlet.i18n.AcceptHeaderLocaleResolver

org.springframework.web.servlet.ThemeResolver=org.springframework.web.servlet.theme.FixedThemeResolver

org.springframework.web.servlet.HandlerMapping=org.springframework.web.servlet.handler.BeanNameUrlHandlerMapping,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerMapping

org.springframework.web.servlet.HandlerAdapter=org.springframework.web.servlet.mvc.HttpRequestHandlerAdapter,\
	org.springframework.web.servlet.mvc.SimpleControllerHandlerAdapter,\
	org.springframework.web.servlet.mvc.method.annotation.RequestMappingHandlerAdapter

org.springframework.web.servlet.HandlerExceptionResolver=org.springframework.web.servlet.mvc.method.annotation.ExceptionHandlerExceptionResolver,\
	org.springframework.web.servlet.mvc.annotation.ResponseStatusExceptionResolver,\
	org.springframework.web.servlet.mvc.support.DefaultHandlerExceptionResolver

org.springframework.web.servlet.RequestToViewNameTranslator=org.springframework.web.servlet.view.DefaultRequestToViewNameTranslator

org.springframework.web.servlet.ViewResolver=org.springframework.web.servlet.view.InternalResourceViewResolver

org.springframework.web.servlet.FlashMapManager=org.springframework.web.servlet.support.SessionFlashMapManager

	protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
		// 找到上下文类型。若自己没有配置实现类，那就是XmlApplicationContext
		Class<?> contextClass = determineContextClass(sc);
		// 由此看出  用户diy的也必须是ConfigurableWebApplicationContext的子类才行
		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) {
		// 显然，一般情况下我们都不会自己配置一个容器类，自己去实现~ 所有走else
		String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
		if (contextClassName != null) {
			try {
				return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
			}
		} else {
			// 采用默认配置文件里的XmlApplicationContext来初始化上下文
			contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
			try {
				return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
			}
		}
	}

	protected WebApplicationContext findWebApplicationContext() {
		// 只有调用过setContextAttribute(String contextAttribute)这里才有值，否则为null  或者web.xml里配置：contextAttribute为key的属性值
		String attrName = getContextAttribute();
		if (attrName == null) {
			return null;
		}
		//按照这个attr去Servlet容器里面找
		WebApplicationContext wac =
				WebApplicationContextUtils.getWebApplicationContext(getServletContext(), attrName);
		if (wac == null) {
			throw new IllegalStateException("No WebApplicationContext found: initializer not registered?");
		}
		return wac;
	}

	protected WebApplicationContext createWebApplicationContext(@Nullable ApplicationContext parent) {
		// 没有配置的话，默认值为public static final Class<?> DEFAULT_CONTEXT_CLASS = XmlWebApplicationContext.class;
		Class<?> contextClass = getContextClass();
		
		// 校验必须是ConfigurableWebApplicationContext的子类
		if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
			throw new ApplicationContextException(
					"Fatal initialization error in servlet with name '" + getServletName() +
					"': custom WebApplicationContext class [" + contextClass.getName() +
					"] is not of type ConfigurableWebApplicationContext");
		}
		// 创建一个容器实例
		ConfigurableWebApplicationContext wac =
				(ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);

		// 设置好父容器、Enviroment等等
		wac.setEnvironment(getEnvironment());
		wac.setParent(parent);
		
		//看看有没有配置配置文件的位置
		String configLocation = getContextConfigLocation();
		if (configLocation != null) {
			wac.setConfigLocation(configLocation);
		}
		
		// 这个是重点，如完善、初始化、刷新容器
		configureAndRefreshWebApplicationContext(wac);

		return wac;
	}

	protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac) {
		if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
			if (this.contextId != null) {
				wac.setId(this.contextId);
			} else {
				// 默认的id  这里面和contextpath有关了
				wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
						ObjectUtils.getDisplayString(getServletContext().getContextPath()) + '/' + getServletName());
			}
		}
		
		// 关联到了Namespace/servlet等等
		wac.setServletContext(getServletContext());
		wac.setServletConfig(getServletConfig());
		wac.setNamespace(getNamespace());
		//添加了一个容器监听器  此监听器SourceFilteringListener在后面还会碰到
		wac.addApplicationListener(new SourceFilteringListener(wac, new ContextRefreshListener()));

		// 同之前~
		ConfigurableEnvironment env = wac.getEnvironment();
		if (env instanceof ConfigurableWebEnvironment) {
			((ConfigurableWebEnvironment) env).initPropertySources(getServletContext(), getServletConfig());
		}
		
		//留给子类，可以复写此方法，做一些初始化时候自己的实行
		postProcessWebApplicationContext(wac);
		
		//同样的 执行一些初始化类们  一般也是用不着。备注:用到了这个常量ContextLoader.GLOBAL_INITIALIZER_CLASSES_PARAM
		applyInitializers(wac);
		wac.refresh();
	}