01｜Bean的初始化

1、AbstractApplicationContext

Spring管理的所有的非懒加载的单例Bean会随着容器的初始化加载到容器中，初始化入口依旧在AbstractApplicationContext的refresh方法中

  1. public abstract class AbstractApplicationContext extends DefaultResourceLoader
  2.         implements ConfigurableApplicationContext {
  3.     @Override
  4.     public void refresh() throws BeansException, IllegalStateException {
  5.         synchronized (this.startupShutdownMonitor) {
  6.             // 代码略...
  7.             // 1.1、实例化并调⽤实现了BeanFactoryPostProcessor接⼝的Bean
  8.             // 会扫描注册Bean的元数据信息并存入BeanFactory的beanDefinitionNames中
  9.             // Spring会将需要创建的Bean的信息封装到BeanDefinition类中，其中包含的类的所有元数据信息，如类的全路径名、声明周期等等
  10.             invokeBeanFactoryPostProcessors(beanFactory);
  11.             // 代码略...
  12.             // 1.2、依据1.1中的Bean元数据信息实例话所有非懒加载的单例bean
  13.             finishBeanFactoryInitialization(beanFactory);
  14.             // 代码略...
  16.     }
  17.     protected void finishBeanFactoryInitialization(ConfigurableListableBeanFactory beanFactory) {
  18.         // 调用DefaultListableBeanFactory的preInstantiateSingletons方法进行开始Bean的创建
  19.         beanFactory.preInstantiateSingletons();
  20.     }
  21. }

2、DefaultListableBeanFactory

DefaultListableBeanFactory的preInstantiateSingletons方法中会遍历注册到beanFactory的Bean信息进行对象的逐一创建

  1. public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
  2.         implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {
  3.     @Override
  4.     public void preInstantiateSingletons() throws BeansException {
  5.         // 代码略...
  7.         // 此处先不关注其余代码，只看getBean方法
  8.         List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);
  9.         for (String beanName : beanNames) {
  10.             RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
  11.             if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
  12.                 if (isFactoryBean(beanName)) {
  13.                     Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
  14.                     if (bean instanceof FactoryBean) {
  15.                         FactoryBean<?> factory = (FactoryBean<?>) bean;
  16.                         boolean isEagerInit;
  17.                         if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
  18.                             isEagerInit = AccessController.doPrivileged(
  19.                                     (PrivilegedAction<Boolean>) ((SmartFactoryBean<?>) factory)::isEagerInit,
  20.                                     getAccessControlContext());
  21.                         }
  22.                         else {
  23.                             isEagerInit = (factory instanceof SmartFactoryBean &&
  24.                                     ((SmartFactoryBean<?>) factory).isEagerInit());
  25.                         }
  26.                         if (isEagerInit) {
  27.                             getBean(beanName);
  28.                         }
  29.                     }
  30.                 }
  31.                 else {
  32.                     getBean(beanName);
  33.                 }
  34.             }
  35.          // 代码略...
  36.         }
  37.     }
  38. }

3、AbstractBeanFactory

getBean方法是定义在其父类AbstractBeanFactory中

  1. public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory {
  3.     @Override
  4.     public Object getBean(String name) throws BeansException {
  5.         return doGetBean(name, null, null, false);
  6.     }
  8.     protected <T> T doGetBean(
  9.             String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
  10.             throws BeansException {
  12.         String beanName = transformedBeanName(name);
  13.         Object bean;
  15.         // 3.1、检查缓存中或者实例工厂中是否有对应的实例
  16.         // 在创建单例Bean时会存在依赖注入的情况，Spring会通过ObjectFactory如提早曝光Bean对象，避免循环依赖，
  17.         Object sharedInstance = getSingleton(beanName);
  18.         if (sharedInstance != null && args == null) {
  19.             bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  20.         }else {
  21.             // Fail if we're already creating this bean instance:
  22.             // We're assumably within a circular reference.
  23.             if (isPrototypeCurrentlyInCreation(beanName)) {
  24.                 throw new BeanCurrentlyInCreationException(beanName);
  25.             }
  27.             // Check if bean definition exists in this factory.
  28.             BeanFactory parentBeanFactory = getParentBeanFactory();
  29.             if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  30.                 // Not found -> check parent.
  31.                 String nameToLookup = originalBeanName(name);
  32.                 if (parentBeanFactory instanceof AbstractBeanFactory) {
  33.                     return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
  34.                             nameToLookup, requiredType, args, typeCheckOnly);
  35.                 }
  36.                 else if (args != null) {
  37.                     // Delegation to parent with explicit args.
  38.                     return (T) parentBeanFactory.getBean(nameToLookup, args);
  39.                 }
  40.                 else if (requiredType != null) {
  41.                     // No args -> delegate to standard getBean method.
  42.                     return parentBeanFactory.getBean(nameToLookup, requiredType);
  43.                 }
  44.                 else {
  45.                     return (T) parentBeanFactory.getBean(nameToLookup);
  46.                 }
  47.             }
  49.             if (!typeCheckOnly) {
  50.                 markBeanAsCreated(beanName);
  51.             }
  53.             StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
  54.                     .tag("beanName", name);
  55.             try {
  56.                 if (requiredType != null) {
  57.                     beanCreation.tag("beanType", requiredType::toString);
  58.                 }
  59.                 RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
  60.                 checkMergedBeanDefinition(mbd, beanName, args);
  62.                 // 3.2、检查是否存在依赖，若需要进行递归创建依赖
  63.                 String[] dependsOn = mbd.getDependsOn();
  64.                 if (dependsOn != null) {
  65.                     for (String dep : dependsOn) {
  66.                         if (isDependent(beanName, dep)) {
  67.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  68.                                     "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
  69.                         }
  70.                         registerDependentBean(dep, beanName);
  71.                         try {
  72.                             getBean(dep);
  73.                         }
  74.                         catch (NoSuchBeanDefinitionException ex) {
  75.                             throw new BeanCreationException(mbd.getResourceDescription(), beanName,
  76.                                     "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
  77.                         }
  78.                     }
  79.                 }
  80.                 // 3.3、通过回调的方式创建Bean
  81.                 if (mbd.isSingleton()) {
  82.                     sharedInstance = getSingleton(beanName, () -> {
  83.                         try {
  84.                             // 此处会调用AbstractAutowireCapableBeanFactory的doCreateBean方法进行Bean的实例化
  85.                             return createBean(beanName, mbd, args);
  86.                         }
  87.                         catch (BeansException ex) {
  88.                             // Explicitly remove instance from singleton cache: It might have been put there
  89.                             // eagerly by the creation process, to allow for circular reference resolution.
  90.                             // Also remove any beans that received a temporary reference to the bean.
  91.                             destroySingleton(beanName);
  92.                             throw ex;
  93.                         }
  94.                     });
  95.                     bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
  96.                 }
  98.                 else if (mbd.isPrototype()) {
  99.                     // It's a prototype -> create a new instance.
  100.                     Object prototypeInstance = null;
  101.                     try {
  102.                         beforePrototypeCreation(beanName);
  103.                         prototypeInstance = createBean(beanName, mbd, args);
  104.                     }
  105.                     finally {
  106.                         afterPrototypeCreation(beanName);
  107.                     }
  108.                     bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
  109.                 }
  111.                 else {
  112.                     String scopeName = mbd.getScope();
  113.                     if (!StringUtils.hasLength(scopeName)) {
  114.                         throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
  115.                     }
  116.                     Scope scope = this.scopes.get(scopeName);
  117.                     if (scope == null) {
  118.                         throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
  119.                     }
  120.                     try {
  121.                         Object scopedInstance = scope.get(beanName, () -> {
  122.                             beforePrototypeCreation(beanName);
  123.                             try {
  124.                                 return createBean(beanName, mbd, args);
  125.                             }
  126.                             finally {
  127.                                 afterPrototypeCreation(beanName);
  128.                             }
  129.                         });
  130.                         bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
  131.                     }
  132.                     catch (IllegalStateException ex) {
  133.                         throw new ScopeNotActiveException(beanName, scopeName, ex);
  134.                     }
  135.                 }
  136.             }
  137.             catch (BeansException ex) {
  138.                 beanCreation.tag("exception", ex.getClass().toString());
  139.                 beanCreation.tag("message", String.valueOf(ex.getMessage()));
  140.                 cleanupAfterBeanCreationFailure(beanName);
  141.                 throw ex;
  142.             }
  143.             finally {
  144.                 beanCreation.end();
  145.             }
  146.         }
  148.         // 3.4、类型检查
  149.         if (requiredType != null && !requiredType.isInstance(bean)) {
  150.             try {
  151.                 T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
  152.                 if (convertedBean == null) {
  153.                     throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  154.                 }
  155.                 return convertedBean;
  156.             }
  157.             catch (TypeMismatchException ex) {
  158.                 if (logger.isTraceEnabled()) {
  159.                     logger.trace("Failed to convert bean '" + name + "' to required type '" +
  160.                             ClassUtils.getQualifiedName(requiredType) + "'", ex);
  161.                 }
  162.                 throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
  163.             }
  164.         }
  165.         return (T) bean;
  166.     }
  167. }

02｜循环依赖对象创建分析

  1. //开始初始化Bean
  2. DefaultListableBeanFactory#preInstantiateSingletons 
  3.  AbstractBeanFactory#getBean
  4.   AbstractBeanFactory#doGetBean 
  5.     // #从三级缓存中获取Bean，解决循环依赖关键位置，第一次返回null
  6.     DefaultSingletonBeanRegistry#getSingleton 
  7.     protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  8.                 // 从一级缓存获取，获取成功则对象已经创建成功
  9.         Object singletonObject = this.singletonObjects.get(beanName);
  10.         if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
  11.             synchronized (this.singletonObjects) {
  12.                                 // 从二级缓存取
  13.                 singletonObject = this.earlySingletonObjects.get(beanName);
  14.                 if (singletonObject == null && allowEarlyReference) {
  15.                     ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
  16.                     if (singletonFactory != null) {
  17.                                                 // 从三级缓存取，获取成功则从三件缓存**剪切**对象到二级缓存
  18.                         singletonObject = singletonFactory.getObject();
  19.                         this.earlySingletonObjects.put(beanName, singletonObject);
  20.                         this.singletonFactories.remove(beanName);
  21.                     }
  22.                 }
  23.             }
  24.         }
  25.         return singletonObject;
  26.     }
  27.       // 创建实例bean，还未对实例bean对象属性进行赋值
  28.       AbstractAutowireCapableBeanFactory#doCreateBean
  29.         AbstractAutowireCapableBeanFactory#createBeanInstance
  30. //  将实例bean包装未ObjectFactory对象，放入三级缓存提前暴露对象        DefaultSingletonBeanRegistry#addSingletonFactory（ObjectFactory）
  31.            // 属性填充
  32.            AbstractAutowireCapableBeanFactory#populateBean 
  33.             AbstractAutowireCapableBeanFactory#autowire*
  34.              AbstractBeanFactory#getBean 
  35.               AbstractBeanFactory#doGetBean 
  36.                // 继续尝试从三级缓存中获取对象，如获取失败，执行bean创建逻辑，并放入缓存供依赖对象获取填充
  37.                DefaultSingletonBeanRegistry#getSingleton

image.png