【Spring源码--IOC容器的实现】（一）Web容器的启动

1.由于大家平常用Spring基本都是Web项目中，那么今天就从Web的角度来看看IOC容器是怎么启动并管理Bean的。
2.本文及后续代码版本：Spring3.0.5。所以如发现代码（或图）不一致请注意Spring版本。
3.还是建议大家在前几遍读源码的时候，先把路走通，再回头研究细节。

Web容器接口体系

为了方便在Web环境中使用IOC容器，spring为Web应用提供了上下文接口WebApplicationContext来满足启动过程的需要。这个WebApplicationContext接口的类层次关系如图所示：

在接口设计中，最后是通过ApplicationContext接口与BeanFactory接口对接的，而对于具体功能的实现，很多都是封装在AbstractRefreshableWebApplicationContext中

那么容器启动的入口也就在这里了，context-param字面意思都可以理解，就是ServletContext的参数，这里我们配置了一个xml的路径。我们重点关注listener，这个Spring的ContextLoaderListener实现了ServletContextListener接口，这个接口是在Servlet API中定义的，提供了与Servlet生命周期结合的回调，比如contextInitialized和contextDestroy。那么，作为ServletContext的监听者，如果ServletContext发生变化，监听器就会做出相应的事件。比如：在服务器（tomcat等）启动时，ServletContextListener的contextInitialized方法被调用，服务器将要关闭时，contextDestroy方法被调用。我们来看下ContextLoaderListener的代码：

 

1. publicclassContextLoaderListenerextendsContextLoaderimplementsServletContextListener{
3. privateContextLoader contextLoader;
5. /**
6. * 初始化容器
7. * Initialize the root web application context.
8. */
9. publicvoid contextInitialized(ServletContextEvent event){
10. //这个方法实现的本意是提供一个占位符方法createContextLoader（）给子类机会创建客户化的环境加载，但是，后来这个证明不是非常有用的，已经鼓励不再使用了，事实上，子类可以通过重写本方法达到同样的目的
11. this.contextLoader = createContextLoader();
12. if(this.contextLoader ==null){
13. this.contextLoader =this;
14. }
15. this.contextLoader.initWebApplicationContext(event.getServletContext());
16. }
18. /**
19. * Create the ContextLoader to use. Can be overridden in subclasses.
20. * @return the new ContextLoader
21. * @deprecated in favor of simply subclassing ContextLoaderListener itself
22. * (which extends ContextLoader, as of Spring 3.0)
23. */
24. @Deprecated
25. protectedContextLoader createContextLoader(){
26. returnnull;
27. }
28. /**
29. * Return the ContextLoader used by this listener.
30. * @return the current ContextLoader
31. * @deprecated in favor of simply subclassing ContextLoaderListener itself
32. * (which extends ContextLoader, as of Spring 3.0)
33. */
34. @Deprecated
35. publicContextLoader getContextLoader(){
36. returnthis.contextLoader;
37. }
39. /**
40. * 销毁容器的方法
41. * Close the root web application context.
42. */
43. publicvoid contextDestroyed(ServletContextEvent event){
44. if(this.contextLoader !=null){
45. this.contextLoader.closeWebApplicationContext(event.getServletContext());
46. }
47. ContextCleanupListener.cleanupAttributes(event.getServletContext());
48. }
50. }

我们先重点关注容器的启动，也就是contextInitialized方法，从代码中可以看到它是调用的ContextLoader的initWebApplicationContext方法。我们来看下这个方法的代码：

 

1. publicWebApplicationContext initWebApplicationContext(ServletContext servletContext){
2. //判断ServletContext中是否已经有根上下文存在，存在抛出异常
3. if(servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE)!=null){
4. thrownewIllegalStateException(
5. "Cannot initialize context because there is already a root application context present - "+
6. "check whether you have multiple ContextLoader* definitions in your web.xml!");
7. }
9. Log logger =LogFactory.getLog(ContextLoader.class);
10. servletContext.log("Initializing Spring root WebApplicationContext");
11. if(logger.isInfoEnabled()){
12. logger.info("Root WebApplicationContext: initialization started");
13. }
14. long startTime =System.currentTimeMillis();
16. try{
17. //载入双亲上下文（通常是不存在）
18. ApplicationContext parent = loadParentContext(servletContext);
20. // 创建WebApplicationContext
21. this.context = createWebApplicationContext(servletContext, parent);
22. //把创建的根context保存到Servlet环境中
23. servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE,this.context);
25. //取得线程的类加载器
26. ClassLoader ccl =Thread.currentThread().getContextClassLoader();
27. if(ccl ==ContextLoader.class.getClassLoader()){
28. //如果线程和本类拥有相同的类加载器，则使用静态变量保存即可，因为同一类加载器加载同一份静态变量
29. currentContext =this.context;
30. }
31. elseif(ccl !=null){
32. //如果线程和本类拥有不同的类加载器，则使用线程的类加载器作为key在保存在一个映射对象里，保证析构时能拿到Webcontext进行关闭操作
33. currentContextPerThread.put(ccl,this.context);
34. }
36. if(logger.isDebugEnabled()){
37. logger.debug("Published root WebApplicationContext as ServletContext attribute with name ["+
38. WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE +"]");
39. }
40. if(logger.isInfoEnabled()){
41. long elapsedTime =System.currentTimeMillis()- startTime;
42. logger.info("Root WebApplicationContext: initialization completed in "+ elapsedTime +" ms");
43. }
45. returnthis.context;
46. }
47. catch(RuntimeException ex){
48. logger.error("Context initialization failed", ex);
49. servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
50. throw ex;
51. }
52. catch(Error err){
53. logger.error("Context initialization failed", err);
54. servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
55. throw err;
56. }
57. }

 

这里我们重点关注createWebApplicationContext(servletContext, parent)这个方法，这里是真正生产容器的地方。至于载入双亲上下文的方法，是根据我们ServletContext的参数取的，很明显，我们在上面的web.xml中只配置了xml的路径，并没有配置双亲上下文。想研究的同学可以去看下代码，这里不再多述。那么我们来看看这个创建容器的方法。
代码1.2：ContextLoader的createWebApplicationContext方法

 

 

1. protectedWebApplicationContext createWebApplicationContext(ServletContext sc,ApplicationContext parent){
2. //取得配置的Web应用程序环境类，如果没有配置，则使用缺省的类XmlWebApplicationContext
3. Class<?> contextClass = determineContextClass(sc);
4. //如果配置的Web应用程序环境类不是可配置的Web应用程序环境的子类，则抛出异常，停止初始化
5. if(!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)){
6. thrownewApplicationContextException("Custom context class ["+ contextClass.getName()+
7. "] is not of type ["+ConfigurableWebApplicationContext.class.getName()+"]");
8. }
9. //实例化需要产生的IOC容器，并设置容器的各种参数，然后通过refresh启动容器初始化
10. ConfigurableWebApplicationContext wac =
11. (ConfigurableWebApplicationContext)BeanUtils.instantiateClass(contextClass);
13. // 设置IOC容器的的ID
14. if(sc.getMajorVersion()==2&& sc.getMinorVersion()<5){
15. // 如果 Servlet规范 <= 2.4，则使用web.xml里定义的应用程序名字定义Web应用程序名
16. String servletContextName = sc.getServletContextName();
17. wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
18. ObjectUtils.getDisplayString(servletContextName));
19. }
20. else{
21. // 如果Servlet规范是 2.5， 则使用配置的ContextPath定义Web应用程序名
22. try{
23. String contextPath =(String)ServletContext.class.getMethod("getContextPath").invoke(sc);
24. wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
25. ObjectUtils.getDisplayString(contextPath));
26. }
27. catch(Exception ex){
28. //如果Servlet规范是2.5,但是不能取得ContextPath，抛出异常
29. thrownewIllegalStateException("Failed to invoke Servlet 2.5 getContextPath method", ex);
30. }
31. }
32. //设置双亲上下文
33. wac.setParent(parent);
34. //保存Servlet环境
35. wac.setServletContext(sc);
36. //这里其实就是设置xml的位置
37. wac.setConfigLocation(sc.getInitParameter(CONFIG_LOCATION_PARAM));
38. //提供子类可互换Web应用程序环境的机会
39. customizeContext(sc, wac);
40. //刷新Web应用程序环境以加载Bean定义【重点】
41. wac.refresh();
42. return wac;
43. }