网上很多关键字针对了“spring源码阅读”,但仔细的查看了很多，发现大部分都是一样的，而且讲得很粗，可以借鉴这些思路.但粗粗的去读一下这些文章，对spring真正的实现，还是比较迷茫的，要想真正了解spring,还是得仔细的研读它的每一行代码，对照着别人的思路，静下心来，反复看，才能一点一点的去理解它。有些关键字在百度上讨论得很少的关键字，比如：“EntityResolver”，“PropertySource”,"propertyResolver"之类的，很多人的博文略提到了一点，但也是匆匆而过，这些，都需要自己去看document,自己去看代码，自己去想。
首先，从哪里开始读，我们的web工程要用到spring,必须在web的配置中引入spring的框架，那么，首先就需要去web.xml里找。contextLoaderListener正是我们要找的答案，同样的道理，log4j等等这些框架，也是在这里进行配置，我们通过listener的方式去引入它
<context-param> <param-name>contextConfigLocation</param-name> <param-value> classpath*:spring/applicationcontext.xml, classpath*:spring/spring-*.xml, classpath*:spring/consumer/spring-*.xml, classpath*:spring/provider/spring-*.xml </param-value> </context-param> <context-param> <param-name>log4jConfigLocation</param-name> <param-value>/WEB-INF/log4j.properties</param-value> </context-param> <context-param> <param-name>log4jRefreshInterval</param-name> <param-value>60000</param-value> </context-param> <listener> <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class> </listener> <listener> <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class> </listener>这里可以看到，我们用到了spring的web包下的contextLoaderListener来作为整个spring容器加载的入口，这里，要稍微提一下，读spring的任何源码的时候，最好刻意的，让自己去看一下他的包路径，对理解它整个框架的划分，慢慢的会有一些好处。 下面，我们来看看contextLoaderListener.
public class ContextLoaderListener extends ContextLoader implements ServletContextListener { 从ServletContextListener继承而来，ServletContextListener是servlet包下的接口
/**
* Implementations of this interface receive notifications about
* changes to the servlet context of the web application they are
* part of.
* To receive notification events, the implementation class
* must be configured in the deployment descriptor for the web
* application.
* @see ServletContextEvent
* @since v 2.3
*/
public interface ServletContextListener extends EventListener {
/**
** Notification that the web application initialization
** process is starting.
** All ServletContextListeners are notified of context
** initialization before any filter or servlet in the web
** application is initialized.
*/
public void contextInitialized ( ServletContextEvent sce );
/**
** Notification that the servlet context is about to be shut down.
** All servlets and filters have been destroy()ed before any
** ServletContextListeners are notified of context
** destruction.
*/
public void contextDestroyed ( ServletContextEvent sce ); 可以看到，他有一个contextInitialized方法，这个方法在启动初始化时回调，因此，在contextLoaderListener中，找到这个方法的实现，就是我们需要的地方
public void contextInitialized(ServletContextEvent event) {
this.contextLoader = createContextLoader();
if (this.contextLoader == null) {
this.contextLoader = this;
}
this.contextLoader.initWebApplicationContext(event.getServletContext());
} 好了，前4行代码忽略，createContextLoader()在spring2.5以后，变成了空实现，里面啥也没干，直接进入 contextLoader.initWebApplicationContext. 在进入之前，我们对它的名字思考一下，顾名思义， contextLoaderListner中有一个contextLoader对象，我们用它去初始化WebApplicationContext.用一个ServletContext作为参数，这里要先强调一下，读spring的代码，一定要注意它的一些抽象概念，比如context,ServletContext,Reader,Bean,这种名词，当你全部理解了这些名词的时候，你也就真的懂了 这里我们用到了这两个： 1.contextLoader: 读取器，用来读context的读取器，context是spring中一个非常重要的概念，我们可以简单的 理解为容器，如ApplicationContext. 2.ServletContext: servlet上下文，我们在很多时候写代码都需要一些贯穿始终的参数，在servlet环境中，web容器就是利用servletContext来作为一个参数进行传递，后续我们还会读到spring中的一些比如holder. propertySources等概念，也是这个用途 3.WebApplicationContext: web环境的spring容器,是容器的一种 接下来，进入initWebApplicationContext方法
public WebApplicationContext initWebApplicationContext(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");
if (logger.isInfoEnabled()) {
logger.info("Root WebApplicationContext: initialization started");
}
long startTime = System.currentTimeMillis();
try {
// Store context in local instance variable, to guarantee that
// it is available on ServletContext shutdown.
if (this.context == null) {
this.context = createWebApplicationContext(servletContext);
}
if (this.context instanceof ConfigurableWebApplicationContext) {
configureAndRefreshWebApplicationContext((ConfigurableWebApplicationContext)this.context, servletContext);
}
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);
ClassLoader ccl = Thread.currentThread().getContextClassLoader();
if (ccl == ContextLoader.class.getClassLoader()) {
currentContext = this.context;
}
else if (ccl != null) {
currentContextPerThread.put(ccl, this.context);
}
if (logger.isDebugEnabled()) {
logger.debug("Published root WebApplicationContext as ServletContext attribute with name [" +
WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE + "]");
}
if (logger.isInfoEnabled()) {
long elapsedTime = System.currentTimeMillis() - startTime;
logger.info("Root WebApplicationContext: initialization completed in " + elapsedTime + " ms");
}
return this.context;
}
catch (RuntimeException ex) {
logger.error("Context initialization failed", ex);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, ex);
throw ex;
}
catch (Error err) {
logger.error("Context initialization failed", err);
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, err);
throw err;
}
} 我们看前3行，可以根据字面意思猜到，容器不能重复定义或重复加载，而且，容器创建好之后会放在ServletContext这个上下文中，并且key是一个常量，等会看到最后我们来验证这个猜测。 紧接着一堆日志，开始时间，这些我们都不关注 真正的加载代码，从try开始
this.context = createWebApplicationContext(servletContext);这行字面意思是，创建一个web环境的容器，接着
if (this.context instanceof ConfigurableWebApplicationContext) {
configureAndRefreshWebApplicationContext((ConfigurableWebApplicationContext)this.context, servletContext);
} 表示创建的web环境的容器，必须是configurable的，可配置的，假如是可配置的，就执行配置+刷新操作。 至于为什么可配置，怎么配置，什么叫配置，我们待会应该能看懂。 再往下
servletContext.setAttribute(WebApplicationContext.ROOT_WEB_APPLICATION_CONTEXT_ATTRIBUTE, this.context);验证了我们之前的猜测，容器创建好之后放到servlet的上下文中 再后面的几行代码，我们就不用去关心了，至此，spring容器加载的最重要3步就是： 1.创建一个web applicationcontext, 2.配置并且刷新bean 3.把刷新好的context放到servlet上下文中去。 有了这三步，我们再去逐一的看看，他们分别是怎么实现的。后续还会遇到很多名词，在spring中，这些名词都有很深刻的含义，了解了这些名词才能深刻的了解spring,在(二)中我们去学习创建webApplicationContext.