spring IOC:DefaultListableBeanFactory

DefaultSingletonBeanRegistry完成对单例bean的控制
AbstractBeanFactory完成对不同getBean请求的响应，查询Bean定义及销毁方法的注册
AbstractAutowireCapableBeanFactory完成Bean的创建，属性的注入，切面代理的产生，bean的生命周期的管理
最后由DefaultListableBeanFactory提供registerBeanDefinition方法完成bean定义的注册
[code]
public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)throws BeanDefinitionStoreException {

if (beanDefinition instanceof AbstractBeanDefinition) {
try {
((AbstractBeanDefinition) beanDefinition).validate();
}
catch (BeanDefinitionValidationException ex) {
//.....
}
}

Object oldBeanDefinition = this.beanDefinitionMap.get(beanName);
if (oldBeanDefinition != null) {
if (!this.allowBeanDefinitionOverriding) {
//.....

}
else {
this.beanDefinitionNames.add(beanName);
}
this.beanDefinitionMap.put(beanName, beanDefinition);
removeSingleton(beanName);
}
[/code]
Spring采用这样层层继承的结构，逐步完成IOC容器的各个功能。

XmlBeanFactory继承自DefaultListableBeanFactory，由它和XmlBeanDefinitionReader完成资源的读取工作。

XmlBeanFactory：
[code]
public XmlBeanFactory(Resource resource) throws BeansException {
this(resource, null);
}
public XmlBeanFactory(Resource resource, BeanFactory parentBeanFactory) throws BeansException {
super(parentBeanFactory);
this.reader.loadBeanDefinitions(resource);
}
[/code]
这里reader.loadBeanDefinitions(resource);
接下来
[code]
//调用doLoadBeanDefinitions方法
loadBeanDefinitions(EncodedResource encodedResource)
//验证读取xml配置文件，嗲用registerBeanDefinitions方法
doLoadBeanDefinitions(inputSource, encodedResource.getResource());
//调用documentReader.registerBeanDefinitions方法，由默认的documentReader对象解析xml
registerBeanDefinitions
[/code]
最后在registerBeanDefinitions方法中，有具体的BeanDefinitionParserDelegate来完成bean的注册工作
[code]
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);
}
[/code]
在parseBeanDefinitions(root, delegate);我们找到了->
BeanDefinitionReaderUtils.registerBeanDefinition(bdHolder, getReaderContext().getRegistry());
这是最后注册bean定义的方法，在这个方法中会调用DefaultListableBeanFactory提供的
registerBeanDefinition(beanName, bdHolder.getBeanDefinition());这个方法。

还要提到的就是这个ApplicationContext请看其类图
[img]http://whoknow.iteye.com/upload/picture/pic/47291/51f7c0ee-f931-3982-8a60-d5dd524859e6.jpg[/img]
AbstractApplicationContext中的refresh()方法做为一个模板方法详细描述了整个容器的启动过程。同时在实现了BeanFactory ，ListableBeanFactory ,HierarchicalBeanFactory它作为一个IOC容器的门面，来负责IOC容器的具体运行。

[color=red]注意在这里AbstractRefreshableApplicationContext直接持有了对DefaultListableBeanFactory的引用[/color]

回看一下它的IOC容器的图
[img]http://dl.iteye.com/upload/picture/pic/47039/766b6cea-8f02-34fb-8d19-ec6b922c25fd.jpg[/img]
[code]

一些对IOC容器直接操作的方法
//---------------------------------------------------------------------
// Implementation of BeanFactory interface
//---------------------------------------------------------------------
public Object getBean(String name) throws BeansException {
return getBeanFactory().getBean(name);
}

public Object getBean(String name, Class requiredType) throws BeansException {
return getBeanFactory().getBean(name, requiredType);
}

public boolean containsBean(String name) {
return getBeanFactory().containsBean(name);
}

public boolean isSingleton(String name) throws NoSuchBeanDefinitionException {
return getBeanFactory().isSingleton(name);
}

public Class getType(String name) throws NoSuchBeanDefinitionException {
return getBeanFactory().getType(name);
}

public String[] getAliases(String name) {
return getBeanFactory().getAliases(name);
}
//---------------------------------------------------------------------
// Implementation of ListableBeanFactory interface
//---------------------------------------------------------------------

public boolean containsBeanDefinition(String name) {
return getBeanFactory().containsBeanDefinition(name);
}

public int getBeanDefinitionCount() {
return getBeanFactory().getBeanDefinitionCount();
}

public String[] getBeanDefinitionNames() {
return getBeanFactory().getBeanDefinitionNames();
}

public String[] getBeanNamesForType(Class type) {
return getBeanFactory().getBeanNamesForType(type);
}

public String[] getBeanNamesForType(Class type, boolean includePrototypes, boolean allowEagerInit) {
return getBeanFactory().getBeanNamesForType(type, includePrototypes, allowEagerInit);
}

public Map getBeansOfType(Class type) throws BeansException {
return getBeanFactory().getBeansOfType(type);
}

public Map getBeansOfType(Class type, boolean includePrototypes, boolean allowEagerInit)
throws BeansException {

return getBeanFactory().getBeansOfType(type, includePrototypes, allowEagerInit);
}
//---------------------------------------------------------------------
// Implementation of HierarchicalBeanFactory interface
//---------------------------------------------------------------------

public BeanFactory getParentBeanFactory() {
return getParent();
}

public boolean containsLocalBean(String name) {
return getBeanFactory().containsLocalBean(name);
}
[/code]
这个 refresh()描述了整个容器的启动过程，提供了很多抽象方法，由子类来实现，层层向下
[code]
public void refresh() throws BeansException, IllegalStateException {
synchronized (this.startupShutdownMonitor) {
this.startupTime = System.currentTimeMillis();

synchronized (this.activeMonitor) {
this.active = true;
}

//由子类AbstractRefreshableApplicationContext实现，创建IOC容器，并调用loadBeanDefinitions方法（该方法继续由具体子类来完成）
refreshBeanFactory();
ConfigurableListableBeanFactory beanFactory = getBeanFactory();

//设置类加载器
beanFactory.setBeanClassLoader(getClassLoader());


beanFactory.addPropertyEditorRegistrar(new ResourceEditorRegistrar(this));

beanFactory.addBeanPostProcessor(new ApplicationContextAwareProcessor(this));
beanFactory.ignoreDependencyInterface(ResourceLoaderAware.class);
beanFactory.ignoreDependencyInterface(ApplicationEventPublisherAware.class);
beanFactory.ignoreDependencyInterface(MessageSourceAware.class);
beanFactory.ignoreDependencyInterface(ApplicationContextAware.class);

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

//启动工厂前处理器
for (Iterator it = getBeanFactoryPostProcessors().iterator(); it.hasNext();) {
BeanFactoryPostProcessor factoryProcessor = (BeanFactoryPostProcessor) it.next();
factoryProcessor.postProcessBeanFactory(beanFactory);
}

if (logger.isInfoEnabled()) {
if (getBeanDefinitionCount() == 0) {
logger.info("No beans defined in application context [" + getDisplayName() + "]");
}
else {
logger.info(getBeanDefinitionCount() + " beans defined in application context [" + getDisplayName() + "]");
}
}

try {
// 注册beanFactory处理器
invokeBeanFactoryPostProcessors();

//注册bean处理器
registerBeanPostProcessors();

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

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

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

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

// Instantiate singletons this late to allow them to access the message source.
beanFactory.preInstantiateSingletons();

// Last step: publish corresponding event.
publishEvent(new ContextRefreshedEvent(this));
}

catch (BeansException ex) {
beanFactory.destroySingletons();
throw ex;
}
}
}
[/code]
AbstractRefreshableApplicationContext提供了创建IOC容器的方法
[code]
protected DefaultListableBeanFactory createBeanFactory() {
return new DefaultListableBeanFactory(getInternalParentBeanFactory());
}
[/code]
其它的诸如AbstractXmlApplicationContext类则提供了读取资源文件等方法，逐层完成整个功能