【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中完成的。再从代码的角度看下这个继承体系：

• Web容器的启动

  1.web.xml中的配置

  为了使用Spring，我们一般都会在web.xml中配一个监听器。如下：

  2. contextConfigLocation
  3. classpath:applicationContext.xml
  6. org.springframework.web.context.ContextLoaderListener

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

  代码1.1：ContextLoaderListener源码

1. public class ContextLoaderListener extends ContextLoader implements ServletContextListener {
3. private ContextLoader contextLoader;
5. /**
6. * 初始化容器
7. * Initialize the root web application context.
8. */
9. public void 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. protected ContextLoader createContextLoader() {
26. return null;
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. public ContextLoader getContextLoader() {
36. return this.contextLoader;
37. }
39. /**
40. * 销毁容器的方法
41. * Close the root web application context.
42. */
43. public void 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.2：ContextLoader的initWebApplicationContext方法

1. public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
2. //判断ServletContext中是否已经有根上下文存在，存在抛出异常
3. if (servletContext.getAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE) != null) {
4. throw new IllegalStateException(
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. else if (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. return this.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. protected WebApplicationContext createWebApplicationContext(ServletContext sc, ApplicationContext parent) {
2. //取得配置的Web应用程序环境类，如果没有配置，则使用缺省的类XmlWebApplicationContext
3. Class contextClass = determineContextClass(sc);
4. //如果配置的Web应用程序环境类不是可配置的Web应用程序环境的子类，则抛出异常，停止初始化
5. if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
6. throw new ApplicationContextException("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. throw new IllegalStateException("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. }

这个refresh方法是我们后面讲IOC容器的重点，这里web容器启动也就到这里了。后面是真正的IOC怎么加载Resource、解析BeanDefinition、注册、依赖注入。

参考文献：

【Spring技术内幕】第二版