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方法"; } }