Spring2.0中的IOC随笔(二)之配置文件解析

        在Web应用中，默认的bean配置文件为WEB-INF目录下面的applicationContext.xml文件(当然你也可以指定其他路径或文件名)，而对配置文件的加载是在XmlWebApplicationContext中实现的，该bean容器将具体的加载工作全权委托给了一个名为XmlBeanDefinitionReader的辅助类，同时创建了一个新的Bean工厂DefaultListableBeanFactory作为参数传给了其构造函数，供其调用该Bean工厂中提供的服务，代码如下：

protected void loadBeanDefinitions(DefaultListableBeanFactory beanFactory) throws 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.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);
	}

这个XML配置文件读取类采用了Spring的惯用设计，接口+抽象类+具体实现类的方式，其继承结构为如下图所示：

        插句题外话，如果让你来设计一个模块的体系结构，你会觉得哪部分最困难呢，我想大概应该是中间的那层抽象类了，最上面的接口固然很重要，因为他决定了整个模块对外提供的服务接口，并决定了内部实现的体系结构，但是中间的抽象层更加依赖于设计者高度的抽象能力以及丰富的设计经验，而最底层的具体实现类则是相对比较容易实现的部分，即使出现了问题，也不至于对整个设计产生致命的影响。

        言归正传，XmlBeanDefinitionReader在被构造完毕并进行了一些初始化的工作后，XmlWebApplicationContext调用了其父类AbstractBeanDefinitionReader的方法loadBeanDefinitions来进行某个配置文件的加载工作，最终实际执行的方法仍为XmlBeanDefinitionReader中的registerBeanDefinitions，具体代码如下所示：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {
		// Support old XmlBeanDefinitionParser SPI for backwards-compatibility.
		if (this.parserClass != null) {
			XmlBeanDefinitionParser parser =
					(XmlBeanDefinitionParser) BeanUtils.instantiateClass(this.parserClass);
			return parser.registerBeanDefinitions(this, doc, resource);
		}
		// Read document based on new BeanDefinitionDocumentReader SPI.
		BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();
		int countBefore = getBeanFactory().getBeanDefinitionCount();
		documentReader.registerBeanDefinitions(doc, createReaderContext(resource));
		return getBeanFactory().getBeanDefinitionCount() - countBefore;
	}

而其中又将对某个Document文档的解析委托给了类DefaultBeanDefinitionDocumentReader的方法registerBeanDefinitions，并传进了Document和XmlReaderContext两个参数，第一个是被解析的配置文件，第二个参数是解析上下文，其中包含了包括XmlBeanDefinitionReader本身在内的一系列引用，方便和他们进行通信。
        接着来看DefaultBeanDefinitionDocumentReader是如何解析给定的Document的。对于配置文件中配置的每一个Bean，DefaultBeanDefinitionDocumentReader又将具体的解析工作交给了名为BeanDefinitionParserDelegate的类来处理，具体代码如下：

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);
		postProcessXml(root);
	}

紧接着BeanDefinitionParserDelegate会判断该Bean的Id是否重复，如果重复，则抛出异常，如果是Id唯一，就将真正启动Bean的解析过程，具体函数为：

public AbstractBeanDefinition parseBeanDefinitionElement(
			Element ele, String beanName, BeanDefinition containingBean) {

		String className = null;
		if (ele.hasAttribute(CLASS_ATTRIBUTE)) {
			className = ele.getAttribute(CLASS_ATTRIBUTE);
		}
		String parent = null;
		if (ele.hasAttribute(PARENT_ATTRIBUTE)) {
			parent = ele.getAttribute(PARENT_ATTRIBUTE);
		}

		try {
			this.parseState.push(new BeanEntry(beanName));

			AbstractBeanDefinition bd = BeanDefinitionReaderUtils.createBeanDefinition(
					parent, className, getReaderContext().getReader().getBeanClassLoader());

			if (ele.hasAttribute(SCOPE_ATTRIBUTE)) {
				// Spring 2.0 "scope" attribute
				bd.setScope(ele.getAttribute(SCOPE_ATTRIBUTE));
				if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
					error("Specify either 'scope' or 'singleton', not both", ele);
				}
			}
			else if (ele.hasAttribute(SINGLETON_ATTRIBUTE)) {
				// Spring 1.x "singleton" attribute
				bd.setSingleton(TRUE_VALUE.equals(ele.getAttribute(SINGLETON_ATTRIBUTE)));
			}
			else if (containingBean != null) {
				// Take default from containing bean in case of an inner bean definition.
				bd.setSingleton(containingBean.isSingleton());
			}

			if (ele.hasAttribute(ABSTRACT_ATTRIBUTE)) {
				bd.setAbstract(TRUE_VALUE.equals(ele.getAttribute(ABSTRACT_ATTRIBUTE)));
			}

			String lazyInit = ele.getAttribute(LAZY_INIT_ATTRIBUTE);
			if (DEFAULT_VALUE.equals(lazyInit) && bd.isSingleton()) {
				// Just apply default to singletons, as lazy-init has no meaning for prototypes.
				lazyInit = getDefaultLazyInit();
			}
			bd.setLazyInit(TRUE_VALUE.equals(lazyInit));

			if (ele.hasAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE)) {
				bd.setAutowireCandidate(TRUE_VALUE.equals(ele.getAttribute(AUTOWIRE_CANDIDATE_ATTRIBUTE)));
			}

			String autowire = ele.getAttribute(AUTOWIRE_ATTRIBUTE);
			if (DEFAULT_VALUE.equals(autowire)) {
				autowire = getDefaultAutowire();
			}
			bd.setAutowireMode(getAutowireMode(autowire));

			String dependencyCheck = ele.getAttribute(DEPENDENCY_CHECK_ATTRIBUTE);
			if (DEFAULT_VALUE.equals(dependencyCheck)) {
				dependencyCheck = getDefaultDependencyCheck();
			}
			bd.setDependencyCheck(getDependencyCheck(dependencyCheck));

			if (ele.hasAttribute(DEPENDS_ON_ATTRIBUTE)) {
				String dependsOn = ele.getAttribute(DEPENDS_ON_ATTRIBUTE);
				bd.setDependsOn(StringUtils.tokenizeToStringArray(dependsOn, BEAN_NAME_DELIMITERS));
			}

			if (ele.hasAttribute(FACTORY_METHOD_ATTRIBUTE)) {
				bd.setFactoryMethodName(ele.getAttribute(FACTORY_METHOD_ATTRIBUTE));
			}
			if (ele.hasAttribute(FACTORY_BEAN_ATTRIBUTE)) {
				bd.setFactoryBeanName(ele.getAttribute(FACTORY_BEAN_ATTRIBUTE));
			}

			if (ele.hasAttribute(INIT_METHOD_ATTRIBUTE)) {
				String initMethodName = ele.getAttribute(INIT_METHOD_ATTRIBUTE);
				if (!"".equals(initMethodName)) {
					bd.setInitMethodName(initMethodName);
				}
			}
			else {
				if (getDefaultInitMethod() != null) {
					bd.setInitMethodName(getDefaultInitMethod());
					bd.setEnforceInitMethod(false);
				}
			}

			if (ele.hasAttribute(DESTROY_METHOD_ATTRIBUTE)) {
				String destroyMethodName = ele.getAttribute(DESTROY_METHOD_ATTRIBUTE);
				if (!"".equals(destroyMethodName)) {
					bd.setDestroyMethodName(destroyMethodName);
				}
			}
			else {
				if (getDefaultDestroyMethod() != null) {
					bd.setDestroyMethodName(getDefaultDestroyMethod());
					bd.setEnforceDestroyMethod(false);
				}
			}

			parseMetaElements(ele, bd);
			parseLookupOverrideSubElements(ele, bd.getMethodOverrides());
			parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

			parseConstructorArgElements(ele, bd);
			parsePropertyElements(ele, bd);

			bd.setResourceDescription(getReaderContext().getResource().getDescription());
			bd.setSource(extractSource(ele));

			return bd;
		}
		catch (ClassNotFoundException ex) {
			error("Bean class [" + className + "] not found", ele, ex);
		}
		catch (NoClassDefFoundError err) {
			error("Class that bean class [" + className + "] depends on not found", ele, err);
		}
		catch (Throwable ex) {
			error("Unexpected failure during bean definition parsing", ele, ex);
		}
		finally {
			this.parseState.pop();
		}

		return null;
	}

该函数完成了一个完整的Bean的解析，其流程可总结为：
1. 获取class属性
2. 获取parent属性
3. 创建AbstractBeanDefinition
  4.1 判断是否配置scope或者singleton属性(默认为singleton; 可选值为singleton/prototype/request/session/global session)
  4.2 判断是否配置abstract属性(默认为false; 可选值为true/false)
  4.3 判断是否配置lazy-init属性(默认为false; 可选值为true/false, 并且仅当scope为singleton时此属性才有效, 因为对于prototype的bean, 此属性没有意义)
  4.4 判断是否配置autowire-candidate属性(默认为true; 可选值为true/false)
  4.5 判断是否配置autowire属性(默认为AUTOWIRE_NO(0)，可选值为AUTOWIRE_NO(0)/AUTOWIRE_BY_NAME(1)/AUTOWIRE_BY_TYPE(2)/AUTOWIRE_CONSTRUCTOR(3)/AUTOWIRE_AUTODETECT(4))
  4.6 判断是否配置dependency-check属性(默认为DEPENDENCY_CHECK_NONE(0), 可选值为DEPENDENCY_CHECK_NONE(0)/DEPENDENCY_CHECK_OBJECTS(1)/DEPENDENCY_CHECK_SIMPLE(2)/DEPENDENCY_CHECK_ALL(3))
  4.7 判断是否配置depends-on属性(默认为空数组)
  4.8 判断是否配置factory-method属性(默认为空)
  4.9 判断是否配置factory-bean属性(默认为空)
  4.10 判断是否配置init-method属性(默认为空)
  4.11 判断是否配置destroy-method属性(默认为空)

5 判断是否配置meta
6 判断是否有被IOC覆盖的元素
7 判断是否有被IOC覆盖的方法
8 判断是否配置constructor-arg子节点
  8.1 判断是否配置index和type属性

9 判断是否配置property子节点
  9.1 判断是否配置name属性(必须配置, 而且必须保证唯一性)
  9.2 判断是否配置ref或者value属性(两者只能配置其一)
  9.3 判断是否配置ref或者value子节点(两者只能配置其一)
    9.3.1 判断是否是bean引用
    9.3.1 判断是否是ref引用
      9.3.1.1 判断是否是任意ref引用
      9.3.1.2 判断是否是本地ref引用
      9.3.1.3 判断是否是父ref引用
    9.3.2 判断是否是idref引用
    9.3.3 判断是否是value
    9.3.4 判断是否是null
    9.3.5 判断是否是list
    9.3.6 判断是否是set
    9.3.7 判断是否是map
    9.3.8 判断是否是props

        配置文件的解析工作完成后，每个配置的Bean都被映射成为了一个BeanDefinition的实例保存在Bean工厂中，之后便要对其中属性为singleton的Bean进行实例化(前提是如果你没有为该Bean配置lazy-init属性的话)。具体是在bean容器AbstractApplicationContext的refresh()方法中，执行完配置文件的解析，维护好BeanDefinition后，调用了Bean工厂的preInstantiateSingletons方法来实例化Singleton的。方法中会遍历所有已经维护好的BeanDefinition，只有某个BeanDefinition满足三个条件，即单体，非Abstract，非LazyInit，才会将该Bean进行初始化。具体的初始化工作是在AbstractBeanFactory中的方法getBean中实现的。