《Spring技术内幕》笔记-第二章 IoC容器的实现

简介
1，在Spring中，SpringIoC提供了一个基本的JavaBean容器，通过IoC模式管理依赖关系，并通过依赖注入和AOP切面增强了为JavaBean这样子的POJO提供事务管理，生命周期管理等功能。
2，Spring IoC的设计中，主要包含两个主要的容器系列：
-1，BeanFactory系列，该序列实现了容器的基本功能。
-2，ApplicationContext应用上下文。

Spring IoC容器的设计


1，如下图，IoC容器的接口设计图。



2，简介
-1，从BeanFactory到HierarchicalbeanFactory再到ConfigurableBeanFactory是一条主要的BeanFactory设计路径。BeanFactory定义了基本的IoC容器接口。HierarchicalBeanFactory接口继承了BeanFactory接口，并再其基础上增加了getParentBeanFactory()接口功能，使得BeanFactory具备双亲IoC管理功能。ConfigurableBeanFactory主要定义了对BeanFactory的配置功能。

-2，以ApplicationContext为核心的接口设计。

BeanFactory的应用场景
BeanFactory是最基本的IoC容器。

用户在使用容器的时候可以通过&符来获取FactoryBean本身，FactoryBean跟普通Bean不同，通过BeanFactory类的getBean方法直接获取到的并不是该FactoryBean的实例，而是 该FactoryBean中方法getObject返回的对象。但我们可以通过其它途径获取到该FactoryBean的实例，方法就是在通过 getBean方法获取实例时在参数name前面加上“&”符号即可。

String FACTORY_BEAN_PREFIX = "&";

[/code]

1，BeanFactory的主要接口，以及其作用如下：

-1，容器判断是否包含指定名字的bean。

boolean containsBean(String name);

[/code]
-2，判断指定的bean是否是prototype类型。

boolean isPrototype(String name) throws NoSuchBeanDefinitionException;

[/code]
-3，判断指定的bean是否是singleton。

boolean isSingleton(String name) throws NoSuchBeanDefinitionException;

[/code]
-4，判断指定的bean是否与给定类型相匹配。

boolean isTypeMatch(String name, Class<?> targetType) throws NoSuchBeanDefinitionException;

[/code]
-5，获取指定Bean的类型。

Class<?> getType(String name) throws NoSuchBeanDefinitionException;

[/code]
-6，指定bean的所有别名。

String[] getAliases(String name);

[/code]
2，BeanFactory的容器设计原理。
BeanFactory接口提供了使用IoC的规范，并且Spring实现了一系列容器的实现供开发人员使用。以XmlBeanFactory为例。如下为XmlBeanFactory的继承结构图。



以下是XmlBeanFactory的代码，在Spring 4中，该类已经不推荐被使用了。

@Deprecated

@SuppressWarnings({"serial", "all"})

public class XmlBeanFactory extends DefaultListableBeanFactory {

private final XmlBeanDefinitionReader reader = new XmlBeanDefinitionReader(this);

/**

* 通过给定的资源创建一个XmlBeanFactory实例。

*/

public XmlBeanFactory(Resource resource) throws BeansException {

this(resource, null);

}

/**

* Create a new XmlBeanFactory with the given input stream,

* which must be parsable using DOM.

*/

public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {

super(parentBeanFactory);

this.reader.loadBeanDefinitions(resource);

}

}

[/code]
该类继承了DefaultListableBeanFactory类，DefaultListableBeanFactory该类实现一个最为基础的IoC容器。
如下是一个简单的用法举例：

ClassPathResource re = new ClassPathResource("bean.xml");

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

XmlBeanDefinitionReader xdr = new XmlBeanDefinitionReader(beanFactory);

xdr.loadBeanDefinitions(re);

System.out.println(xdr.getRegistry());

[/code]

ApplicationContext的应用场景
1， ApplicationContext在BeanFactory的基础上增加了很多新的特性：
-1，支持不同的信息源。ApplicationContext扩展了MessageSource接口，这些为国际化提供服务。

-2，访问资源。对ResourceLoader和Resource的支持。可以从不同的地方获取到资源。

-3，支持应用事件。继承ApplicationEventPublisher，从而引入的事件机制。与Bean的生命周期结合，方便管理Bean。

-4，在ApplicationContext增加附加服务。

2，ApplicationContext设计原理，以FileSystemApplicationContext为例。

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

throws BeansException {

super(parent);

setConfigLocations(configLocations);

if (refresh) {

refresh();

}

}

[/code]

在实例化该应用中，调用了AbstractApplicationContext的refresh方法，该方法是IoC容器启动的主要方法。
还有一个主要方法是：

@Override

protected Resource getResourceByPath(String path) {

if (path != null && path.startsWith("/")) {

path = path.substring(1);

}

return new FileSystemResource(path);

}

[/code]
该方法通过FileSystemResource获取资源路径。
IoC容器的初始化过程
简单来说IoC的初始化是由AbstractApplicationContext的refresh方法实现的。整个启动过程包括三个部分，BeanDefinition的Resource定位、载入和注册三个基本部分。Spring将三个模块分开，并使用不同的模块完成。
第一个过程是Resource定位过程。这个Resource定位是指Spring找到我们定义的Bean配置的xml文件。

第二步，BeanDefinition的载入。这个过程是把用户定义好的Bean表示成IoC容器内部的数据结构，而这个数据结构就是BeanDefinition。具体说，BeanDefination实际就是POJO在容器中的抽象，通过这个BeanDefinition定义的数据结构，使IoC容器能够方便的对POJO对象，也就是Bean进行管理。

第三步，是向IoC容器注册这些BeanDefinition的过程。这个过程通过调用BeanDefinationRegistry接口实现。这个注册过程把载入过程（第二步）得到的BeanDefinition向容器注册。IoC内部，将BeanDefinition注入到一个HashMap中去，IoC容器就是通过HashMap来持有这些BeanDefinition数据的。

一般，IoC的初始化过程，不包括依赖注入。依赖注入一般发生在应用第一次通过getBean向容器获取Bean的时候。

1，BeanDefinition的Resource定位。
在使用DefaultListableBeanFactory的时候，首先需要使用Resource来进行资源定位容器使用的BeanDefinition。

使用ClassPathResource进行资源定位。

ClassPathResource re = new ClassPathResource("bean.xml");

[/code]
在此处定义的资源文件不能被DefaultListableBeanFactory直接使用，通过BeanDefinitionReader来读取。

DefaultListableBeanFactory beanFactory = new DefaultListableBeanFactory();

XmlBeanDefinitionReader xdr = new XmlBeanDefinitionReader(beanFactory);

xdr.loadBeanDefinitions(re);

[/code]
在此处我们发现使用比较麻烦。所以使用ApplicationContext，因为在ApplicationContext中，Spring为我们提供了一系列的资源定位，比如FileSystemXmlApplicationContext。

以FileSystemXmlApplicationContext为例，讲解对应的源码。
该构造函数通过文件路劲来生成对应的FileSystemXmlApplicationContext

public FileSystemXmlApplicationContext(String configLocation) throws BeansException {

this(new String[] {configLocation}, true, null);

}

[/code]
通过refresh方法来载入BeanDefinition。

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

throws BeansException {

super(parent);

setConfigLocations(configLocations);

if (refresh) {

refresh();

}

}

[/code]
通过文件系统来获取资源。

@Override

protected Resource getResourceByPath(String path) {

if (path != null && path.startsWith("/")) {

path = path.substring(1);

}

return new FileSystemResource(path);

}

[/code]
2，BeanDefinition的载入和解析。
对IoC容器来说，载入过程相当于把BeanDefinition在IoC容器中转换成一个Spring内部数据结构的过程。IoC对对象的管理都是通过对其持有的BeanDefination进行相关操作来实现的。这些BeanDefinition是通过HashMap来维护的。

public FileSystemXmlApplicationContext(String[] configLocations, boolean refresh, ApplicationContext parent)

throws BeansException {

super(parent);

setConfigLocations(configLocations);

if (refresh) {

refresh();

}

}

[/code]

如上代码，refresh()方法启动了容器初始化。是载入BeanDefination的入口方法。

refresh()具体的代码结构如下：

@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.

//在子类中启动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并注册

registerListeners();

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

//实例化所有(non-lazy-init) 单例。

finishBeanFactoryInitialization(beanFactory);

// Last step: publish corresponding event.

//发布容器事件，结束

finishRefresh();

}

catch (BeansException ex) {

// Destroy already created singletons to avoid dangling resources.

//防止Bean资源占用，销毁已经创建的单例。

destroyBeans();

// Reset 'active' flag.

//重置active标志

cancelRefresh(ex);

// Propagate exception to caller.

throw ex;

}

}

}

[/code]

-1，prepareRefresh()：

/**

* Prepare this context for refreshing, setting its startup date and

* active flag as well as performing any initialization of property sources.

*/

protected void prepareRefresh() {

this.startupDate = System.currentTimeMillis();

synchronized (this.activeMonitor) {

this.active = true;

}

if (logger.isInfoEnabled()) {

logger.info("Refreshing " + this);

}

// Initialize any placeholder property sources in the context environment

initPropertySources();

// Validate that all properties marked as required are resolvable

// see ConfigurablePropertyResolver#setRequiredProperties

getEnvironment().validateRequiredProperties();

}

[/code]

-2，启动refreshBeanFactory()：

ConfigurableListableBeanFactory beanFactory = obtainFreshBeanFactory();

[/code]

/**

* Tell the subclass to refresh the internal bean factory.

* @return the fresh BeanFactory instance

* @see #refreshBeanFactory()

* @see #getBeanFactory()

*/

protected ConfigurableListableBeanFactory obtainFreshBeanFactory() {

refreshBeanFactory();

ConfigurableListableBeanFactory beanFactory = getBeanFactory();

if (logger.isDebugEnabled()) {

logger.debug("Bean factory for " + getDisplayName() + ": " + beanFactory);

}

return beanFactory;

}

[/code]

最终调用，AbstractRefreshableApplicationContext中的refreshBeanFactory()方法。

/**

* This implementation performs an actual refresh of this context's underlying

* bean factory, shutting down the previous bean factory (if any) and

* initializing a fresh bean factory for the next phase of the context's lifecycle.

*/

@Override

protected final void refreshBeanFactory() throws BeansException {

if (hasBeanFactory()) {//如果已经存在BeanFactory

destroyBeans();//销毁

closeBeanFactory();

}

try { //创建IoC容器

DefaultListableBeanFactory beanFactory = createBeanFactory();

beanFactory.setSerializationId(getId());

customizeBeanFactory(beanFactory);

loadBeanDefinitions(beanFactory);//载入BeanFactory，抽象方法

synchronized (this.beanFactoryMonitor) {

this.beanFactory = beanFactory;

}

}

catch (IOException ex) {

throw new ApplicationContextException("I/O error parsing bean definition source for " + getDisplayName(), ex);

}

}

[/code]

这里调用的loadBeanDefinations()是一个抽象方法，具体实现在AbstractXmlApplicationContext。

/**

* Loads the bean definitions via an XmlBeanDefinitionReader.

* @see org.springframework.beans.factory.xml.XmlBeanDefinitionReader

* @see #initBeanDefinitionReader

* @see #loadBeanDefinitions

*/

@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);

}

[/code]

接着就是调用loadBeanDefinations的地方，首先得到BeanDefinition信息的Resource定位，然后调用XmlBeanDefinitionReader来读取，具体过程委托给BeanDefinitionReader来完成的。XML文件则是通过XmlBeanDefinitionReader来载入BeanDefination到容器中。
​注：在XmlBeanDefinationReader中找到的loadBeanDefination()方法，与书中的代码块不同。此处可能是Spring版本的问题。

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<EncodedResource> currentResources = this.resourcesCurrentlyBeingLoaded.get();

if (currentResources == null) {

currentResources = new HashSet<EncodedResource>(4);

this.resourcesCurrentlyBeingLoaded.set(currentResources);

}

if (!currentResources.add(encodedResource)) {

throw new BeanDefinitionStoreException(

"Detected cyclic 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());

}//调用解析XML文件

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.remove();

}

}

}

[/code]

doLoadBeanDefinitions()方法：

protected int doLoadBeanDefinitions(InputSource inputSource, Resource resource)

throws BeanDefinitionStoreException {

try {

//加载文件

Document doc = doLoadDocument(inputSource, resource);

//启动详细的解析过程

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);

}

}

[/code]

registerbeanDefinitions()方法代码：

public int registerBeanDefinitions(Document doc, Resource resource) throws BeanDefinitionStoreException {

//获取XML文档读取

BeanDefinitionDocumentReader documentReader = createBeanDefinitionDocumentReader();

documentReader.setEnvironment(this.getEnvironment());

int countBefore = getRegistry().getBeanDefinitionCount();

//具体解析过程

documentReader.registerBeanDefinitions(doc, createReaderContext(resource));

return getRegistry().getBeanDefinitionCount() - countBefore;

}

[/code]

BeanDefinition载入过程中，首先调用XML解析器，生成XML解析对象。然后再进行具体的解析。
createBeanDefinitionDocumentReader()方法：

protected BeanDefinitionDocumentReader createBeanDefinitionDocumentReader() {

return BeanDefinitionDocumentReader.class.cast(BeanUtils.instantiateClass(this.documentReaderClass));

}

[/code]

获取到具体的解析器，然后委托给BeanDefinitionParserDelegate来完成具体的解析。如下查看DefaultBeanDefinitionDocuementReader中的processBeanDefinition(Element , BeanDefinitionParserDelegate)方法：

protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {

BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele);

//BeanDefinitionHolder是对BeanDefinition的封装。

if (bdHolder != null) {

bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);

try {

// Register the final decorated instance.

//向IoC容器注册解析到的BeanDefinition。

BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());

}

	catch (BeanDefinitionStoreException ex) {

getReaderContext().error("Failed to register bean definition with name '" +

bdHolder.getBeanName() + "'", ele, ex);

}

// Send registration event.

getReaderContext().fireComponentRegistered(new BeanComponentDefinition(bdHolder));

}

}

[/code]

BeanDefinitionHolder：

public class BeanDefinitionHolder implements BeanMetadataElement {

private final BeanDefinition beanDefinition;

private final String beanName;

private final String[] aliases;

........

[/code]

在BeanDefinitionParserDelegate类中，定义了对各种SpringBean类的处理。查看其对应的parseBeanDefinitionElement方法：

public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {

String id = ele.getAttribute(ID_ATTRIBUTE);//bean元素中的ID

String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);//bean元素中的name

List<String> aliases = new ArrayList<String>();//aliases

if (StringUtils.hasLength(nameAttr)) {

String[] nameArr = StringUtils.tokenizeToStringArray(nameAttr, MULTI_VALUE_ATTRIBUTE_DELIMITERS);

aliases.addAll(Arrays.asList(nameArr));

}

String beanName = id;

if (!StringUtils.hasText(beanName) && !aliases.isEmpty()) {

beanName = aliases.remove(0);

	if (logger.isDebugEnabled()) {

logger.debug("No XML 'id' specified - using '" + beanName +

"' as bean name and " + aliases + " as aliases");

}

}

if (containingBean == null) {

checkNameUniqueness(beanName, aliases, ele);

}

AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);//详细解析过程，返回AbstractBeanDefinition对象，该对象定义了Bean的基本属性

if (beanDefinition != null) {

if (!StringUtils.hasText(beanName)) {

	try {

if (containingBean != null) {

beanName = BeanDefinitionReaderUtils.generateBeanName(

beanDefinition, this.readerContext.getRegistry(), true);

}

else {

beanName = this.readerContext.generateBeanName(beanDefinition);

// Register an alias for the plain bean class name, if still possible,

// if the generator returned the class name plus a suffix.

// This is expected for Spring 1.2/2.0 backwards compatibility.

String beanClassName = beanDefinition.getBeanClassName();

if (beanClassName != null &&

beanName.startsWith(beanClassName) && beanName.length() > beanClassName.length() &&

!this.readerContext.getRegistry().isBeanNameInUse(beanClassName)) {

aliases.add(beanClassName);

}

}

if (logger.isDebugEnabled()) {

logger.debug("Neither XML 'id' nor 'name' specified - " +

"using generated bean name [" + beanName + "]");

}

}

catch (Exception ex) {

error(ex.getMessage(), ele);

return null;

}

}

String[] aliasesArray = StringUtils.toStringArray(aliases);

return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);

}

return null;

}

[/code]

查看具体的解析代码，parseBeanDefinitionEleent方法：

public AbstractBeanDefinition parseBeanDefinitionElement(

Element ele, String beanName, BeanDefinition containingBean) {

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

String className = null;

if (ele.hasAttribute(CLASS_ATTRIBUTE)) {

className = ele.getAttribute(CLASS_ATTRIBUTE).trim();

}

try {

String parent = null;

if (ele.hasAttribute(PARENT_ATTRIBUTE)) {

parent = ele.getAttribute(PARENT_ATTRIBUTE);

}

//生成BeanDefinition对象

AbstractBeanDefinition bd = createBeanDefinition(className, parent);

//解析属性，并设置Description信息

parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);

bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

//解析bean元素信息

parseMetaElements(ele, bd);

parseLookupOverrideSubElements(ele, bd.getMethodOverrides());

parseReplacedMethodSubElements(ele, bd.getMethodOverrides());

//构造函数

parseConstructorArgElements(ele, bd);

//成员变量

parsePropertyElements(ele, bd);

parseQualifierElements(ele, bd);

bd.setResource(this.readerContext.getResource());

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;

}

[/code]

其中对应的各种异常信息，可能我们在编程工作中经常遇到。

public void parsePropertyElements(Element beanEle, BeanDefinition bd) {

NodeList nl = beanEle.getChildNodes();

for (int i = 0; i < nl.getLength(); i++) {

Node node = nl.item(i);

if (isCandidateElement(node) && nodeNameEquals(node, PROPERTY_ELEMENT)) {

parsePropertyElement((Element) node, bd);//解析

}

}

}

[/code]

/**

* Parse a property element.

*/

public void parsePropertyElement(Element ele, BeanDefinition bd) {

String propertyName = ele.getAttribute(NAME_ATTRIBUTE);//获取property名字

if (!StringUtils.hasLength(propertyName)) {

error("Tag 'property' must have a 'name' attribute", ele);

return;

}

this.parseState.push(new PropertyEntry(propertyName));

try {

if (bd.getPropertyValues().contains(propertyName)) {//是否包含

error("Multiple 'property' definitions for property '" + propertyName + "'", ele);

	return;

}

Object val = parsePropertyValue(ele, bd, propertyName);//解析

PropertyValue pv = new PropertyValue(propertyName, val);//获取值

parseMetaElements(ele, pv);

pv.setSource(extractSource(ele));

bd.getPropertyValues().addPropertyValue(pv);

}

finally {

this.parseState.pop();

}

}

[/code]

public Object parsePropertyValue(Element ele, BeanDefinition bd, String propertyName) {

String elementName = (propertyName != null) ?

"<property> element for property '" + propertyName + "'" :

"<constructor-arg> element";

// Should only have one child element: ref, value, list, etc.

NodeList nl = ele.getChildNodes();//xml文档解析

Element subElement = null;

for (int i = 0; i < nl.getLength(); i++) {

Node node = nl.item(i);

if (node instanceof Element && !nodeNameEquals(node, DESCRIPTION_ELEMENT) &&

!nodeNameEquals(node, META_ELEMENT)) {

// Child element is what we're looking for.

if (subElement != null) {

error(elementName + " must not contain more than one sub-element", ele);

}

else {

subElement = (Element) node;

}

}

}

boolean hasRefAttribute = ele.hasAttribute(REF_ATTRIBUTE);//是否是ref引用

boolean hasValueAttribute = ele.hasAttribute(VALUE_ATTRIBUTE);//值引用

if ((hasRefAttribute && hasValueAttribute) ||

((hasRefAttribute || hasValueAttribute) && subElement != null)) {

error(elementName +

" is only allowed to contain either 'ref' attribute OR 'value' attribute OR sub-element", ele);

}

if (hasRefAttribute) {//ref引用

String refName = ele.getAttribute(REF_ATTRIBUTE);

if (!StringUtils.hasText(refName)) {

	error(elementName + " contains empty 'ref' attribute", ele);

}

RuntimeBeanReference ref = new RuntimeBeanReference(refName);

ref.setSource(extractSource(ele));

return ref;

}//value 引用

else if (hasValueAttribute) {

TypedStringValue valueHolder = new TypedStringValue(ele.getAttribute(VALUE_ATTRIBUTE));

valueHolder.setSource(extractSource(ele));

return valueHolder;

}//如果还有子元素，触发对子元素的解析

else if (subElement != null) {

return parsePropertySubElement(subElement, bd);

}

else {

// Neither child element nor "ref" or "value" attribute found.

error(elementName + " must specify a ref or value", ele);

	return null;

}

}

[/code]

3，BeanDefinition在IoC容器中的注册
BeanDefinition完成载入和解析过程后，需要对其进行注册操作。注册是在DefaultListableBeanFactory中，通过HashMap来载入Beandefinition的。

/** Map of bean definition objects, keyed by bean name */

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<String, BeanDefinition>(64);

[/code]

调用顺序：XmlBeanDefinitionReader调用loadBeanDefinitions(EncodedResource)方法，然后到registerBeanDefinitions()方法，在该方法中registerBeanDefinitions()方法被调用。在DefaultListableBeanFactory中，实现了BeanDefinitionRegistry接口。

@Override

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)

throws BeanDefinitionStoreException {

Assert.hasText(beanName, "Bean name must not be empty");

Assert.notNull(beanDefinition, "BeanDefinition must not be null");

if (beanDefinition instanceof AbstractBeanDefinition) {

try {

((AbstractBeanDefinition) beanDefinition).validate();

}

catch (BeanDefinitionValidationException ex) {

	throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,

"Validation of bean definition failed", ex);

}

}

synchronized (this.beanDefinitionMap) {//是否存在相同名字

BeanDefinition oldBeanDefinition = this.beanDefinitionMap.get(beanName);

if (oldBeanDefinition != null) {

if (!this.allowBeanDefinitionOverriding) {

		throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,

"Cannot register bean definition [" + beanDefinition + "] for bean '" + beanName +

"': There is already [" + oldBeanDefinition + "] bound.");

}

else if (oldBeanDefinition.getRole() < beanDefinition.getRole()) {

// e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE

if (this.logger.isWarnEnabled()) {

this.logger.warn("Overriding user-defined bean definition for bean '" + beanName +

" with a framework-generated bean definition ': replacing [" +

oldBeanDefinition + "] with [" + beanDefinition + "]");

}

}

else {

if (this.logger.isInfoEnabled()) {

this.logger.info("Overriding bean definition for bean '" + beanName +

"': replacing [" + oldBeanDefinition + "] with [" + beanDefinition + "]");

}

}

}

else {//注册bean。将bean的name放入List

this.beanDefinitionNames.add(beanName);

this.frozenBeanDefinitionNames = null;

}

//map中加入

this.beanDefinitionMap.put(beanName, beanDefinition);

}

resetBeanDefinition(beanName);

}

[/code]

完成了注册，就完成了IoC容器的初始化。在使用的IoC容器的DefaultListableBeanFactory中已经建立了Bean的配置信息，而且这些BeanDefinition已经可以被容器使用，他们都在beanDefinitionMap中被检索和使用。容器的作用就是对这些信息进行维护和处理。

IoC容器的依赖注入 ​ ​


​依赖注入是用户第一次向Ioc容器索要Bean的时候触发的，除非通过lazy-init控制Bean的记载时机。
​从DefaultListableBeanFactory的基类AbstractBeanFactory的getBean方法开始查看实现。

@Override

public Object getBean(String name) throws BeansException {

return doGetBean(name, null, null, false);

}

@Override

public <T> T getBean(String name, Class<T> requiredType) throws BeansException {

return doGetBean(name, requiredType, null, false);

}

@Override

public Object getBean(String name, Object... args) throws BeansException {

return doGetBean(name, null, args, false);

}

[/code]

查看doGetBean方法：

protected <T> T doGetBean(

final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)

throws BeansException {

final String beanName = transformedBeanName(name);

Object bean;

// Eagerly check singleton cache for manually registered singletons.

//从缓存入手，处理单例bean

Object sharedInstance = getSingleton(beanName);

if (sharedInstance != null && args == null) {

if (logger.isDebugEnabled()) {

if (isSingletonCurrentlyInCreation(beanName)) {

logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +

"' that is not fully initialized yet - a consequence of a circular reference");

}

else {

logger.debug("Returning cached instance of singleton bean '" + beanName + "'");

}

}

//对FactoryBean的处理，获取FactoryBean的相关实例。

bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);

}

else {

// Fail if we're already creating this bean instance:

// We're assumably within a circular reference.

if (isPrototypeCurrentlyInCreation(beanName)) {

throw new BeanCurrentlyInCreationException(beanName);

}

// Check if bean definition exists in this factory.

//减产是否已经存在对应的BeanDefinition对象

BeanFactory parentBeanFactory = getParentBeanFactory();

if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {

// Not found -> check parent.

String nameToLookup = originalBeanName(name);

if (args != null) {

// Delegation to parent with explicit args.

return (T) parentBeanFactory.getBean(nameToLookup, args);

}

else {

// No args -> delegate to standard getBean method.

return parentBeanFactory.getBean(nameToLookup, requiredType);

}

}

if (!typeCheckOnly) {

markBeanAsCreated(beanName);

}

try {

//根据Bean的名字获取BeanDefinition

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

checkMergedBeanDefinition(mbd, beanName, args);

// Guarantee initialization of beans that the current bean depends on.

//获取当前bean的所有依赖bean

String[] dependsOn = mbd.getDependsOn();

if (dependsOn != null) {

for (String dependsOnBean : dependsOn) {

if (isDependent(beanName, dependsOnBean)) {

throw new BeanCreationException("Circular depends-on relationship between '" +

beanName + "' and '" + dependsOnBean + "'");

}

registerDependentBean(dependsOnBean, beanName);//注册依赖bean

getBean(dependsOnBean);//获取bean的递归调用

}

}

// Create bean instance.

//创建单例bean

if (mbd.isSingleton()) {

sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {

@Override

public Object getObject() throws BeansException {

	try {

return createBean(beanName, mbd, args);

}

	catch (BeansException ex) {

// Explicitly remove instance from singleton cache: It might have been put there

// eagerly by the creation process, to allow for circular reference resolution.

// Also remove any beans that received a temporary reference to the bean.

destroySingleton(beanName);

throw ex;

}

}

});

bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);

}

else if (mbd.isPrototype()) {// property bean

// It's a prototype -> create a new instance.

Object prototypeInstance = null;

	try {

beforePrototypeCreation(beanName);

prototypeInstance = createBean(beanName, mbd, args);

}

	finally {

afterPrototypeCreation(beanName);

}

bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);

}

else {

String scopeName = mbd.getScope();//其他scope

final Scope scope = this.scopes.get(scopeName);

if (scope == null) {

throw new IllegalStateException("No Scope registered for scope '" + scopeName + "'");

}

	try {

Object scopedInstance = scope.get(beanName, new ObjectFactory<Object>() {

@Override

	public Object getObject() throws BeansException {

		beforePrototypeCreation(beanName);

try {

	return createBean(beanName, mbd, args);

}

finally {

			afterPrototypeCreation(beanName);

}

}

});

bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);

}

catch (IllegalStateException ex) {

throw new BeanCreationException(beanName,

"Scope '" + scopeName + "' is not active for the current thread; " +

"consider defining a scoped proxy for this bean if you intend to refer to it from a singleton",

ex);

}

}

}

catch (BeansException ex) {

cleanupAfterBeanCreationFailure(beanName);

throw ex;

}

}

// Check if required type matches the type of the actual bean instance.

//检查bean的类型，

if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {

try {

return getTypeConverter().convertIfNecessary(bean, requiredType);

}

catch (TypeMismatchException ex) {

	if (logger.isDebugEnabled()) {

logger.debug("Failed to convert bean '" + name + "' to required type [" +

ClassUtils.getQualifiedName(requiredType) + "]", ex);

}

throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());

}

}

return (T) bean;

}

[/code]

这个方法就是依赖注入的入口，因为他触发了依赖注入。

尽管可以以最简单的方法来描述Spring IoC容器，即Spring容器就是一个HashMap，通过HashMap来管理BeanDefinition对象。在getBean()的时候，会触发createBean()来进创建需要的Bean对象。

​最终的调用，到AbstractAutowireCapableBeanFactory的createBean()方法，代码如下：

/**

* Central method of this class: creates a bean instance,

* populates the bean instance, applies post-processors, etc.

* @see #doCreateBean

*/

@Override

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)

throws BeanCreationException {

if (logger.isDebugEnabled()) {

logger.debug("Creating instance of bean '" + beanName + "'");

}

// Make sure bean class is actually resolved at this point.

//判断需要创建的Bean是否可实例化，这个类是否可通过类装载器来载入

resolveBeanClass(mbd, beanName);

// Prepare method overrides.

try {

mbd.prepareMethodOverrides();

}

catch (BeanDefinitionValidationException ex) {

throw new BeanDefinitionStoreException(mbd.getResourceDescription(),

beanName, "Validation of method overrides failed", ex);

}

try {

// Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.

//如果Bean配置了BeanPostProcessors，则返回代理对象

Object bean = resolveBeforeInstantiation(beanName, mbd);

if (bean != null) {

return bean;

}

}

catch (Throwable ex) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName,

"BeanPostProcessor before instantiation of bean failed", ex);

}

//创建bean

Object beanInstance = doCreateBean(beanName, mbd, args);

if (logger.isDebugEnabled()) {

logger.debug("Finished creating instance of bean '" + beanName + "'");

}

return beanInstance;

}

[/code]

再查看doCreateBean()方法：

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {

// Instantiate the bean.

BeanWrapper instanceWrapper = null;

if (mbd.isSingleton()) {//如果是单例的，则移除缓存中的同name bean

instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);

}

if (instanceWrapper == null) {//创建Bean

instanceWrapper = createBeanInstance(beanName, mbd, args);

}

final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);

Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

// Allow post-processors to modify the merged bean definition.

synchronized (mbd.postProcessingLock) {

if (!mbd.postProcessed) {

applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);

mbd.postProcessed = true;

}

}

// Eagerly cache singletons to be able to resolve circular references

// even when triggered by lifecycle interfaces like BeanFactoryAware.

boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&

isSingletonCurrentlyInCreation(beanName));

if (earlySingletonExposure) {

	if (logger.isDebugEnabled()) {

logger.debug("Eagerly caching bean '" + beanName +

"' to allow for resolving potential circular references");

}

addSingletonFactory(beanName, new ObjectFactory<Object>() {

@Override

public Object getObject() throws BeansException {

return getEarlyBeanReference(beanName, mbd, bean);

}

});

}

// Initialize the bean instance.初始化bean，通常在此处发生依赖注入

Object exposedObject = bean;

try {

populateBean(beanName, mbd, instanceWrapper);

if (exposedObject != null) {

exposedObject = initializeBean(beanName, exposedObject, mbd);

}

}

catch (Throwable ex) {

if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {

throw (BeanCreationException) ex;

}

else {

	throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);

}

}

if (earlySingletonExposure) {

Object earlySingletonReference = getSingleton(beanName, false);

if (earlySingletonReference != null) {

if (exposedObject == bean) {

exposedObject = earlySingletonReference;

}

else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {

String[] dependentBeans = getDependentBeans(beanName);

Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);

for (String dependentBean : dependentBeans) {

if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {

actualDependentBeans.add(dependentBean);

}

}

if (!actualDependentBeans.isEmpty()) {

throw new BeanCurrentlyInCreationException(beanName,

"Bean with name '" + beanName + "' has been injected into other beans [" +

StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +

"] in its raw version as part of a circular reference, but has eventually been " +

"wrapped. This means that said other beans do not use the final version of the " +

"bean. This is often the result of over-eager type matching - consider using " +

"'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");

}

}

}

}

// Register bean as disposable.

try {

registerDisposableBeanIfNecessary(beanName, bean, mbd);

}

catch (BeanDefinitionValidationException ex) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);

}

return exposedObject;

}

[/code]

与依赖注入相关的两个方法：createBeanInstance和populateBean。

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {

// Make sure bean class is actually resolved at this point.

//确认需要创建实例的类可以实例化

Class<?> beanClass = resolveBeanClass(mbd, beanName);

if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName,

"Bean class isn't public, and non-public access not allowed: " + beanClass.getName());

}

//工厂方法实例化

if (mbd.getFactoryMethodName() != null)  {

return instantiateUsingFactoryMethod(beanName, mbd, args);

}

// Shortcut when re-creating the same bean...

boolean resolved = false;

boolean autowireNecessary = false;

if (args == null) {

synchronized (mbd.constructorArgumentLock) {

if (mbd.resolvedConstructorOrFactoryMethod != null) {

resolved = true;

autowireNecessary = mbd.constructorArgumentsResolved;

}

}

}

if (resolved) {

if (autowireNecessary) {

return autowireConstructor(beanName, mbd, null, null);

}

else {

return instantiateBean(beanName, mbd);

}

}

//构造函数实例化

Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);

if (ctors != null ||

mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||

mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args))  {

return autowireConstructor(beanName, mbd, ctors, args);

}

// 使用无参构造函数

return instantiateBean(beanName, mbd);

}

[/code]

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {

//使用CGLIB对bean进行实例化。

try {

Object beanInstance;

final BeanFactory parent = this;

if (System.getSecurityManager() != null) {

beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {

@Override

public Object run() {

return getInstantiationStrategy().instantiate(mbd, beanName, parent);

}

}, getAccessControlContext());

}

else {

beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);

}

BeanWrapper bw = new BeanWrapperImpl(beanInstance);

initBeanWrapper(bw);

return bw;

}

catch (Throwable ex) {

throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);

}

}

[/code]

在Bean实例化后，就是相关的依赖关系。
​依赖注入的发生是在BeanWrapper的setPropertyValues中实现，具体实现是在BeanWrapper的子类，BeanWrapperImpl中实现。

以上便是整个IoC过程创建Bean的整体思路。与书中相比，省略了部分代码。
ApplicationContext和Bean的初始化及销毁


​ApplicationContext的启动是在AbstractApplicationContext中实现。

​同样的销毁操作是在doClose()方法中完成。

protected void doClose() {

boolean actuallyClose;

synchronized (this.activeMonitor) {

actuallyClose = this.active && !this.closed;

this.closed = true;

}

if (actuallyClose) {

	if (logger.isInfoEnabled()) {

logger.info("Closing " + this);

}

LiveBeansView.unregisterApplicationContext(this);

try {

// Publish shutdown event.

publishEvent(new ContextClosedEvent(this));

}

	catch (Throwable ex) {

logger.warn("Exception thrown from ApplicationListener handling ContextClosedEvent", ex);

}

// Stop all Lifecycle beans, to avoid delays during individual destruction.

try {

getLifecycleProcessor().onClose();

}

	catch (Throwable ex) {

logger.warn("Exception thrown from LifecycleProcessor on context close", ex);

}

// Destroy all cached singletons in the context's BeanFactory.

destroyBeans();

// Close the state of this context itself.

closeBeanFactory();

// Let subclasses do some final clean-up if they wish...

onClose();

	synchronized (this.activeMonitor) {

this.active = false;

}

}

}

[/code]

​Bean的销毁和创建，Spring通过IoC管理Bean的生命周期来实现。Spring中Bean的生命周期包含：
​ ​-1，Bean实例的创建。

​ ​-2，为Bean实例设置属性。

​ ​-3，调用Bean的初始化方法。

​ ​-4，通过IoC获取Bean。

​ ​-5，当容器关闭的时候调用bean的销毁方法。

总结


​BeanDefinition的定位。对IoC容器来说，它为管理POJO直接的关系提供了帮助，但也要根据Spring的定义规则提供Bean定义信息。在Bean定义方面，Spring为用户提供了很大的灵活性。在初始化过程中，首先需要定义到这些有效地Bean定义信息，这里Spring使用Resource接口来统一这些信息，而定位由ResourceLoader完成。
​容器的初始化。容器的初始化过程是在refresh()方法中完成的。这个refresh()相当于容器的初始化函数。在初始化中，比较重要的就是对Bean信息的载入和注册功能。

​