Spring getBean实例化过程

单例bean实例保存在DefaultSingletonBeanRegistry类的ConcurrentHashMap<String, Object>(256);中

1、根据bean名称从缓存中查询，如果查询到再进行判断是否FactoryBean，如果不是直接返回实例；如果是FactoryBean，再判断是否取FactoryBean本身，如果是直接返回，否则调用FactoryBean工厂的getObject方法取得实例bean.

2、判断Beandefintion是否当前工厂可以取得到是否有双亲工厂，如果有双亲工厂从双亲取getBean.

3、根据Beandefiniton取得依赖Bean信息数组，遍历数组，通过getBean 方法递归实例化依赖bean。

4、实例化依赖bean之后，如果是单例进行进行创建bean实例后并保存到ConcurrentHashMap。

bean实例化过程中生命周期：

AbstractAutowireCapableBeanFactory类initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd)方法

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {
if (System.getSecurityManager() != null) {
AccessController.doPrivileged(new PrivilegedAction<Object>() {
@Override
public Object run() {
invokeAwareMethods(beanName, bean);
return null;
}
}, getAccessControlContext());
}
else {

//通过检测bean是否实现了*aware类接口，来调用实现的接口方法把相关的通知BeanNameAware、BeanClassLoaderAware、BeanFactoryAware赋值给bean。

invokeAwareMethods(beanName, bean);
}


Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {

//调用bean的后处理器初始化之前的方法，通过轮询保存bean后处理器的list，调用每个bean后处理器的postProcessBeforeInitialization方法。
wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}


try {

//调用的初始化方法
invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
throw new BeanCreationException(
(mbd != null ? mbd.getResourceDescription() : null),
beanName, "Invocation of init method failed", ex);
}
//调用bean的后处理器初始化之后的方法

if (mbd == null || !mbd.isSynthetic()) {
wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
}
return wrappedBean;
}

private void invokeAwareMethods(final String beanName, final Object bean) {
if (bean instanceof Aware) {
if (bean instanceof BeanNameAware) {
((BeanNameAware) bean).setBeanName(beanName);
}
if (bean instanceof BeanClassLoaderAware) {
((BeanClassLoaderAware) bean).setBeanClassLoader(getBeanClassLoader());
}
if (bean instanceof BeanFactoryAware) {
((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
}
}
}

public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)
throws BeansException {

               
Object result = existingBean;

//getBeanPostProcessors返回通过 ArrayList<BeanPostProcessor>保存的bean后处理器，bean处理器的注册时在AbstractRefreshableApplicationContext类的 refresh()方法里注册的bean的后置处理器
for (BeanPostProcessor beanProcessor : getBeanPostProcessors()) {
result = beanProcessor.postProcessBeforeInitialization(result, beanName);
if (result == null) {
return result;
}
}
return result;
}

//调用初始化方法

protected void invokeInitMethods(String beanName, final Object bean, RootBeanDefinition mbd)
throws Throwable {


boolean isInitializingBean = (bean instanceof InitializingBean);
if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
if (logger.isDebugEnabled()) {
logger.debug("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
}
if (System.getSecurityManager() != null) {
try {
AccessController.doPrivileged(new PrivilegedExceptionAction<Object>() {
@Override
public Object run() throws Exception {
((InitializingBean) bean).afterPropertiesSet();
return null;
}
}, getAccessControlContext());
}
catch (PrivilegedActionException pae) {
throw pae.getException();
}
}
else {//调用初始化接口的初始化方法
((InitializingBean) bean).afterPropertiesSet();
}
}


if (mbd != null) {
String initMethodName = mbd.getInitMethodName();//调用配置文件定义的初始化方法
if (initMethodName != null && !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
!mbd.isExternallyManagedInitMethod(initMethodName)) {
invokeCustomInitMethod(beanName, bean, mbd);
}
}
}