2. spring中IOC的实现源码篇【analyze spring framework source】

2B青年欢乐多啊，最近研究spring源码，做点笔记，欢迎继续补充, 持续更新

接上一篇 1. Introduce how to import the Spring Framework sourcecode into an eclipse project

一. 结构

spring中bean管理设计到下面3个包





core 相当于一个工具类，bean包是对IOC的实现包，context是在bean的基础扩展功能

IOC的实现原理简介

简单实现

package org.benson;

import org.springframework.beans.factory.config.ConfigurableListableBeanFactory;
import org.springframework.beans.factory.support.BeanDefinitionRegistry;
import org.springframework.beans.factory.support.DefaultListableBeanFactory;
import org.springframework.beans.factory.xml.XmlBeanDefinitionReader;
import org.springframework.core.io.ClassPathResource;

public class Test4DebugSpringIOC {
ConfigurableListableBeanFactory beanFactory = new DefaultListableBeanFactory();//manage bean factory
ClassPathResource resource = new ClassPathResource(
"applicationContext.xml");//resource
XmlBeanDefinitionReader xmlReader=new XmlBeanDefinitionReader((BeanDefinitionRegistry)beanFactory); //register

public Test4DebugSpringIOC() {
// TODO load and registered BeanDefinition
xmlReader.loadBeanDefinitions(resource);
}
public static void main(String[] args) {
Test4DebugSpringIOC test4DebugSpring= new Test4DebugSpringIOC();
Test4DebugSpringBean test4DebugSpringBean = (Test4DebugSpringBean) test4DebugSpring.beanFactory
.getBean("testAlias");
test4DebugSpringBean.SayHolle();
}
}

1，找到bean的定义文件（Resource）

如此处classPathResource，用于找到文件位置

2，把定义文件解析成BeanDefinition对象并进行注册，在XmlBeanDefinitionReader中

int validationMode = getValidationModeForResource(resource);//Validation xml file  . XmlBeanDefinitionReader doLoadBeanDefinitions
Document doc = this.documentLoader.loadDocument(
inputSource, getEntityResolver(), this.errorHandler, validationMode, isNamespaceAware());//parse to doc . through documentLoader(DefaultDocumentLoader)
return registerBeanDefinitions(doc, resource);

一个普通bean的解析step

i 调用DefaultDocumentLoader把XML解析成DOC并进行XSD，DTD等格式验证.

DefaultDocumentLoader调用了SAX的DocumentBuilderFactory.newInstance()，把XML文件解析成一个org.w3c.dom.Document对象(标准的DOM解析方式)，当然也设置XML验证的validationMode，namespace

/**
* Load the {@link Document} at the supplied {@link InputSource} using the standard JAXP-configured
* XML parser.
*/
public Document loadDocument(InputSource inputSource, EntityResolver entityResolver,
ErrorHandler errorHandler, int validationMode, boolean namespaceAware) throws Exception {

DocumentBuilderFactory factory = createDocumentBuilderFactory(validationMode, namespaceAware);
if (logger.isDebugEnabled()) {
logger.debug("Using JAXP provider [" + factory.getClass().getName() + "]");
}
DocumentBuilder builder = createDocumentBuilder(factory, entityResolver, errorHandler);
return builder.parse(inputSource);
}

ii DefaultBeanDefinitionDocumentReader读取document中的所有Element.

registerBeanDefinitions(doc, resource)中调用BeanDefinitionDocumentReader的registerBeanDefinitions方法获根节点

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

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

doRegisterBeanDefinitions(root);
}

得到XML的根节点,调用doRegisterBeanDefinitions

/**
* Register each bean definition within the given root {@code <beans/>} element.
* @throws IllegalStateException if {@code <beans profile="..."} attribute is present
* and Environment property has not been set
* @see #setEnvironment
*/
protected void doRegisterBeanDefinitions(Element root) {
..//profile

// any nested <beans> elements will cause recursion in this method. In
// order to propagate and preserve <beans> default-* attributes correctly,
// keep track of the current (parent) delegate, which may be null. Create
// the new (child) delegate with a reference to the parent for fallback purposes,
// then ultimately reset this.delegate back to its original (parent) reference.
// this behavior emulates a stack of delegates without actually necessitating one.
BeanDefinitionParserDelegate parent = this.delegate;
this.delegate = createHelper(readerContext, root, parent);

preProcessXml(root);
parseBeanDefinitions(root, this.delegate);
postProcessXml(root);

this.delegate = parent;
}

然后从获得根结点的所有子节点，进行循环

/**
* Parse the elements at the root level in the document:
* "import", "alias", "bean".
* @param root the DOM root element of the document
*/
protected void parseBeanDefinitions(Element root, BeanDefinitionParserDelegate delegate) {
if (delegate.isDefaultNamespace(root)) {
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;
if (delegate.isDefaultNamespace(ele)) {
parseDefaultElement(ele, delegate);//parse defalut element
}
else {
delegate.parseCustomElement(ele);
}
}
}
}
else {
delegate.parseCustomElement(root);
}
}

此处isDefaultNamespace方法是获取namespace为http://www.springframework.org/schema/beans的node，目前对应schema定义的包括"bean" "alis" "beans" "import" ,处理方法为parseDefaultElement(ele, delegate)，如果发现是bean标签则调用processBeanDefinition方法

/**
* Process the given bean element, parsing the bean definition
* and registering it with the registry.
*/
protected void processBeanDefinition(Element ele, BeanDefinitionParserDelegate delegate) {
BeanDefinitionHolder bdHolder = delegate.parseBeanDefinitionElement(ele); //parse to object of BeanDefinitionHolder
if (bdHolder != null) {//if it is not exit. parse it from xml
bdHolder = delegate.decorateBeanDefinitionIfRequired(ele, bdHolder);
try {
// Register the final decorated instance.
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));
}
}

[b]iii 调用BeanDefinitionParserDelegate对象完成doc中Element->BeanDefinitionHolder的转换[/b]

/**
* Parses the supplied <code><bean></code> element. May return <code>null</code>
* if there were errors during parse. Errors are reported to the
* {@link org.springframework.beans.factory.parsing.ProblemReporter}.
*/
public BeanDefinitionHolder parseBeanDefinitionElement(Element ele, BeanDefinition containingBean) {
String id = ele.getAttribute(ID_ATTRIBUTE);
String nameAttr = ele.getAttribute(NAME_ATTRIBUTE);
... ... //vacation
AbstractBeanDefinition beanDefinition = parseBeanDefinitionElement(ele, beanName, containingBean);
....

return new BeanDefinitionHolder(beanDefinition, beanName, aliasesArray);
}

先获得别名，这里叫nameAttr先转成数组，然后通过BeanDefinitionHolder把它和beanName，beandefine绑定在一起

/**
* Parse the bean definition itself, without regard to name or aliases. May return
* <code>null</code> if problems occurred during the parsing of the bean definition.
*/
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);
}
AbstractBeanDefinition bd = createBeanDefinition(className, parent);

parseBeanDefinitionAttributes(ele, beanName, containingBean, bd);
bd.setDescription(DomUtils.getChildElementValueByTagName(ele, DESCRIPTION_ELEMENT));

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

全部当成属性设置到了AbstractBeanDefinition 的对象中，具体可以看AbstractBeanDefinition 类

最后返回BeanDefinitionHolder；BeanDefinitionHolder是由beanname+aliasArray+beandefinition组成的一个对象

IV 然后回到ii的最后调用[b][b]BeanDefinitionReaderUtils.registerBeanDefinition注册beandefine对象[/b]，并调BeanDefinitionRegistry接口进行注册，如DefaultListableBeanFactory[/b]

完成转换后，BeanDefinitionReaderUtils.registerBeanDefinition 调用到 BeanDefinitionRegistry接口实现类的registerBeanDefinition方法把对象放入bean的工厂容器中

* Register the given bean definition with the given bean factory.
* @param definitionHolder the bean definition including name and aliases
* @param registry the bean factory to register with
* @throws BeanDefinitionStoreException if registration failed
*/
public static void registerBeanDefinition(
BeanDefinitionHolder definitionHolder, BeanDefinitionRegistry registry)
throws BeanDefinitionStoreException {

// Register bean definition under primary name.
String beanName = definitionHolder.getBeanName();
registry.registerBeanDefinition(beanName, definitionHolder.getBeanDefinition());

// Register aliases for bean name, if any.
String[] aliases = definitionHolder.getAliases();
if (aliases != null) {
for (String aliase : aliases) {
registry.registerAlias(beanName, aliase);
}
}
}

在DefaultListableBeanFactory的实现也很简单了，直接用map添加下就OK了

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)
throws BeanDefinitionStoreException {
....//Validation

this.beanDefinitionMap.put(beanName, beanDefinition);//add it to beanDefinitionMap
}

resetBeanDefinition(beanName); //reset all exist
}

3，查找，通过getbean获得bean，用ConfigurableListableBeanFactory，如DefaultListableBeanFactory

这部分功能主要在abstractbeanfactory中完成，如果是singleton（即spring的default）

i transformedBeanName(name) ，得到SimpleAliasRegistry 的 map 属性 aliasMap，转换为beanname（别名功能）

ii Object sharedInstance = getSingleton(beanName); 尝试从DefaultSingletonBeanRegistry的MAP singletonObjects中拿出bean (singleton功能)

iii bean = getObjectForBeanInstance(sharedInstance, name, beanName, null) 处理factorybean部分，附 Spring FactoryBean源码浅析

iv final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName); 从bean注册的信息中找到bean 对应的 BeanDefinition

v return createBean(beanName, mbd, args); 创建新的bean，通过BeanDefinition的描述信息来，并填充到DefaultSingletonBeanRegistry的singletonObjects中

beanfactory的主要代码，加上了些注释

/**
* Return an instance, which may be shared or independent, of the specified bean.
* @param name the name of the bean to retrieve
* @param requiredType the required type of the bean to retrieve
* @param args arguments to use if creating a prototype using explicit arguments to a
* static factory method. It is invalid to use a non-null args value in any other case.
* @param typeCheckOnly whether the instance is obtained for a type check,
* not for actual use
* @return an instance of the bean
* @throws BeansException if the bean could not be created
*/
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
throws BeansException {
final String beanName = transformedBeanName(name); //get true name from attribute aliasMap of SimpleAliasRegistry
Object bean;
// Eagerly check singleton cache for manually registered singletons.
Object sharedInstance = getSingleton(beanName); //get instance object from the attribute singletonObjects of DefaultSingletonBeanRegistry
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 + "'");
}
}
bean = getObjectForBeanInstance(sharedInstance, name, beanName, null); // it is for that class witch is implement interface factorybean
}

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

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);//get BeanDefinition from registered information
checkMergedBeanDefinition(mbd, beanName, args);

// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
for (String dependsOnBean : dependsOn) {
getBean(dependsOnBean);
registerDependentBean(dependsOnBean, beanName);
}
}

// Create bean instance.
if (mbd.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
//create new instance and put in attribute map singletonObjects of DefaultSingletonBeanRegistry
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()) {
// 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();
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>() {
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);
}
}
}

// Check if required type matches the type of the actual bean instance.
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;
}

附 bean中的主要结构

主要类，下列类从上往下继承

SimpleAliasRegistry 用于维护一个 aliasMap，维护别名功能

DefaultSingletonBeanRegistry map 维护 singletonObjects，维护工厂单例，一个工厂一个单例，非N个工厂一个单例

FactoryBeanRegistrySupport，

AbstractBeanFactory ，factorybean的主要实现类，其doGetBean,getBean是主要获得bean的入口 ，维护一个mergedBeanDefinitions

AbstractAutowireCapableBeanFactory,configureableBeanFactory的主要实现类, createBean根据beandefine的信息创建相应的值

DefaultListableBeanFactory ConfigurableListableBeanFactory和BeanDefinitionRegistry接口的主要实现类，维护beanDefiniti信息

主要接口关系如下





Parse XML主要用到的几个相关类

* @see DocumentLoader
* @see DefaultDocumentLoader

TODO 对SAX几个工厂属性进行设置，schema等，调用SAX对XML转换成了DOC对象

* @see BeanDefinitionDocumentReader
* @see DefaultBeanDefinitionDocumentReader

提供registerBeanDefinitions，和setEnvironment方法，用于DOC到beandefine的注册功能，遍历了doc的所有node，调用 BeanDefinitionParserDelegate解析node,并调用BeanDefinitionReaderUtils对解析的beandefine到beandefine注册类的注册

* @BeanDefinitionParserDelegate

主要解析类，各种属性，对beandefine对象属性的设置都是在此类完成

bean中ConfigurableListableBeanFactory接口继承了bean中的基本接口，DefaultListableBeanFactory是其唯一实现类，也是预留接口供扩展

接口因为可以多继承，所以用来表示系统的结构最合适不过，而JAVA中类单继承的，一般只是用来实现设计，侧重实现功能，因为类层次肯定是一条线。