Spring Bean的创建流程

通过注解方式研究SpringBean创建流程，入口是AnnotationConfigApplicationContext类。

ApplicationContext applicationContext = new  AnnotationConfigApplicationContext(MyConfig.class);

看这个构造方法中执行了三步：

• 调用this()方法：

   ■ 完成ioc容器DefaultListableBeanFactory实例化；
   ■ 完成AnnotationBeanDefinitionReader bean解析器实例化；
   ■ 完成ClassPathBeanDefinitionScanner实例化（不知道这个是做啥的）
  

• 调用register(componentClasses)方法：

   ■ 完成将当前传入的配置解析成beanDefinition注册到容器中。
  

• 调用refresh()方法（Spring核心方法）

public AnnotationConfigApplicationContext(Class<?>... componentClasses) {
    //调用无参构造函数会先调用父类GenericApplicationContext的无参构造函数，主要用于实例化BeanFactory工厂；
    //然后创建AnnotatedBeanDefinitionReader注解Bean解析器
    this();
    //将当前配置类解析成beanDefinition,注册到容器中。
    register(componentClasses);
    //核心方法，刷新容器
    refresh();
}

主要看refresh()方法，这是SpringIOC启动流程和Bean创建的核心方法。

  ■ 调用 invokeBeanFactoryPostProcessors(beanFactory)方法：作用是将所有bean解析成beanDefinition
  ■ 调用 finishBeanFactoryInitialization(beanFactory)方法：完成所有非懒加载、单例bean的实例化。

@Override
public void refresh() throws BeansException, IllegalStateException {
    synchronized (this.startupShutdownMonitor) {
        //...省略一些不重要的方法(后面讲Spring启动流程的时候会详细描述)

        try {
            // Allows post-processing of the bean factory in context subclasses.
            postProcessBeanFactory(beanFactory);

            // 将所有的Bean解析成BeanDefinition
            invokeBeanFactoryPostProcessors(beanFactory);

           //...省略了

            // 实例化所有非懒加载的Bean(Spring创建Bean核心方法也是Bean生命周期的核心方法)
            finishBeanFactoryInitialization(beanFactory);

            // Last step: publish corresponding event.
            finishRefresh();
        }
        //...省略一些不重要的方法
    }
}

这里主要涉及到Bean创建的核心方法是finishBeanFactoryInitialization()。看下里面具体实现了什么。

 ■ 主要是调用了 beanFactory.preInstantiateSingletons()方法：主要作用是完成所有非懒加载、单例bean的实例化功能。

protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
    // ...省略一些不重要的方法

    // 实例化所有非懒加载的单例Bean 
    // Instantiate all remaining (non-lazy-init) singletons.
    beanFactory.preInstantiateSingletons();
}

beanFactory.preInstantiateSingletons()中主要逻辑如下：

  ■ 获取当前ioc容器中所有单例bean的beanName；
  ■ 遍历所有beanName，获取每一个beanName对应合并后的BeanDefinition对象；
  ■ 如果是FactoryBean对象则直接走FactoryBean的实例化逻辑，否则直接走bean的实例化逻辑，即直接调用getBean(beanName)方法。
  ■ 调用所有bean后初始化逻辑。

@Override
public void preInstantiateSingletons() throws BeansException {
	// ...
	// 获取容器中所有Bean的beanName
	List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
	
	// 触发所有非懒加载单例beans的初始化工作
	// Trigger initialization of all non-lazy singleton beans...
	for (String beanName : beanNames) {
	   //获取一个合并的BeanDefinition
	   RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
	   if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
	       //判断是否是FactoryBean对象
	       if (isFactoryBean(beanName)) {
	           //如果是FactoryBean对象，通过&+beanName获取FactoryBean
	           Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
	           if (bean instanceof FactoryBean) {
	               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 {
	           //调用初始化Bean方法
	           getBean(beanName);
	       }
	   }
	}
	// 调用所有Bean后初始化回调
	// Trigger post-initialization callback for all applicable beans...
	for (String beanName : beanNames) {
	    Object singletonInstance = getSingleton(beanName);
	    if (singletonInstance instanceof SmartInitializingSingleton) {
	        SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
	        if (System.getSecurityManager() != null) {
	            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
	                smartSingleton.afterSingletonsInstantiated();
	                return null;
	            }, getAccessControlContext());
	        }
	        else {
	            smartSingleton.afterSingletonsInstantiated();
	        }
	    }
	}
}

getBean()方法会继续调用doGetBean()方法，主要逻辑如下：

■ 调用getSingleton(beanName)方法，先从缓存中获取bean，如果缓存中存在当前bean则直接返回bean，否则往下执行。
Spring是如何解决循环依赖的问题？

protected Object getSingleton(String beanName, boolean allowEarlyReference) {
    // 先从singletonObjects中获取(一级缓存)
    Object singletonObject = this.singletonObjects.get(beanName);
    if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
        // 在从earlySingletonObjects中获取(二级缓存)
        singletonObject = this.earlySingletonObjects.get(beanName);
        if (singletonObject == null && allowEarlyReference) {
            synchronized (this.singletonObjects) {
                // Consistent creation of early reference within full singleton lock
                singletonObject = this.singletonObjects.get(beanName);
                if (singletonObject == null) {
                    singletonObject = this.earlySingletonObjects.get(beanName);
                    if (singletonObject == null) {
                        // 最后从singletonFactories中获取(三级缓存)
                        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
                        if (singletonFactory != null) {
                            // 
                            singletonObject = singletonFactory.getObject();
                            this.earlySingletonObjects.put(beanName, singletonObject);
                            this.singletonFactories.remove(beanName);
                        }
                    }
                }
            }
        }
    }
    return singletonObject;
}

■ 通过String[] dependsOn = mbd.getDependsOn()判断当前bean是否存在依赖，如果存在依赖则先实例化依赖。

// 实例化当前Bean所有的依赖
// Guarantee initialization of beans that the current bean depends on.
String[] dependsOn = mbd.getDependsOn();
if (dependsOn != null) {
    for (String dep : dependsOn) {
        if (isDependent(beanName, dep)) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
        }
        registerDependentBean(dep, beanName);
        try {
            getBean(dep);
        }
        catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                            "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
        }
    }
}

■ 调用createBean(beanName, mbd, args)方法开始进行实例化bean。

protected <T> T doGetBean(
			String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
			throws BeansException {

    String beanName = transformedBeanName(name);
    Object bean;

    // 先从缓存中获取Bean如果获取到直接返回，获取不到开始实例化一个Bean然后放进缓存中。
    // 这里是Spring Bean实现的单例的主要方式（通过Map缓存来实现Bean的单例）。
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            if (isSingletonCurrentlyInCreation(beanName)) {
                logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                             "' that is not fully initialized yet - a consequence of a circular reference");
            }
            else {
                logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
            }
        }
        // 此方法的作用是根据BeanName判断返回的是FactoryBean原生对象还是getObject()方法返回的对象，如果以&开头就是FactoryBean原生对象，否则就是getObject()返回的对象。
        bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
       // ...省略不重要的逻辑
        
        try {
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // 实例化当前Bean所有的依赖
            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            // ...

			// 实例化单例Bean
            // Create bean instance.
            if (mbd.isSingleton()) {
                sharedInstance = getSingleton(beanName, () -> {
                    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);
            }
            // 处理其他Bean作用的实例化
        }
        catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
        }
    }
	// 省略不重要的逻辑
    return (T) bean;
}

最后调用AbstractAutowireCapableBeanFactory.doCreateBean()方法,逻辑如下：

■ 执行InstantiationAwareBeanPostProcessor后置处理器方法postProcessBeforeInstantiation(beanClass, beanName)。(Aop的核心功能就是通过这个后置处理器完成的，AnnotationAwareAspectJAutoProxyCreator.postProcessBeforeInstantiation（）方法，核心逻辑后面具体描述)。SpringAOP实现原理？
■ 调用doCreateBean(beanName, mbdToUse, args)方法完成bean实例化。

@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  throws BeanCreationException {
  // ...省略一些不重要的方法
  try {
      // 执行InstantiationAwareBeanPostProcessor初始化后置处理器方法。这里是处理AOP的主要后置处理器。
      // Aop的核心后置处理器AnnotationAwareAspectJAutoProxyCreator就是实现了InstantiationAwareBeanPostProcessor接口。后面会专门介绍AOP的执行流程。
  // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
          return bean;
      }
  }
  catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
                                      "BeanPostProcessor before instantiation of bean failed", ex);
  }

  try {
      //开始实例化Bean
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
          logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
  }
  catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
  }
  catch (Throwable ex) {
      throw new BeanCreationException(
          mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
  }
}

实例化Bean的核心方法doCreateBean()方法主要实现逻辑如下：

■ 调用createBeanInstance()方法实例化bean。Spring实例化构造器推断原理？
■ 通过determineConstructorsFromBeanPostProcessors(beanClass, beanName)推断实例化使用的构造器。这里只有AutowiredAnnotationBeanPostProcessor后置处理器实现这个方法。那么这个方法主要告诉我们内容总结如下：
  ● 首先我们要知道一个bean如果有多个构造器可以通过@Autowired注解告诉容器我们需要通过哪个构造器来进行实例化。
  ● 如果存在两个以上@Autowired标注的构造函数，则IOC容器会报错。
  ● 最后调用一个@Autowired注解是required=false，那么会加入到候选列表中，如果此时存在无参构造函数也会加入到候选列表中，如果只有一个@AutoWired，则返回这个构造。
  ● 如果构造方法大于1个，但是都没有@AutoWired，那么返回null。
■ 最后调用ContructorResolver.instantiate()方法，通过反射机制进行实例化bean。注意此时实例化的bean是一个半成品，还没有进行属性注入。
■ 调用applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName)执行MergedBeanDefinitionPostProcessor后置处理器，这个后置处理器主要用于bean属性注入的前置工作，将所有类中包含@Autowired、@Resource等注解的属性和方法都放进RejectionMetadata中，用于后面进行自动装配。@Autowired、@Inject等依赖注入注解的实现原理？
■ 调用addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean))方法。
■ 这里通过三级缓存this.singletonFactories.put(beanName, singletonFactory)来解决循环依赖问题。
■ 调用populateBean()方法完成bean的属性填充。
■ 这里主要是通过AutowiredAnnotationBeanPostProcessor.postProcessProperties方法进行属性注入。主要逻辑是获取InjectionMetadata，然后遍历每个属性进行属性注入。
■ 调用initializeBean()方法完成bean的初始化。
■ 调用invokeAwareMethods(beanName, bean)回调方法，用来执行实现了BeanNameAware、BeanFactoryAware、BeanClassLoaderAware等setXXX()方法。
■ 通过applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName)方法，来调用BeanPostProcessor后置处理器前方法
■ 通过invokeInitMethods(beanName, wrappedBean, mbd)方法，调用bean初始化方法；
  ● 先调用实现了InitializingBean接口的afterPropertiesSet()方法；
  ● 在调用自定义的init-method中的方法。
■ 通过applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName)方法调用BeanPostProcessor后置处理器方法。

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
			throws BeanCreationException {

    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
        instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
        // 创建Bean实例
        instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    Object bean = instanceWrapper.getWrappedInstance();
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
        mbd.resolvedTargetType = beanType;
    }

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
        if (!mbd.postProcessed) {
            try {
                // 调用MergedBeanDefinitionPostProcessor后置处理器，完成对AutoWiredAnnotationBeanPostProcessor后置处理器对自动装配功能的实现。
                applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
            }
            catch (Throwable ex) {
                throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                                                "Post-processing of merged bean definition failed", ex);
            }
            mbd.postProcessed = true;
        }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
                                      isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
        if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                         "' to allow for resolving potential circular references");
        }
        addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }

    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
        // 属性填充
        populateBean(beanName, mbd, instanceWrapper);
        // 初始化Bean
        exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
        if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
            throw (BeanCreationException) ex;
        }
        else {
            throw new BeanCreationException(
                mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
        }
    }
    
    // ...省略一些不重要的方法

    // Register bean as disposable.
    try {
        registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
}