Spring BeanFactory、ApplicationContext层次结构和BeanDefinition解析过程

先说层次架构

// 水桶和上下文类层次概要（还有如何打水）


// 当你在使用FileSystemXmlApplicationContext之类的类时，你会感觉里面的方法调用错综复杂，层次很多。
// 那么，我们先从主要类的作用和层次说起，让我们有个大体的概念和印象，便于后面的分析。

class Waterpot {
	// 水桶：
	// 顺序基本是按照继承的先后顺序

	// ***************************基本接口定义分支***************************

	// ==================最基本的两个接口=============================

	// 接口：最基本的，就是包括一些bean的获取，bean类型判断，别名数组获取等
	// *org.springframework.beans.factory.BeanFactory

	// 接口：和他的名字Hierarchical一样，分层用的，获取父的beanFactory，和判断beanfactory是否存在指定的bean
	// *org.springframework.beans.factory.HierarchicalBeanFactory

	// ===========ConfigurableBeanFactory：bean factory的主要相关资源管理========

	// 接口：HierarchicalBeanFactory的其中一种直接父接口（还包括ApplicationContext，也是HierarchicalBeanFactory的一种直接父接口）
	// 他的方法定义就比较多，包括（应该主要是bean factory操作需要的一些场景资源和环境指定等）：
	// 设置beanfactory用的双亲（parentBeanFactory）、ClassLoader赋值、tempClassLoader赋值、Set
	// whether to cache bean metadata such as given bean definitions (in
	// merged fashion) and resolved bean
	// classes.、TypeConverter赋值、添加BeanPostProcessor等
	// *org.springframework.beans.factory.config.ConfigurableBeanFactory

	// ===ConfigurableListableBeanFactory：对configurable、list、autowire的继承包含（主要就是对环境定义的深入整合）====

	// 接口：前面做到了bean factory对bean的单个操作，这个主要是返回和操作多个返回结果
	// *org.springframework.beans.factory.ListableBeanFactory

	// 接口：自动IoC注解的相关操作
	// *org.springframework.beans.factory.config.AutowireCapableBeanFactory

	// 接口：主要是对前面主要接口的总结，并提供了preInstantiateSingletons方法。
	// 主要还包括了，对自动装配的额外定义：忽略类型、忽略接口、指定绑定等
	// *org.springframework.beans.factory.config.ConfigurableListableBeanFactory

	// ***************************额外特殊接口和实现分支***************************

	// ====================各种bean注册==============================
	// 接口：别名操作的定义
	// *org.springframework.core.AliasRegistry

	// 实现：对别名的管理（主要是维护了别名的map）
	// *org.springframework.core.SimpleAliasRegistry

	// 接口：单例方式bean的管理定义，包括注册获取和判断等
	// *org.springframework.beans.factory.config.SingletonBeanRegistry

	// 实现：继承了别名管理实现，并实现了单例注册（自己主要实现了单例注册接口，并管理着各种类型数据的map集合）
	// *org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

	// 接口：主要是对BeanDefinition的注册相关定义（BeanDefinition是bean的第二步原始数据--第一步dom解析数据）
	// *org.springframework.beans.factory.support.BeanDefinitionRegistry

	// ***************************各种接口的整合实现***************************

	// =========================对各种原始数据的操作==================================

	// 实现：对单例的获取和维护，对DefaultSingletonBeanRegistry进行了封装
	// *org.springframework.beans.factory.support.FactoryBeanRegistrySupport

	// 实现：实现了ConfigurableBeanFactory，也就是对资源管理的实现。且对FactoryBeanRegistrySupport继承，做了对bean获取的更进一步封装。
	// 这里已经不局限于单例的获取，还包括非单例，从父工厂获取判断等
	// *org.springframework.beans.factory.support.AbstractBeanFactory

	// 实现：对AutowireCapableBeanFactory接口的实现，并继承了AbstractBeanFactory
	// *org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

	// 实现：我们主要的基本容器实现。（再往下走会有各种applicationContext），但是原始数据BeanDefinition的水桶和单例的水桶主要就是DefaultListableBeanFactory
	// *org.springframework.beans.factory.support.DefaultListableBeanFactory
}

class Context {
	// 上下文

	// =========================最底层上下文：ApplicationContext==================================

	// 接口：环境Environment的获取
	// *org.springframework.core.env.EnvironmentCapable

	// 接口：参数化和国际化等消息的支持下解决的消息，策略接口。
	// *org.springframework.context.MessageSource

	// 接口：接收ApplicationEvent
	// *org.springframework.context.ApplicationEventPublisher

	// 接口：获取资源
	// *org.springframework.core.io.support.ResourcePatternResolver

	// 接口：上下文最基础的接口，除继承了上面的接口外，还继承了容器的ListableBeanFactory,
	// HierarchicalBeanFactory的两个接口
	// *org.springframework.context.ApplicationContext

	// ==============================ConfigurableApplicationContext=======================================
	// 接口：The typical use case for this is to control asynchronous processing.
	// 很多执行控制接口都继承自本接口
	// *org.springframework.context.Lifecycle

	// 接口：从ApplicationContext继承了上下文的基本功能外，又定义了大量的环境配置接口(包括：setEnvironment、addBeanFactoryPostProcessor、addApplicationListener、registerShutdownHook)。还有主要的入口refresh()
	// *org.springframework.context.ConfigurableApplicationContext

	// ==============================上线文基本方法实现：AbstractApplicationContext=======================================

	// 接口：销毁动作，销毁单例类
	// *org.springframework.beans.factory.DisposableBean

	// 接口：加载资源的策略接口
	// *org.springframework.core.io.ResourceLoader

	// 实现：默认的资源加载
	// *org.springframework.core.io.DefaultResourceLoader

	// 实现：上线文基本方法实现（包括加载和刷新的入口、初始化容器开始时间等、刷新重建BeanFactory入口（具体的refreshBeanFactory留由子类完成）、准备bean
	// factory（主要声明了classLoader、添加BeanPostProcessor
	// 、自动装配忽略接口、自动装配类型匹配指定、注册各种单例等）、调用BeanFactory的后处理器，这些后处理器是在Bean定义中向容器注册的
	// 、对上下文中的消息源进行初始化、初始化上下文中的事件机制、检查监听bean并且将这些bean向容器注册、实例化所有的(non-lazy-init)单例、发布容器事件，结束Refresh过程）
	// *org.springframework.context.support.AbstractApplicationContext

	// ==============================刷新和重建BeanFactory：AbstractRefreshableApplicationContext==================
	// 实现：比较重要的实现方法refreshBeanFactory，刷新和重建BeanFactory
	// *org.springframework.context.support.AbstractRefreshableApplicationContext

	// ==============================AbstractRefreshableConfigApplicationContext==============================

	// 接口：bean factory的名称
	// *org.springframework.beans.factory.BeanNameAware

	// *org.springframework.beans.factory.InitializingBean

	// 实现：Config的设置
	// *org.springframework.context.support.AbstractRefreshableConfigApplicationContext

	// ==============================AbstractXmlApplicationContext==============================

	// 实现：主要是loadBeanDefinitions的实现，内部指定XmlBeanDefinitionReader方式读取
	// *org.springframework.context.support.AbstractXmlApplicationContext

	// ClassPathXmlApplicationContext、FileSystemXmlApplicationContext
	// 启动入口和“个性”资源加载
}

// =====================================================解析相关============================================


// 解析第一步：读取资源

class Reader {

	// ===================================资源读取：XmlBeanDefinitionReader===================================
	// 分析下XmlBeanDefinitionReader组织层次

	// 接口：读取解析的基础接口，主要就是四个loadBeanDefinitions定义，负责读取的定义，但是不包含读取后的注册定义等。
	// *org.springframework.beans.factory.support.BeanDefinitionReader

	// 实现：简单封装实现了BeanDefinitionReader（String类型资源加载、Resource多参数遍历、各种资源的获取和赋值定义）和EnvironmentCapable两个接口。
	// （具体如何读取交给了子类包含Resource参数的接口定义中去完成）
	// *org.springframework.beans.factory.support.AbstractBeanDefinitionReader

	// 实现：XML格式文件读取，最终实现提供类。具体指定了读取规则，和注册规则。（具体的读取和注册还要往下走）
	// *org.springframework.beans.factory.xml.XmlBeanDefinitionReader
}

// 解析第二步：Document读取
// DefaultDocumentLoader，dom解析就不说了，和我们平时做dom解析应该没太大区别，我们平时可以借助很多不错的第三方框架。


// 解析第二步半：BeanDefinitionDocumentReader（资源整合，或者说功能抽取）

class MyBeanDefinitionDocumentReader {
	// ===================================通过Reader返回的Document获取注册匹配的BeanDefinition：BeanDefinitionDocumentReader=========================

	// 接口：SPI for parsing an XML document that contains Spring bean definitions.
	// Used by XmlBeanDefinitionReader for actually parsing a DOM document.
	// *org.springframework.beans.factory.xml.BeanDefinitionDocumentReader

	// 实现：供Reader调用。结合了DocumentLoader读取的Document和XmlReaderContext。
	// *org.springframework.beans.factory.xml.DefaultBeanDefinitionDocumentReader
}

// 解析第三步：通过Document解析成BeanDefinition

class MyBeanDefinitionParserDelegate {
	// 工具类：根绝规则做的各种解析方法
	// *org.springframework.beans.factory.xml.BeanDefinitionParserDelegate
	// 然后就是通过工具类，帮助封装注册进DefaultListableBeanFactory
}

再说执行过程

==============================FileSystemXmlApplicationContext==============================


*org.springframework.context.support.FileSystemXmlApplicationContext


比较常用的ApplicationContext有多种，我们选择一种FileSystemXmlApplicationContext进行入口分析。（几种ApplicationContext实现的区分基本在于资源获取方式和解析方式不同）


创建：

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)
		throws BeansException {
	
	super(parent);
	//设置资源路径，由子类AbstractRefreshableConfigApplicationContext完成
	setConfigLocations(configLocations);
	//Load or refresh the persistent representation of the configuration, which might an XML file, properties file, or relational database schema. 
	//进行了加载资源，销毁以前容器，创建容器，资源解析，Instantiate all remaining (non-lazy-init) singletons，
	if (refresh) {
		refresh();
	}
}

*1：refresh():(由最基础实现类AbstractApplicationContext提供)

public void refresh() throws BeansException, IllegalStateException {  
    synchronized (this.startupShutdownMonitor) {  
        // Prepare this context for refreshing.  
        prepareRefresh();  
  
        // Tell the subclass to refresh the internal bean factory.  
        //这里是在子类中启动refreshBeanFactory()的地方  
        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.  
            //设置BeanFactory的后置处理  
            postProcessBeanFactory(beanFactory);  
  
            // Invoke factory processors registered as beans in the context.  
            //调用BeanFactory的后处理器，这些后处理器是在Bean定义中向容器注册的  
            invokeBeanFactoryPostProcessors(beanFactory);  
  
            // Register bean processors that intercept bean creation.  
            //注册Bean的后处理器，在bean的创建过程中被调用  
            registerBeanPostProcessors(beanFactory);  
  
            // Initialize message source for this context.  
            //对上下文中的消息源进行初始化  
            initMessageSource();  
  
            // Initialize event multicaster for this context.  
            //初始化上下文中的事件机制  
            initApplicationEventMulticaster();  
  
            // Initialize other special beans in specific context subclasses.  
            //初始化其他的特殊bean  
            onRefresh();  
  
            // Check for listener beans and register them.  
            //检查监听bean并且将这些bean向容器注册  
            registerListeners();  
  
            // Instantiate all remaining (non-lazy-init) singletons.  
            //实例化所有的(non-lazy-init)单例  
            finishBeanFactoryInitialization(beanFactory);  
  
            // Last step: publish corresponding event.  
            //发布容器事件，结束Refresh过程  
            finishRefresh();  
        }  
  
        catch (BeansException ex) {  
            // Destroy already created singletons to avoid dangling resources.  
            destroyBeans();  
  
            // Reset 'active' flag.  
            cancelRefresh(ex);  
  
            // Propagate exception to caller.  
            throw ex;  
        }  
    }  
}  

**1.1:容器获取、数据解析入口：obtainFreshBeanFactory()具体实现refreshBeanFactory()留给子类实现
（因为AbstractApplicationContext就是具体的通用的资源准备，具体的计息读取规则应该由各分支子类实现）：
AbstractRefreshableApplicationContext---refreshBeanFactory

@Override  
protected final void refreshBeanFactory() throws BeansException {  
    //这里判断，如果已经建立BeanFactory，则销毁并关闭该BeanFactory  
    if (hasBeanFactory()) {  
        destroyBeans();  
        closeBeanFactory();  
    }  
    //这里是创建并设置持有的DefaultListableBeanFactory的地方同时调用loadBeanDefinitions(beanFactory)再载入BeanDefinition的信息。  
    try {  
        DefaultListableBeanFactory beanFactory = createBeanFactory();  
        beanFactory.setSerializationId(getId());  
        //BeanFactoryAware等资源的配置
        customizeBeanFactory(beanFactory);
        loadBeanDefinitions(beanFactory);  
        synchronized (this.beanFactoryMonitor) {  
            this.beanFactory = beanFactory;  
        }  
    }  
    catch (IOException ex) {  
        throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);  
    }  
}  

***1.1.1:需要注意的是我们以后要用的BeanFactory--DefaultListableBeanFactory：

protected DefaultListableBeanFactory createBeanFactory() {
（也就是水桶，具体的水桶并不由ApplicationContext提供，而是由BeanFactory分支实现提供）
	return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}

****1.1.1.1:创建之后会赋值给AbstractRefreshableApplicationContext的变量：

/** Bean factory for this context */
private DefaultListableBeanFactory beanFactory;

****1.1.1.2:并实现了AbstractApplicationContext声明的获取方法：

@Override
public final ConfigurableListableBeanFactory getBeanFactory() {
	synchronized (this.beanFactoryMonitor) {
		if (this.beanFactory == null) {
			throw new IllegalStateException("BeanFactory not initialized or already closed - " +
					"call 'refresh' before accessing beans via the ApplicationContext");
		}
		return this.beanFactory;
	}
}

****1.1.1.3:同步的锁：

/** Synchronization monitor for the internal BeanFactory */
private final Object beanFactoryMonitor = new Object();

***1.1.2加载解析Bean的原始封装数据：BeanDefinitions -- loadBeanDefinitions(beanFactory)
这里主要指定了读取工具类（XmlBeanDefinitionReader），和执行解析入口。因为，我们的配置可以是多种形式的，这里需要具体资源形式的子类（AbstractXmlApplicationContext）去实现。
AbstractXmlApplicationContext：

@Override
protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws BeansException, IOException {
	// Create a new XmlBeanDefinitionReader for the given BeanFactory.
	XmlBeanDefinitionReader beanDefinitionReader = new XmlBeanDefinitionReader(beanFactory);

	// Configure the bean definition reader with this context's
	// resource loading environment.
	beanDefinitionReader.setEnvironment(this.getEnvironment());
	beanDefinitionReader.setResourceLoader(this);
	beanDefinitionReader.setEntityResolver(new ResourceEntityResolver(this));

	// Allow a subclass to provide custom initialization of the reader,
	// then proceed with actually loading the bean definitions.
	initBeanDefinitionReader(beanDefinitionReader);
	loadBeanDefinitions(beanDefinitionReader);
}

****1.1.2.1这里的application environment的值是由最开始FileSystemXmlApplicationContext构造器中super(parent)，一路调用父类构造器，最终在
AbstractApplicationContext中实现：

public AbstractApplicationContext(ApplicationContext parent) {
	this.parent = parent;
	this.resourcePatternResolver = getResourcePatternResolver();
	this.environment = this.createEnvironment();
}

/**
 * Create and return a new {@link StandardEnvironment}.
 * <p>Subclasses may override this method in order to supply
 * a custom {@link ConfigurableEnvironment} implementation.
 */
protected ConfigurableEnvironment createEnvironment() {
	return new StandardEnvironment();
}

****1.1.2.2ResourceLoader是通过继承获得（AbstractApplicationContext extends DefaultResourceLoader）

****1.1.2.3EntityResolver：Allow the application to resolve external entities. 
通过下面两个常量，我们可以猜是对格式规范的读取

public class DelegatingEntityResolver implements EntityResolver {

	/** Suffix for DTD files */
	public static final String DTD_SUFFIX = ".dtd";

	/** Suffix for schema definition files */
	public static final String XSD_SUFFIX = ".xsd";
	
	public DelegatingEntityResolver(ClassLoader classLoader) {
		this.dtdResolver = new BeansDtdResolver();
		this.schemaResolver = new PluggableSchemaResolver(classLoader);
	}	
...
}	

****1.1.2.4为XmlBeanDefinitionReader准备好各种所需的资源后，就开始真正解析了：
这里是对我们前面赋值的资源便利读取：

protected void loadBeanDefinitions(XmlBeanDefinitionReader reader) throws BeansException, IOException {
	Resource[] configResources = getConfigResources();
	if (configResources != null) {
		reader.loadBeanDefinitions(configResources);
	}
	String[] configLocations = getConfigLocations();
	if (configLocations != null) {
		reader.loadBeanDefinitions(configLocations);
	}
}

*********1.1.2.4.1目前主要是下面那个String[]数组。
赋值的地方在AbstractRefreshableConfigApplicationContext（这也是我们为什么在AbstractRefreshableApplicationContext的基础上有多了个AbstractRefreshableConfigApplicationContext原因，单独为资源赋值形式抽取封装）：

public void setConfigLocations(String[] locations) {
	if (locations != null) {
		Assert.noNullElements(locations, "Config locations must not be null");
		this.configLocations = new String[locations.length];
		for (int i = 0; i < locations.length; i++) {
			this.configLocations[i] = resolvePath(locations[i]).trim();
		}
	}
	else {
		this.configLocations = null;
	}
}

此方法调用是在我们上面的FileSystemXmlApplicationContext构造器中。
（所以到这里，可以看到，我们上面出现了很多很多不同地方，不同形式的赋值，这些赋值在以后的解析等过程中进行了各自的作用）




到这里我们ApplicationContext关于解析的工作告一段落，然后就是XmlBeanDefinitionReader如何具体解析：
上面准备了和计算出了很多环境条件，然后接下来就是具体的如何通过Xml解析成最初的Bean类型BeanDefinition


===================================解析===================================
1、开始是一连串的AbstractBeanDefinitionReader处理，做了他可以做的事情之后，具体的又交给了父类，也就是上面指定的XmlBeanDefinitionReader
2、XmlBeanDefinitionReader也有做了一大串的判断，在doLoadBeanDefinitions方法中调用了DefaultDocumentLoader的loadDocument获取了Document
3、然后又把一些资源和Document传给了DefaultBeanDefinitionDocumentReader，DefaultBeanDefinitionDocumentReader又做了一些介于Reader和纯Document解析之间的一些工作，包括各种解析判断走向什么的。
4、然后又通过BeanDefinitionParserDelegate，BeanDefinitionParserDelegate只接收了Element，根绝我们的规则解析出了BeanDefinitionHolder
5、最后我们又通过BeanDefinitionReaderUtils，把我们解析出的BeanDefinition注解进我们的容器DefaultListableBeanFactory。