spring IOC:AbstractBeanFactory

接上篇[url]http://whoknow.iteye.com/blog/487786[/url]
DefaultSingletonBeanRegistry可以简单的管理bean但是做为一个ioc容器来讲它的功能还远远不够。比如，在一个应用中，一些bean是始终存在的，一些则是随着当前线程的结束而结束，做为一个容器来讲，它需要可以管理整个bean的生命周期

[code]
public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements ConfigurableBeanFactory {
[/code]

AbstractBeanFactory继承了DefaultSingletonBeanRegistry类，并进一步丰富了已有的功能，这个类提供了singleton/prototype的选择，单例cache,对于FactoryBean的处理，bean定义的处理以及bean 的销毁…
其中比较重要的功能是对BeanFactory中getBean方法的实现
[code]
public Object getBean(String name) throws BeansException {
return getBean(name, null, null);
}

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

public Object getBean(String name, Object[] args) throws BeansException {
return getBean(name, null, args);
}
[/code]

几个连续的重载，我们关心的是最后这个
[code]
public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {
[/code]
然后一点一点看这个方法，假如给自己这样一个问题，我们首先会做什么？这个方法打算写些什么呢？
很显然，在我们的父类DefaultSingletonBeanRegistry中，已经有了一些对于bean的操作的实现，比如getSingleton方法，让我们可以拿到一个bean,于是
[code]
Object sharedInstance = getSingleton(beanName);
if (sharedInstance != null) {
//一个简单的判断，先看一眼，map里是否有这个类了
//如果有的话呢？直接返回？好像不太好，因为这个类可能是一个工厂类，所以我们还需要一个方法判断下，如果是工厂类的话，那么它应该返回一个产品
bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
}
[/code]
看一下getObjectForBeanInstance这个方法
[code]
protected Object getObjectForBeanInstance(Object beanInstance, String name, RootBeanDefinition mbd)throws BeansException {

//这里略去了很多代码，只是把最关键的几行取出
if (beanInstance instanceof FactoryBean) {
FactoryBean factory = (FactoryBean) beanInstance;
object = getObjectFromFactoryBean(factory, beanName, mbd);
}
return object;
}
[/code]
那么这个getObjectFromFactoryBean方法又是？从参数来看，我们发现了一个factory，实际上在这个方法中会调用它
[code]
object = factory.getObject();
//之后
return object
[/code]

FactoryBean这个接口在DefaultSingletonBeanRegistry中的 public Object getSingleton(String beanName, ObjectFactory singletonFactory)方法中也出现过，由一个实现了FactoryBean的工厂来产生这个类

在if (sharedInstance != null) {}判断完成后，即我们当前没有这个类，接下来呢？这时该由容器将这个类实例化了，所以在}else之后
先判断是否有父容器，如果有则由父容器生产它
BeanFactory parentBeanFactory = getParentBeanFactory();
这里会调用父容器的getBean方法

如果没有则我们要创建这个类，spring在启动时首先会通过ResourceLoader读取其配置文件，然后由BeanDefinitionReader进行读取并保存到BeanDefinitionRegistry中。之后会对这些定义进行处理，这些beandefine中放置的就是xml的基本信息，如:class,scope,等等属性，结构如图：
[img]http://whoknow.iteye.com/upload/picture/pic/47057/3fd75fd4-21ea-38ab-86b6-db997f29ac9d.jpg[/img]

[code]
//得到bean的定义
final RootBeanDefinition mergedBeanDefinition = getMergedBeanDefinition(beanName, false);
先拿到Bean的定义
getMergedBeanDefinition：还是先检查是否有父容器，有就调用父容器的getMergedBeanDefinition方法，没有调用当前的
protected RootBeanDefinition getMergedBeanDefinition(String name, boolean includingAncestors)
throws BeansException {
String beanName = transformedBeanName(name);
if (includingAncestors && !containsBeanDefinition(beanName) &&
getParentBeanFactory() instanceof AbstractBeanFactory) {
return ((AbstractBeanFactory) getParentBeanFactory()).getMergedBeanDefinition(beanName, true);
}
return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}
[/code]
那么getMergedBeanDefinition中呢？这里主要就是拿到它的rootbean,如果是children则调用cbd.getParentName()方法最后返回root的定义.

这里return getMergedBeanDefinition(beanName,getBeanDefinition(beanName));
getBeanDefinition是一个抽象方法
protected abstract BeanDefinition getBeanDefinition(String beanName)
由具体的子类来实现.

一个类一个责任，AbstractBeanFactory的主要职责是bean的管理，其它职责由其子类完成，如：createBean, postProcessObjectFromFactoryBean, getBeanDefinition
Spring的设计清晰易读，很大程度上都是由于类的职责划分清晰造成的。BeanFactory 是一个基本的描述，接下来我们希望这个容器可以实现上下文关系，对一个类最简单的一些操作，所以就有了SingletonBeanRegistry，HierarchicalBeanFactory接口。然后再层层向下，通过接口描述主要的组件功能，具体类进行实现

拿到这个bean的定义后，就可以实例化它了
如果是一个单例：
[code]
if (mergedBeanDefinition.isSingleton()) {
sharedInstance = getSingleton(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
try {
//createBean由其子类AbstractAutowireCapableBeanFactory来实现
return createBean(beanName, mergedBeanDefinition, args);
}
catch (BeansException ex) {
destroySingleton(beanName);
throw ex;
}
}
});
//这里再次判断，如果该类是一个工厂则调用其getObject()方法
bean = getObjectForBeanInstance(sharedInstance, name,mergedBeanDefinition);
}
[/code]

这里使用了一个回调方法，在父类的DefaultSingletonBeanRegistry中的public Object getSingleton(String beanName, ObjectFactory singletonFactory) 需要一个ObjectFactory，我们用一个匿名类写入方法，并调用其子类的createBean方法，在这里createBean是AbstractBeanFactory的抽象方法

如果是Prototype的话：
[code]
if (mergedBeanDefinition.isPrototype()) {
Object prototypeInstance = null;
try {
beforePrototypeCreation(beanName);
prototypeInstance = createBean(beanName, mergedBeanDefinition, args);
}
finally {
afterPrototypeCreation(beanName);
}
// 又判断它是不是工厂类
bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);
}
[/code]

最后如果既不是Singleton也不是Prototype时，首先拿它的scope
[code]
String scopeName = mergedBeanDefinition.getScope();
final Scope scope = (Scope) this.scopes.get(scopeName);
…
try {
scope的get回调方法得到实例
Object scopedInstance = scope.get(beanName, new ObjectFactory() {
public Object getObject() throws BeansException {
beforePrototypeCreation(beanName);
try {
Object bean = createBean(beanName, mergedBeanDefinition, args);
if (requiresDestruction(bean, mergedBeanDefinition)) {
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));
}
return bean;
}
finally {
afterPrototypeCreation(beanName);
}
}
});
bean = getObjectForBeanInstance(scopedInstance, name, mergedBeanDefinition);
}
catch (IllegalStateException ex) {
throw new BeanCreationException(beanName, "Scope '" + scopeName + "' is not active", ex);
}
[/code]

这里有一行代码
[code]
scope.registerDestructionCallback(beanName,
new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));
[/code]

注册它的销毁方法
[code]
public void registerDestructionCallback(String name, Runnable callback) {
RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
attributes.registerDestructionCallback(name, callback, getScope());
}
[/code]
在这里首先通过RequestContextHolder得到当前的RequestAttributes。在RequestContextHolder中requestAttributesHolder 为ThreadLocal
之后在ServletRequestAttributes注册其回调销毁方法最后
[code]
private void executeRequestDestructionCallbacks() {
for (Iterator it = this.requestDestructionCallbacks.values().iterator(); it.hasNext();) {
((Runnable) it.next()).run();
}
}

[/code]

可以看到在DisposableBeanAdapter中
[code]
public void run() {
destroy();
}
[/code]
首先beanPostProcessors执行所有的DestructionAwareBeanPostProcessor，最后在最后执行invokeCustomDestroyMethod();所以客户定义的销毁方式是在最后的
[code]
public void destroy() {
if (this.beanPostProcessors != null) {
if (logger.isDebugEnabled()) {
logger.debug("Applying DestructionAwareBeanPostProcessors to bean with name '" + this.beanName + "'");
}
for (int i = this.beanPostProcessors.size() - 1; i >= 0; i--) {
Object beanProcessor = this.beanPostProcessors.get(i);
if (beanProcessor instanceof DestructionAwareBeanPostProcessor) {
((DestructionAwareBeanPostProcessor) beanProcessor).postProcessBeforeDestruction(this.bean, this.beanName);
}
}
}

if (this.bean instanceof DisposableBean) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking destroy() on bean with name '" + this.beanName + "'");
}
try {
((DisposableBean) this.bean).destroy();
}
catch (Throwable ex) {
logger.error("Couldn't invoke destroy method of bean with name '" + this.beanName + "'", ex);
}
}

if (this.mergedBeanDefinition != null) {
invokeCustomDestroyMethod();
}
}
[/code]