Spring框架系列之bean的生命周期底层原理07

上一篇我们预留了两个大的内容，一个是Object sharedInstance = getSingleton(beanName)从单例池中获取数据，另外一个是getSingleton方法创建单例Bean，如下图：

getSingleton(beanName, () -> {
   try {
         return createBean(beanName, mbd, args);
   }
   catch (BeansException ex) {
      destroySingleton(beanName);
      throw ex;
   }
});

本篇我们就来聊聊上面这个getSingleton方法。

说句掏心窝子的话，要想把Bean的生命周期讲清楚真不是一件容易的事情，要让看官看明白就更难了，所以笔者一直在考虑怎么样才能将Bean的生命周期讲清楚，这里举个实际的案例来讲可能会更明了，后续我们所有的分析也将基于这个案例进行：

有三个类，代码如下：

public class ClassA{
   ClassB classB;
}

public class ClassB{
   ClassA classA;
}

public class ClassC{
   ClassA classA;
}

如上，ClassA依赖ClassB，ClassB依赖ClassA，ClassC也依赖ClassA，我们getBean("classA")来获取ClassA的实例对象，进入到getSingleton这个方法，我们可以看到getSingleton的第二个参数是lambda表达式，进入getSingleton方法：

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   synchronized (this.singletonObjects) {
     //关键点一
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         if (this.singletonsCurrentlyInDestruction) {
            throw new BeanCreationNotAllowedException(beanName,
                  "Singleton bean creation not allowed while singletons of this factory are in destruction " +
                  "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
         }
         if (logger.isDebugEnabled()) {
            logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
         }
         beforeSingletonCreation(beanName);
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
           //关键点二
            singletonObject = singletonFactory.getObject();  // createBean()
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         } catch (BeanCreationException ex) {
            if (recordSuppressedExceptions) {
               for (Exception suppressedException : this.suppressedExceptions) {
                  ex.addRelatedCause(suppressedException);
               }
            }
            throw ex;
         }finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
           //关键点三
            afterSingletonCreation(beanName);
         }

         if (newSingleton) {
           //关键点四
            addSingleton(beanName, singletonObject);
         }
      }
      return singletonObject;
   }
}

关键点一

该方法首先判断singletonObjects单例池中是否有实例，没有则调用beforeSingletonCreation方法将beanName添加到
singletonsCurrentlyInCreation集合中，表示正在创建该单例对象。

关键点二

执行
singletonFactory.getObject()方法，我们上面说过singletonFactory这个对象是一个lambda表达式，那么执行singletonFactory.getObject(),就会实际执行表达式的内容，也就是调用createBean方法。

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
   ......
   try {
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  
      if (bean != null) {
         return bean;
      }
   }
   ......
   try {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
         logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   ......
}

如上
resolveBeforeInstantiation这个方法是干嘛的呢？如果英语好应该很容易理解，表示在实例化之前做点什么事情，方法里面调用了applyBeanPostProcessorsBeforeInstantiation方法：

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;
}

而
applyBeanPostProcessorsBeforeInstantiation方法则是循环调用所有InstantiationAwareBeanPostProcessor类型的Bean的后置处理器的postProcessBeforeInstantiation方法，默认情况下只有ConfigurationClassPostProcessor属于InstantiationAwareBeanPostProcessor类型，它直接返回Null，那Spring加这个方法放这里有啥用？用处当然有，Spring通过这种方式给咱们提供了一个扩展点，咱们可以自己定义InstantiationAwareBeanPostProcessor的实现类，来直接返回实例对象，如果这里返回的是非空的对象，则Spring直接返回给咱们了，这样就可以跳过Spring的生命周期流程了。

当然如果经过“实例化之前“这个骚操作得到的是空对象，则会调用doCreateBean来创建实例，这里是核心了，具体放下一篇幅分析。

关键点三

调用afterSingletonCreation方法，将刚刚正在创建的beanName从
singletonsCurrentlyInCreation中移除。

关键点四

调用addSingleton方法将创建好的单例bean添加到单例池singletonObjects中。