Bean的创建生命周期

BeanDefinition生成

Spring在启动时，需要先扫描到需要创建的类，将这些类解析为Bean定义(Bean定义了Bean的一些创建信息，如是否单例，是否懒加载，beanClass等)，生成好的Bean定义存储在beanDefinitionMap中，此时的BeanClass还是类名字符串(如: "com.heoller.entity.User")，没有加载成Class对象。

// org.springframework.beans.factory.support.DefaultListableBeanFactory
private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

RootBeanDefinition生成

/*
 * 合并bean定义, 生成RootBeanDefinition。
 * <bean id="commonBean" abstract="true" scope="prototype" />
 * <!-- 此时user的scope属性将会是prototype -->
 * <bean id="user" class="com.heoller.entity.User" parent="commonBean" />
 */
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);

加载beanClass

// 加载beanClass并返回Class对象
Class<?> resolvedClass = resolveBeanClass(mbd, beanName);

执行实例化前的BeanPostProcessors

Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
// 实例化前执行InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation
protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
  for (BeanPostProcessor bp : getBeanPostProcessors()) {
    if (bp instanceof InstantiationAwareBeanPostProcessor) {
      InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
      Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
      if (result != null) {
        return result;
      }
    }
  }
  return null;
}

选择构造方法

实例化

根据构造方法反射创建实例

RootBeanDefinition后置处理器

可以通过这个后置处理器完成BeanDefinition的修改，比如: 修改bean的初始化方法、propertyValues等，作用于Bean的初始化阶段。

// org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#applyMergedBeanDefinitionPostProcessors
MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition

填充属性

org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory#populateBean

执行Aware

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

执行初始化前的BeanPostProcessors

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

  Object result = existingBean;
  for (BeanPostProcessor processor : getBeanPostProcessors()) {
    // CommonAnnotationBeanPostProcessor会处理@PostConstruct注解方法
    // ApplicationContextAwareProcessor会执行各种Aware方法
    Object current = processor.postProcessBeforeInitialization(result, beanName);
    if (current == null) {
      return result;
    }
    result = current;
  }
  return result;
}

执行初始化方法

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

  boolean isInitializingBean = (bean instanceof InitializingBean);
  if (isInitializingBean && (mbd == null || !mbd.isExternallyManagedInitMethod("afterPropertiesSet"))) {
    if (logger.isTraceEnabled()) {
      logger.trace("Invoking afterPropertiesSet() on bean with name '" + beanName + "'");
    }
    if (System.getSecurityManager() != null) {
      try {
        AccessController.doPrivileged((PrivilegedExceptionAction<Object>) () -> {
          ((InitializingBean) bean).afterPropertiesSet();
          return null;
        }, getAccessControlContext());
      }
      catch (PrivilegedActionException pae) {
        throw pae.getException();
      }
    }
    else {
      ((InitializingBean) bean).afterPropertiesSet();
    }
  }

  if (mbd != null && bean.getClass() != NullBean.class) {
    String initMethodName = mbd.getInitMethodName();
    if (StringUtils.hasLength(initMethodName) &&
        !(isInitializingBean && "afterPropertiesSet".equals(initMethodName)) &&
        !mbd.isExternallyManagedInitMethod(initMethodName)) {
      invokeCustomInitMethod(beanName, bean, mbd);
    }
  }
}

执行初始化后的BeanPostProcessors

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

  Object result = existingBean;
  for (BeanPostProcessor processor : getBeanPostProcessors()) {
    Object current = processor.postProcessAfterInitialization(result, beanName);
    if (current == null) {
      return result;
    }
    result = current;
  }
  return result;
}