spring IOC:AbstractBeanFactory

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

public abstract class AbstractBeanFactory extends DefaultSingletonBeanRegistry implements ConfigurableBeanFactory {

AbstractBeanFactory继承了DefaultSingletonBeanRegistry类，并进一步丰富了已有的功能，这个类提供了singleton/prototype的选择，单例cache,对于FactoryBean的处理，bean定义的处理以及bean 的销毁…
其中比较重要的功能是对BeanFactory中getBean方法的实现

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

几个连续的重载，我们关心的是最后这个

public Object getBean(String name, Class requiredType, final Object[] args) throws BeansException {

然后一点一点看这个方法，假如给自己这样一个问题，我们首先会做什么？这个方法打算写些什么呢？
很显然，在我们的父类DefaultSingletonBeanRegistry中，已经有了一些对于bean的操作的实现，比如getSingleton方法，让我们可以拿到一个bean,于是

	Object sharedInstance = getSingleton(beanName);
	if (sharedInstance != null) {
		//一个简单的判断，先看一眼，map里是否有这个类了
		//如果有的话呢？直接返回？好像不太好，因为这个类可能是一个工厂类，所以我们还需要一个方法判断下，如果是工厂类的话，那么它应该返回一个产品
		bean = getObjectForBeanInstance(sharedInstance, name, mergedBeanDefinition);
}

看一下getObjectForBeanInstance这个方法

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

那么这个getObjectFromFactoryBean方法又是？从参数来看，我们发现了一个factory，实际上在这个方法中会调用它

	object = factory.getObject();
         //之后
          return object

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,等等属性，结构如图：

//得到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));
	}

那么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的定义后，就可以实例化它了
如果是一个单例：

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

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

如果是Prototype的话：

if (mergedBeanDefinition.isPrototype()) {
				Object prototypeInstance = null;
				try {
					beforePrototypeCreation(beanName);
					prototypeInstance = createBean(beanName, mergedBeanDefinition, args);
				}
				finally {
					afterPrototypeCreation(beanName);
				}
				// 又判断它是不是工厂类
				bean = getObjectForBeanInstance(prototypeInstance, name, mergedBeanDefinition);
			}

最后如果既不是Singleton也不是Prototype时，首先拿它的scope

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

这里有一行代码

scope.registerDestructionCallback(beanName,
											new DisposableBeanAdapter(bean, beanName, mergedBeanDefinition, getBeanPostProcessors()));

注册它的销毁方法

public void registerDestructionCallback(String name, Runnable callback) {
		RequestAttributes attributes = RequestContextHolder.currentRequestAttributes();
		attributes.registerDestructionCallback(name, callback, getScope());
	}

在这里首先通过RequestContextHolder得到当前的RequestAttributes。在RequestContextHolder中requestAttributesHolder 为ThreadLocal
之后在ServletRequestAttributes注册其回调销毁方法最后

private void executeRequestDestructionCallbacks() {
		for (Iterator it = this.requestDestructionCallbacks.values().iterator(); it.hasNext();) {
			((Runnable) it.next()).run();
		}
}

可以看到在DisposableBeanAdapter中

public void run() {
		destroy();
	}

首先beanPostProcessors执行所有的DestructionAwareBeanPostProcessor，最后在最后执行invokeCustomDestroyMethod();所以客户定义的销毁方式是在最后的

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