Spring中Bean的範例化詳細流程

AbstractApplicationContext.refresh()

// Instantiate all remaining (non-lazy-init) singletons.
 // 翻譯一下就是 範例化所有非懶載入的Bean
finishBeanFactoryInitialization(beanFactory);

DefaultListableBeanFactory.preInstantiateSingletons()。
@Override
 public void preInstantiateSingletons() throws BeansException {

    // Iterate over a copy to allow for init methods which in turn register new bean definitions.
    // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
    // 獲取所有的要範例化的Bean的名稱
    List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
    // Trigger initialization of all non-lazy singleton beans...
    // 開始初始化單例的Bean
    for (String beanName : beanNames) {
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
       // Bean 不是抽象的，是單例的，不是懶載入的進入如下分支
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
        // 如果是FactoryBean進入此分支。本次只聊自己開發寫的非FactoryBean
        // 所以聊else下面的分支。
        if (isFactoryBean(beanName)) {
        // FactoryBean的名稱很特別
          Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
          if (bean instanceof FactoryBean) {
            final FactoryBean<?> factory = (FactoryBean<?>) bean;
            boolean isEagerInit;
            if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
              isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                      ((SmartFactoryBean<?>) factory)::isEagerInit,
                  getAccessControlContext());
            }
            else {
              isEagerInit = (factory instanceof SmartFactoryBean &&
                  ((SmartFactoryBean<?>) factory).isEagerInit());
            }
            if (isEagerInit) {
              getBean(beanName);
            }
          }
        }
        else {
         // 非 FactoryBean進入此分支
          getBean(beanName);
        }
      }
    }
  }

AbstractBeanFactory.doGetBean() 的方法。
protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
      @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {
    //  這個方法主要是獲取Bean的名稱，一些Bean的名稱可能命名的比較特別
    // 需要進行轉換。
    final String beanName = transformedBeanName(name);
    Object bean;
    // Eagerly check singleton cache for manually registered singletons.
    // 首先先從容器的快取中獲取Bean,如果容器中已經存在，直接返回。
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    } 
    else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      // 先檢查這個Bean是否在建立中，如果在建立中丟擲異常 
      if (isPrototypeCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
      }
       // 標記Bean為正在建立中。
      if (!typeCheckOnly) {
        markBeanAsCreated(beanName);
      }
      try {
        // Create bean instance.
        //  如果Bean是單例開始建立Bean .
        //  後面判斷還有Prototype（多例）不是要講的重點，程式碼刪除了。
        if (mbd.isSingleton()) {
        //  這個方法是Java 8的 lambda 寫法，這個方法裡面會把建立好的
        // Bean放到Spring容器中，後面再獲取這個Bean直接從容器中獲取了。
          sharedInstance = getSingleton(beanName, () -> {
            try {
            // 正式開始建立Bean 。
              return createBean(beanName, mbd, args);
            }
            catch (BeansException ex) {
            // 建立過程出現異常，銷燬Bean
              destroySingleton(beanName);
              throw ex;
            }
          });
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
    return (T) bean;
  }

AbstractAutowireCapableBeanFactory.createBean() 的方法。
@Override
  protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
    RootBeanDefinition mbdToUse = mbd;
    try {
     // doCreateBean 是Spring正在做事的方法。
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
  }
  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
    // Instantiate the bean.
    //  範例化Bean 先建立一個BeanWrapper .這個方法裡面Spring 一般為預設
    // 無參的構造方法建立物件，所以大家如果重寫物件的構造方法的時候，一定
    // 要把無參構造方法也寫出來。要不然某些情況下啟動Spring容器可能會報錯。
    if (instanceWrapper == null) {
      instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
    // 為Bean的屬性賦值。
      populateBean(beanName, mbd, instanceWrapper);
      // 初始化Bean 。
      exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    return exposedObject;
  }
  // 初始化Bean。
  protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
    // 如果你的Bean實現了Spring內建的Aware方法，會在這裡執行
    invokeAwareMethods(beanName, bean);
    Object wrappedBean = bean;
    if (mbd == null || !mbd.isSynthetic()) {
    // 執行Bean的初始化前置處理器，很重要也就是Spring的勾點函數
      wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
    }
    try {
    // 執行Bean的初始化方法
      invokeInitMethods(beanName, wrappedBean, mbd);
    }
    if (mbd == null || !mbd.isSynthetic()) {
    // 執行Bean的後置處理器，也很重要。
    // 很多寫底層架構的人都會對此勾點方法靈活應用
      wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
    }
    return wrappedBean;
  }

@Component
public class A implements BeanPostProcessor {
    @Override
    public Object postProcessBeforeInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName);
        return null;
    }
    @Override
    public Object postProcessAfterInitialization(Object bean, String beanName) throws BeansException {
        System.out.println(beanName);
        return null;
    }
}

@Component
public class A implements InitializingBean {
    @Override
    public void afterPropertiesSet() throws Exception {
        System.out.println("執行InitializingBean的afterPropertiesSet方法");
    }
}