前言
前面两篇文章主要介绍的是xml到BeanDefinition的过程，我们知道在使用Spring的过程中通常直接使用getBean(beanName)的方式，getBean返回的是实例化并且已经完成初始化后的对象。对于我们平时使用来说，创建一个对象通常会使用new,或者使用反射。我们使用反射instantiation对象，使用反射填充field，使用反射调用init方法，最终得到对象使用。Spring也是采用的同样的过程，只不过过程更为复杂，考虑的异常情况更多。
抽丝剥茧出主干也就是：
根据BeanDefinition的信息找到对象构造器，实例化对象
根据BeanDefinition的信息找到属性值，填充之
-
如果有初始化方法，调用初始化方法
当然上述主干主要讲的是非单例对象，如果是单例对象创建一次之后需要保证其唯一性，而以上三步每一步在Spring中都很复杂，本文只是分析一个大体过程，而每个小点将放在以后的博文中进行详细讲解，目前规划好的小点有：
Spring对于循环依赖问题的解决
Spring属性填充过程
Spring在Bean创建过程中提供的扩展点及事件监听
Spring的initiation过程及一种并行初始化的实现。
getBean的主干
抽出BeanFactory.getBean的主干如下：
在本文中只讨论单例对象(默认scope，非factoryBean类)的创建过程
贴一段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.
Object sharedInstance = getSingleton(beanName);
...
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);
}
这段代码描述的过程很简单，首先进行transformedBeanName(name)转换beanName，然后试着调用getSingleton(beanName)， getSingleton(beanName）是从一个缓存的singletonObjects Map中查询(如果没有拿到其实还会去earlySingletonObjects中拿，这个是为了解决循环依赖，在后面的博文中详细叙述)，这个Map保存着已经创建好的单例对象。在如果没有拿到缓存对象的情况下，会继续getSingleton(beanName, singletonFactory)方法。
getSingleton(beanName, singletonFactory)这个方法是一个比较让人疑惑的地方，Spring传进去了一个ObjectFactory匿名内部类，该类override了getObject()方法，getObject实际上是createBean。在getSingleton(beanName, singletonFactory)方法中会调用getObject(),实际上也就是调用了createBean，bean的创建实际上是从这个地方开始的。
这种实现方式让人很费解，很可能仅仅是为了抽出ObjectFactory接口，这个接口有个getObject方法，顾名思义是为了获取Object，当然获取Object的形式有很多，可以返回同一个创建好的对象，可以每次都新建一个对象。在解决循环依赖问题的时候Spring也用了一个ObjectFactory匿名内部类，后面的博文会讲到
让我们看一看getSingleton(beanName, singletonFactory)这个方法究竟干了什么
synchronized (this.singletonObjects) {
Object singletonObject = this.singletonObjects.get(beanName);
if (singletonObject == null) {
if (this.singletonsCurrentlyInDestruction) {
throw new BeanCreationNotAllowedException(beanName, "Singleton bean creation not allowed while the singletons of this factory are in destruction " + "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
}
if (logger.isDebugEnabled()) {
logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
}
beforeSingletonCreation(beanName);
boolean newSingleton = false;
boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
if (recordSuppressedExceptions) {
this.suppressedExceptions = new LinkedHashSet<Exception>();
}
try {
singletonObject = singletonFactory.getObject();
newSingleton = true;
}
...删掉了异常处理
finally {
if (recordSuppressedExceptions) {
this.suppressedExceptions = null;
}
afterSingletonCreation(beanName);
}
if (newSingleton) {
addSingleton(beanName, singletonObject);
}
}
return (singletonObject != NULL_OBJECT ? singletonObject : null); }}
在去掉异常处理后，这段代码非常的简单，首先从singletonObjects map里试着拿bean，如果拿不到的话调用singletonFactory.getObject()，在这里表现为createBean()，最后如果是新创建的singleton，调用addSingleton(beanName, singletonObject)将新创建的对象保存到singletonObjects Map中便于下次使用。
createBean
createBean主要负责创建对象，它将责任委派给了doCreateBean，其主干代码如下：
BeanWrapper instanceWrapper = null;
if (mbd.isSingleton()) {
instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
if (instanceWrapper == null) {
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;
}
}
try {
populateBean(beanName, mbd, instanceWrapper);
if (exposedObject != null) {
exposedObject = initializeBean(beanName, exposedObject, mbd);
}
}
if (earlySingletonExposure) {
Object earlySingletonReference = getSingleton(beanName, false);
}
try {
registerDisposableBeanIfNecessary(beanName, bean, mbd);
}
抽去一些不太重要的代码只有，整个逻辑非常清楚，首先createBeanInstance创建对象，然后填充对象populateBean，最后调用初始化方法initializeBean，和我们使用反射创建对象的常用流程差不多，只不过这三个函数都异常的复杂，在后面的博文中会分别介绍
总结
这篇文章只是大体介绍了getBean的主干部分，各个细节的部分后面的博文会详细讲解！
