Spring IoC容器构建过程分析（一）

注：本文分析的内容，针对的是Spring 2.5.6的版本

ApplicationContext是spring IoC容器的顶级接口，其类结构图如下：



从上面的类图中可以看出， ApplicationContext继承了ResourceLoader接口，便于获取外部资源；也间接继承了 BeanFactory接口，这样可以在Spring容器中创建Bean对象；同时也继承了ApplicationEventPublisher接口，用于发送一些事件消息。

通常我们使用这样的一行代码来创建并启动Spring容器：

ApplicationContext context = new ClassPathXmlApplicationContext("applicationContext.xml");

虽然是简单的一行代码，但背后却做了很多事情，先看一下ClassPathXmlApplicationContext的构造方法：

public ClassPathXmlApplicationContext(String configLocation) throws BeansException {
this(new String[] {configLocation}, true, null);
}
public ClassPathXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
throws BeansException {

super(parent);
setConfigLocations(configLocations);
if (refresh) {
refresh();
}
}

在该构造方法中，最后调用了AbstractApplicationContext.refresh()方法，该方法的实现代码如下：

public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
//1、 Prepare this context for refreshing.
prepareRefresh();

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

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

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

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

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

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

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

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

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

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

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

catch (BeansException ex) {
// Destroy already created singletons to avoid dangling resources.
beanFactory.destroySingletons();

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

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

这个方法非常关键，通过调用12个其他的方法，完成了整个IoC容器的构建。详细了解这个方法里面的每一行代码，基本上就掌握了Spring大部分的原理、功能和扩展点。下面分析每一个方法的所做的事情。

1、prepareRefresh()

该方法所做的事情相对比较简单：记录容器启动的时间，并设置容器处于活跃状态。

2、obtainFreshBeanFactory()

该方法的作用：创建BeanFactory实例，并解析Spring的xml配置文件。beanFactory的实现类是：ConfigurableListableBeanFactory。方法的实现如下：

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isInfoEnabled()) {
logger.info("Bean factory for application context [" + getId() + "]: " +
ObjectUtils.identityToString(beanFactory));
}
if (logger.isDebugEnabled()) {
logger.debug(beanFactory.getBeanDefinitionCount() + " beans defined in " + this);
}

return beanFactory;
}

该方法主要通过调用AbstractRefreshableApplicationContext.refreshBeanFactory()方法完成相关功能：

protected final void refreshBeanFactory() throws BeansException {
if (hasBeanFactory()) {
destroyBeans();
closeBeanFactory();
}
try {
DefaultListableBeanFactory beanFactory = createBeanFactory(); //1、创建beanFactory对象
customizeBeanFactory(beanFactory);
loadBeanDefinitions(beanFactory);//2、解析spring的xml配置文件，加载bean定义信息
synchronized (this.beanFactoryMonitor) {
this.beanFactory = beanFactory;
}
}
catch (IOException ex) {
throw new ApplicationContextException(
"I/O error parsing XML document for application context [" + getDisplayName() + "]", ex);
}
}

首先，通过createBeanFactory，创建了DefaultListableBeanFactory类型的beanFactory实例。分析一下BeanFactory的类图结构，如下：



创建了beanFactory之后，通过调用AbstractXmlApplicationContext.loadBeanDefinitions方法，加载spring的xml配置文件，把用户通过配置文件定义的bean，解析成容器中以特定的数据结构描述的bean定义。AbstractXmlApplicationContext.loadBeanDefinitions方法的实现如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws IOException {
// Create a new XmlBeanDefinitionReader for the given BeanFactory.
XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory); //1、创建BeanDefinitionReader对象

// Configure the bean definition reader with this context's
// resource loading environment.
beanDefinitionReader.setResourceLoader(this);
beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this)); // 2、设置xml文件schema的解析器，获取xsd文件。

// Allow a subclass to provide custom initialization of the reader,
// then proceed with actually loading the bean definitions.
initBeanDefinitionReader(beanDefinitionReader);
loadBeanDefinitions(beanDefinitionReader); //3、加载spring的xml配置文件，并解析。
}

第一步，创建bean的解析类：XmlBeanDefinitionReader，将bean的解析工作，托管给BeanDefinitionReader处理。BeanDefinitionReader的类结构图如下：



第二步，创建ResourceEntityResolver，设置用于XML配置文件验证的实体分解器。该类的resolveEntity方法，实现对文档验证实体的转换：根据spring定义bean的xml配置文件中的“http://www.springframework.org/schema/beans”形式的url，从spring.jar包中的META-INF\spring.schema文件中，找到对应的DTD或XSD文件在本地的路径。

第三步，调用initBeanDefinitionReader方法，该方法是一个空实现，允许子类去覆盖，可以用来设置自定义的EntityResolver实现类，以及NamespaceHandlerResolver实现类。这也是spring的一个扩展点。

第四步，调用loadBeanDefinitions方法，该方法最终调用XmlBeanDefinitionReader.loadBeanDefinitions(EncodedResource)方法实现xml配置文件的加载及bean的注册，方法的实现如下：

public int loadBeanDefinitions(EncodedResource encodedResource) throws BeanDefinitionStoreException {
Assert.notNull(encodedResource, "EncodedResource must not be null");
if (logger.isInfoEnabled()) {
logger.info("Loading XML bean definitions from " + encodedResource.getResource());
}

Set currentResources = (Set) this.resourcesCurrentlyBeingLoaded.get();
if (currentResources == null) {
currentResources = new HashSet(4);
this.resourcesCurrentlyBeingLoaded.set(currentResources);
}
if (!currentResources.add(encodedResource)) {
throw new BeanDefinitionStoreException(
"Detected recursive loading of " + encodedResource + " - check your import definitions!");
}
try {
InputStream inputStream = encodedResource.getResource().getInputStream();
try {
InputSource inputSource = new InputSource(inputStream);
if (encodedResource.getEncoding() != null) {
inputSource.setEncoding(encodedResource.getEncoding());
}
return doLoadBeanDefinitions(inputSource, encodedResource.getResource());
}
finally {
inputStream.close();
}
}
catch (IOException ex) {
throw new BeanDefinitionStoreException(
"IOException parsing XML document from " + encodedResource.getResource(), ex);
}
finally {
currentResources.remove(encodedResource);
if (currentResources.isEmpty()) {
this.resourcesCurrentlyBeingLoaded.set(null);
}
}
}
protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)
            throws BeanDefinitionStoreException {
        try {
            int validationMode = getValidationModeForResource(resource);
            Document doc = this.documentLoader.loadDocument(
                    inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());
            return registerBeanDefinitions(doc, resource);
        }
        catch (BeanDefinitionStoreException ex) {
            throw ex;
        }
        catch (SAXParseException ex) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                    "Line " + ex.getLineNumber() + " in XML document from " + resource + " is invalid", ex);
        }
        catch (SAXException ex) {
            throw new XmlBeanDefinitionStoreException(resource.getDescription(),
                    "XML document from " + resource + " is invalid", ex);
        }
        catch (ParserConfigurationException ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(),
                    "Parser configuration exception parsing XML from " + resource, ex);
        }
        catch (IOException ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(),
                    "IOException parsing XML document from " + resource, ex);
        }
        catch (Throwable ex) {
            throw new BeanDefinitionStoreException(resource.getDescription(),
                    "Unexpected exception parsing XML document from " + resource, ex);
        }
    }

在doLoadBeanDefinitions方法中，调用DefaultDocumentLoader.loadDocument方法，使用JAXP加载xml文档；然后调用registerBeanDefinitions方法，通过DefaultBeanDefinitionDocumentReader.registerBeanDefinitions，注册定义的bean。registerBeanDefinitions方法实现如下：

public void registerBeanDefinitions(Document doc, XmlReaderContext readerContext) {
this.readerContext = readerContext;

logger.debug("Loading bean definitions");
Element root = doc.getDocumentElement();

BeanDefinitionParserDelegate delegate = createHelper(readerContext, root);

preProcessXml(root);// 前置处理方法，是一个空实现
parseBeanDefinitions(root, delegate);<span><span class="comment">// 解析整个文档，循环处理各个子节点</span></span>
postProcessXml(root);// 后置处理方法，也是一个空实现
}
    protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
        if (delegate.isDefaultNamespace(root.getNamespaceURI())) {
            NodeList nl = root.getChildNodes();
            for (int i = 0; i < nl.getLength(); i++) {
                Node node = nl.item(i);
                if (node instanceof Element) {
                    Element ele = (Element) node;
                    String namespaceUri = ele.getNamespaceURI();
                    if (delegate.isDefaultNamespace(namespaceUri)) {//<span><span class="comment">如果是默认名字空间(beans),则直接使用解析</span><span></span></span>
                        parseDefaultElement(ele, delegate);
                    }
                    else {
                        delegate.parseCustomElement(ele);//对于非默认名字空间，如util，使用对应的NamespaceHandlerResolver实现类的parse方法进行解析。
                    }
                }
            }
        }
        else {
            delegate.parseCustomElement(root);
        }
    }

在bean的注册过程中，spring用到了NamespaceHandlerResolver接口，它是XML配置文件中的各种名字空间（如：context）定义的节点（如:context:property-placeholder）对应解析器的分解器。通过Namespace的SystemId（例如：http://www.springframework.org/schema/util），根据spring.jar的META-INF/spring.handlers映射文件，找到对应的解析器的类路径，然后使用该解析类，解析对应的节点。而对于无前缀的beans默认名字空间节点：采用BeanDefinitionParserDelegate完成节点的解析。

至此，完成了BeanFactory实例的创建和Spring的xml配置文件的解析。

3、prepareBeanFactory

创建好 BeanFactory 后，接着调用prepareBeanFactory方法，添加一些 Spring 本身需要的一些工具类：

protected void prepareBeanFactory(ConfigurableListableBeanFactory beanFactory) {
// Tell the internal bean factory to use the context's class loader.
beanFactory.setBeanClassLoader(getClassLoader());

// Populate the bean factory with context-specific resource editors.
beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this));

// Configure the bean factory with context callbacks.
beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

// BeanFactory interface not registered as resolvable type in a plain factory.
// MessageSource registered (and found for autowiring) as a bean.
beanFactory.registerResolvableDependency(BeanFactory.class, beanFactory);
beanFactory.registerResolvableDependency(ResourceLoader.class, this);
beanFactory.registerResolvableDependency(ApplicationEventPublisher.class, this);
beanFactory.registerResolvableDependency(ApplicationContext.class, this);

// Detect a LoadTimeWeaver and prepare for weaving, if found.
if (beanFactory.containsBean(LOAD_TIME_WEAVER_BEAN_NAME) && JdkVersion.isAtLeastJava15()) {
// Register the (JDK 1.5 specific) LoadTimeWeaverAwareProcessor.
try {
Class ltwapClass = ClassUtils.forName(
"org.springframework.context.weaving.LoadTimeWeaverAwareProcessor",
AbstractApplicationContext.class.getClassLoader());
BeanPostProcessor ltwap = (BeanPostProcessor) BeanUtils.instantiateClass(ltwapClass);
((BeanFactoryAware) ltwap).setBeanFactory(beanFactory);
beanFactory.addBeanPostProcessor(ltwap);
}
catch (ClassNotFoundException ex) {
throw new IllegalStateException("Spring's LoadTimeWeaverAwareProcessor class is not available");
}
// Set a temporary ClassLoader for type matching.
beanFactory.setTempClassLoader(new ContextTypeMatchClassLoader(beanFactory.getBeanClassLoader()));
}
}

该方法主要分成四步，如下：

第一步，设置类加载器；

第二步，设置属性编辑器注册类，用来注册相关的属性编辑器。ResourceEditorRegistrar类，注册的属性编辑器如下：

public void registerCustomEditors(PropertyEditorRegistry registry) {
ResourceEditor baseEditor = new ResourceEditor(this.resourceLoader);
registry.registerCustomEditor(Resource.class, baseEditor);
registry.registerCustomEditor(InputStream.class, new InputStreamEditor(baseEditor));
registry.registerCustomEditor(File.class, new FileEditor(baseEditor));
registry.registerCustomEditor(URL.class, new URLEditor(baseEditor));

ClassLoader classLoader = this.resourceLoader.getClassLoader();
registry.registerCustomEditor(Class.class, new ClassEditor(classLoader));
registry.registerCustomEditor(URI.class, new URIEditor(classLoader));

if (this.resourceLoader instanceof ResourcePatternResolver) {
registry.registerCustomEditor(Resource[].class,
new ResourceArrayPropertyEditor((ResourcePatternResolver) this.resourceLoader));
}
}

例如InputStreamEditor这个属性编辑器，可以将spring配置文件中，用字符串表示的文件路径，转成Resource资源类，注入到bean的对应属性中。同样，我们可以通过自定义的属性编辑器，将spring配置文件中以某种格式定义的字符串，转成对应的Java对象。spring的属性编辑器类图结构如下：



第三步：设置内置的BeanPostProcessor：ApplicationContextAwareProcessor。该BeanPostProcessor的作用是，为实现特殊接口的bean，注入容器类（例如为实现ApplicationContextAware接口的类，注入ApplicationContext对象实例），如下：

public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
if (bean instanceof ResourceLoaderAware) {
((ResourceLoaderAware) bean).setResourceLoader(this.applicationContext);
}
if (bean instanceof ApplicationEventPublisherAware) {
((ApplicationEventPublisherAware) bean).setApplicationEventPublisher(this.applicationContext);
}
if (bean instanceof MessageSourceAware) {
((MessageSourceAware) bean).setMessageSource(this.applicationContext);
}
if (bean instanceof ApplicationContextAware) {
((ApplicationContextAware) bean).setApplicationContext(this.applicationContext);
}
return bean;
}

第四步：调用ignoreDependencyInterface，设置忽略自动注入的接口（因为这些接口已经通过ApplicationContextAwareProcessor注入了）。

第五步：调用registerResolvableDependency，注入特殊的对象。

4、postProcessBeanFactory

该方法是spring的一个扩展点之一，是一个空方法，留给子类去扩展。子类可以重写该方法，对已经构建的 BeanFactory 的配置根据需要进行修改。例如调用beanFactory.registerResolvableDependency，注入特殊的类。