Go语言视频零基础入门到精通

admin

  Spring对于程序员说来说都不陌生；作为一个强大的开源技术，帮助我们能够更好的进行项目的开发与维护。直接进入主题吧。Spring的启动过程实际上就是Ioc容器初始化以及载入Bean的过程；本文主要是学习记录下前半部分（Ioc容器的初始化），新手上路，如有错误，请指正！1.从配置文件说起

1. [code]<listener>  
2.      <listener-class>org.springframework.web.context.ContextLoaderListener
3.      </listener-class>  
4. </listener>
5. <context-param>  
6.     <param-name>contextConfigLocation</param-name>  
7.     <param-value>classpath:applicationContext.xml</param-value>  
8. </context-param>

复制代码

[/code]
  在一般的WEB项目中，项目的启动一般是从web.xml文件的载入开始的。如果我们的项目中使用了Spring，那么你肯定会在你的web.xml文件中看到上面的配置。Spring正是通过ContextLoaderListener监听器来进行容器初始化的。下面通过代码进行分析。
  2.Spring容器加载的三步走
  
   step1:创建一个WebApplicationContext
   step2:配置并且刷新Bean
   step3：将容器初始化到Servlet上下文中
  
  3.WebApplicationContext的创建过程

1. [code]public class ContextLoaderListener extends ContextLoader implements ServletContextListener

复制代码

[/code]
  从ContextLoaderListener的定义可以看出，该监听器继承了ContextLoader，并且重写了ServletContextListener中的contextInitialized和contextDestroyed方法。
  在contextInitialized中，通过调用父类（ContextLoader）的initWebApplicationContext方法进行容器创建：

1. [code]@Override
2. public void contextInitialized(ServletContextEvent event) {
3.     initWebApplicationContext(event.getServletContext());
4. }

复制代码

[/code]
  下面来看initWebApplicationContext的代码：

1. [code]public WebApplicationContext initWebApplicationContext(ServletContext servletContext) {
2.     //1：判断当前容器是否存在，如果存在则报容器已经存在的异常信息
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.     }
8.     Log logger = LogFactory.getLog(ContextLoader.class);
9.     //下面这个日志就是我们经常在启动Spring项目时看到的日志信息:
10.     //Initializing Spring root WebApplicationContext
11.     //Root WebApplicationContext: initialization started
12.     servletContext.log("Initializing Spring root WebApplicationContext");
13.     if (logger.isInfoEnabled()) {
14.       logger.info("Root WebApplicationContext: initialization started");
15.     }
16.     long startTime = System.currentTimeMillis();
18.     try {
19.       // Store context in local instance variable, to guarantee that
20.       // it is available on ServletContext shutdown.
21.       //如果当前容器为null,则创建一个容器，并将servletContext上下文作为参数传递进去，
22.       if (this.context == null) {
23.         this.context = createWebApplicationContext(servletContext);
24.       }
25.        //判断当前容器是否为可配置的，只有是Configurable的容器，才能进行后续的配置
26.       if (this.context instanceof ConfigurableWebApplicationContext) {
27.         ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
28.         if (!cwac.isActive()) {
29.           // The context has not yet been refreshed -> provide services such as
30.           // setting the parent context, setting the application context id, etc
31.           if (cwac.getParent() == null) {
32.             // The context instance was injected without an explicit parent ->
33.             // determine parent for root web application context, if any.
34.             ApplicationContext parent = loadParentContext(servletContext);
35.             cwac.setParent(parent);
36.           }
37.            //三步走中的第二步：配置并且刷新当前容器
38.           configureAndRefreshWebApplicationContext(cwac, servletContext);
39.         }
40.       }
41.        //将配置并且刷新过的容器存入servlet上下文中，并以WebApplicationContext的类名作为key值
43.       servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
45.       ClassLoader ccl = Thread.currentThread().getContextClassLoader();
46.       if (ccl == ContextLoader.class.getClassLoader()) {
47.         currentContext = this.context;
48.       }
49.       else if (ccl != null) {
50.         currentContextPerThread.put(ccl, this.context);
51.       }
53.       if (logger.isDebugEnabled()) {
54.         logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
55.             WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
56.       }
57.       if (logger.isInfoEnabled()) {
58.         long elapsedTime = System.currentTimeMillis() - startTime;
59.         logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
60.       }
61.        //返回创建好的容器
62.       return this.context;
63.     }
64.     catch (RuntimeException ex) {
65.       logger.error("Context initialization failed", ex);
66.       servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
67.       throw ex;
68.     }
69.     catch (Error err) {
70.       logger.error("Context initialization failed", err);
71.       servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
72.       throw err;
73.     }
74.   }

复制代码

[/code]
  下面我们在看下是如何创建WebApplicationContext的

1. [code]protected WebApplicationContext createWebApplicationContext(ServletContext sc) {
2.     //首先来确定context是由什么类定义的，并且判断当前容器是否为可配置的
3.     Class<?> contextClass = determineContextClass(sc);
4.     if (!ConfigurableWebApplicationContext.class.isAssignableFrom(contextClass)) {
5.       throw new ApplicationContextException("Custom context class [" + contextClass.getName() +
6.           "] is not of type [" + ConfigurableWebApplicationContext.class.getName() + "]");
7.     }
8.     //创建可配置的上下文容器
9.     return (ConfigurableWebApplicationContext) BeanUtils.instantiateClass(contextClass);
10.   }

复制代码

[/code]
  最后来看下determineContextClass这个方法

1. [code]protected Class<?> determineContextClass(ServletContext servletContext) {
2.     //首先从web.xml中查看用户是否自己定义了context
3.     String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
4.     //如果有，则通过反射创建实例
5.     if (contextClassName != null) {
6.       try {
7.         return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
8.       }
9.       catch (ClassNotFoundException ex) {
10.         throw new ApplicationContextException(
11.             "Failed to load custom context class [" + contextClassName + "]", ex);
12.       }
13.     }
14.     /*如果没有，则去defaultStrategies里面取【defaultStrategies是Propertites类的/对象，在ContextLoader中的静态代码块中初始化的；具体可看下下面的图像】；默认容器是XmlWebApplicationContext*/
15.   else {
16.    contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
17.       try {
18.         return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
19.       }
20.       catch (ClassNotFoundException ex) {
21.         throw new ApplicationContextException(
22.             "Failed to load default context class [" + contextClassName + "]", ex);
23.       }
24.     }
25.   }

复制代码

[/code]
  总的来说就是：Spring的web工程首先回去检查用户是否自己定义了context，如果有就采用；如果没有就使用Spring默认的。defaultStrategies初始化：
  
  
  至此，容器创建完成。下面是整个过程的一个流程图（有疏漏，回头补一个时序图）：