Spring核心IOC容器实现分析

在Spring IOC容器的设计中，我们可以看到两个主要的容器系列，一个是实现BeanFactory接口的简单容器系列，这系列容器只实现了容器的最基本功能；另一个是ApplicationContext应用上下文，它作为容器的高级形态而存在。应用上下文在简单容器的基础上，增加了许多面向框架的特性，同时对应用环境做了许多适配。

单纯的这样说可能感觉比较抽象下面具体说一下，下面我们直接从实际代码中分析Spring IOC容器加载过程：

web.xml在Java Web中的作用类似于引导PC的引导程序，在应用启动的最开始进行加载，也是我们通常分析一个Web程序的入口

在下面的web.xml配置文件中主要做了两件事：

1、指定了spring的配置文件的位置，为下文Spring IOC容器初始化做准备，配置在这里，在Web启动的时候会加载到ServletContext上下文中

2、配置了ContextLoaderListener，主要监听什么呢？下文会做进一步解释

<?xml version="1.0" encoding="utf-8"?>
<web-app>
<!-- spring配置文件存放的位置 -->
<context-param>
<param-name>contextConfigLocation</param-name>
<param-value>classpath:spring/spring.xml</param-value>
</context-param>

<!-- 配置spring启动listener入口 -->
<listener>
<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
</listener>
</web-app>

下面我们打开ContextLoaderListener类看一下该类具体做了些什么

在这里我们可以看到ContextLoaderListener实现了ServletContextListener接口，该接口是Servlet基础接口，主要监听的就是Tomcat启动和销毁事件，实现的方法主要有两个:

1、ContextInitialized，该方法的入参或是监听的Event是ServletContextEvent事件，也就是Tomcat启动加载完web.xml会产生的是事件，ServletContextEvent持有了从web.xml加载的初始化配置的ServletContext上下文

2、ContextDestroyed，该方法的入参或是监听的Event是ServletContextEvent事件，在Tomcat关闭的时候执行该方法

由此，我们可以知道当Tomcat启动的时候加载web.xml文件的时候，会触发一个ServletContextEvent事件，进而会触发ContextLoaderListener类执行ContextInitialized方法，从源码中我们可以看出该方法中执行了initWebApplicationContext，入参为ServletContext。从这里开始，就开始进入ContextLoaderListener的父类ContextLoader(听名字就知道这才是真正初始化容器)，执行ContextLoader的initWebApplicationContext，下面我们进入ContextLoader中继续查看初始化流程。

public class ContextLoaderListener extends ContextLoader implements ServletContextListener {

public ContextLoaderListener() {
}
public ContextLoaderListener(WebApplicationContext context) {
super(context);
}
/**
* Initialize the root web application context.
*/
@Override
public void contextInitialized(ServletContextEvent event) {
initWebApplicationContext(event.getServletContext());
}
/**
* Close the root web application context.
*/
@Override
public void contextDestroyed(ServletContextEvent event) {
closeWebApplicationContext(event.getServletContext());
ContextCleanupListener.cleanupAttributes(event.getServletContext());
}
}

由上文可知，ContextLoader才是在为IOC容器初始化干活的人，在该类中执行了initWebApplicationContext()，该方法中首先查询了当前应用是否存在根容器，如果存在则报异常，否则的话则创建根容器，创建根容器的时候调用了一个方法determineContextClass，该方法主要就是为了确定该应用使用的是Spring IOC众多容器中的哪个容器，如果我们需要指定容器，那么可以在web.xml应用引导程序中配置初始化参数，指定具体的容器。当然如果不配置，该方法会去寻找默认的配置ContextLoader.properties，这里面指定了默认的容器类型是xmlWebApplicationContext。

容器创建完成之后，下面会执行一个重要的方法就是configureAndRefreshWebApplicationContext，在执行该方法时会将servletContext中获取的spring.xml的资源位置配置在已经创建的xmlWebApplicationContext中，然后执行容器的refresh()方法，这里才开始进入容器的初始化过程。

public class ContextLoader {

private static final String DEFAULT_STRATEGIES_PATH = "ContextLoader.properties";
private static final Properties defaultStrategies;
static {
try {
ClassPathResource resource = new ClassPathResource(DEFAULT_STRATEGIES_PATH, ContextLoader.class);
defaultStrategies = PropertiesLoaderUtils.loadProperties(resource);
}
catch (IOException ex) {
throw new IllegalStateException("Could not load 'ContextLoader.properties': " + ex.getMessage());
}
}

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) {
ConfigurableWebApplicationContext cwac = (ConfigurableWebApplicationContext) this.context;
if (!cwac.isActive()) {
// The context has not yet been refreshed -> provide services such as
// setting the parent context, setting the application context id, etc
if (cwac.getParent() == null) {
// The context instance was injected without an explicit parent ->
// determine parent for root web application context, if any.
ApplicationContext parent = loadParentContext(servletContext);
cwac.setParent(parent);
}
configureAndRefreshWebApplicationContext(cwac, 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;
}
}

protected void configureAndRefreshWebApplicationContext(ConfigurableWebApplicationContext wac, ServletContext sc) {
if (ObjectUtils.identityToString(wac).equals(wac.getId())) {
// The application context id is still set to its original default value
// -> assign a more useful id based on available information
String idParam = sc.getInitParameter(CONTEXT_ID_PARAM);
if (idParam != null) {
wac.setId(idParam);
}
else {
// Generate default id...
wac.setId(ConfigurableWebApplicationContext.APPLICATION_CONTEXT_ID_PREFIX +
ObjectUtils.getDisplayString(sc.getContextPath()));
}
}

wac.setServletContext(sc);
String configLocationParam = sc.getInitParameter(CONFIG_LOCATION_PARAM);
if (configLocationParam != null) {
wac.setConfigLocation(configLocationParam);
}

// The wac environment's #initPropertySources will be called in any case when the context
// is refreshed; do it eagerly here to ensure servlet property sources are in place for
// use in any post-processing or initialization that occurs below prior to #refresh
ConfigurableEnvironment env = wac.getEnvironment();
if (env instanceof ConfigurableWebEnvironment) {
((ConfigurableWebEnvironment) env).initPropertySources(sc, null);
}

customizeContext(sc, wac);
wac.refresh();
}

protected Class<?> determineContextClass(ServletContext servletContext) {
String contextClassName = servletContext.getInitParameter(CONTEXT_CLASS_PARAM);
if (contextClassName != null) {
try {
return ClassUtils.forName(contextClassName, ClassUtils.getDefaultClassLoader());
}
catch (ClassNotFoundException ex) {
throw new ApplicationContextException(
"Failed to load custom context class [" + contextClassName + "]", ex);
}
}
else {
contextClassName = defaultStrategies.getProperty(WebApplicationContext.class.getName());
try {
return ClassUtils.forName(contextClassName, ContextLoader.class.getClassLoader());
}
catch (ClassNotFoundException ex) {
throw new ApplicationContextException(
"Failed to load default context class [" + contextClassName + "]", ex);
}
}
}

/**
* Return the {@link ApplicationContextInitializer} implementation classes to use
* if any have been specified by {@link #CONTEXT_INITIALIZER_CLASSES_PARAM}.
* @param servletContext current servlet context
* @see #CONTEXT_INITIALIZER_CLASSES_PARAM
*/
protected List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>
determineContextInitializerClasses(ServletContext servletContext) {

List<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>> classes =
new ArrayList<Class<ApplicationContextInitializer<ConfigurableApplicationContext>>>();

String globalClassNames = servletContext.getInitParameter(GLOBAL_INITIALIZER_CLASSES_PARAM);
if (globalClassNames != null) {
for (String className : StringUtils.tokenizeToStringArray(globalClassNames, INIT_PARAM_DELIMITERS)) {
classes.add(loadInitializerClass(className));
}
}

String localClassNames = servletContext.getInitParameter(CONTEXT_INITIALIZER_CLASSES_PARAM);
if (localClassNames != null) {
for (String className : StringUtils.tokenizeToStringArray(localClassNames, INIT_PARAM_DELIMITERS)) {
classes.add(loadInitializerClass(className));
}
}

return classes;
}

}

这时候我们开始进入xmlWebApplicationContext的refresh方法，因为xmlWebApplicationContext间接继承了AbstractApplicationContext，所以xmlWebApplicationContext中可以执行refresh方法，而这里才是真正从加载spring.xml文件，并解析bean的开始，注册bean的开始。

下面我着重讲解下具体的执行流程(下面非重要代码已经省略)：

1、prepareRefresh方法中主要记录了一些容器初始化时间等内容

2、obtainFreshBeanFactory，在这一步主要执行的是loadBeanDefinition。通过获取spring.xml配置文件的位置，然后使用BeanDefinitionReader进行加载，并通过SAX将spring.xml解析Document，并根据spring.xml中配置的bean解析出BeanDefinition，最终存在BeanDefinitionFactory中的一个Map中，HashMap的key是bean的id，value是类的全路径。

3、prepareBeanFactory做一些BeanFactory初始化的准备工作

4、finishBeanFactoryInitialization（预实例化bean），如果没有配置lazy-init，则spring bean的依赖注入将放在getBean的时候进行依赖注入，如果配置了lazy-init将在该方法内就完成依赖的注入过程

public abstract class AbstractApplicationContext extends DefaultResourceLoader
implements ConfigurableApplicationContext, DisposableBean {@Override
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
// Prepare this context for refreshing.
prepareRefresh();

// Tell the subclass to refresh the internal bean factory.
ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

// Prepare the bean factory for use in this context.
prepareBeanFactory(beanFactory);

try {
// Allows post-processing of the bean factory in context subclasses.
postProcessBeanFactory(beanFactory);

// Invoke factory processors registered as beans in the context.
invokeBeanFactoryPostProcessors(beanFactory);

// Register bean processors that intercept bean creation.
registerBeanPostProcessors(beanFactory);

// Initialize message source for this context.
initMessageSource();

// Initialize event multicaster for this context.
initApplicationEventMulticaster();

// Initialize other special beans in specific context subclasses.
onRefresh();

// Check for listener beans and register them.
registerListeners();

// Instantiate all remaining (non-lazy-init) singletons.
finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.
finishRefresh();
}

catch (BeansException ex) {
logger.warn("Exception encountered during context initialization - cancelling refresh attempt", ex);

// Destroy already created singletons to avoid dangling resources.
destroyBeans();

// Reset 'active' flag.
cancelRefresh(ex);

// Propagate exception to caller.
throw ex;
}
}
}

}