Spring bean的加载过程源码分析

spring-beans模块囊括了DI、IOC等经典实现;Bean密切相关的接口BeanFactory,与IOC容器、依赖注入、依赖查找等 有着千丝万缕的关系~

其中默认实现类DefaultListableBeanFactory覆盖了这些功能,也可以通俗的理解DefaultListableBeanFactory实例就是一个IOC容器,bean的生命周期都围绕着它来完成
       public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
            implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

       public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
               implements AutowireCapableBeanFactory {
              
Spring bean生命周期
 - Spring bean元信息配置、解析阶段
 - Spring bean注册阶段
 - Spring BeanDefinition合并阶段
 - Spring bean class加载阶段
   - 在AbstractAutowireCapableBeanFactory#createBean中,resolveBeanClass
 - Spring bean实例化前阶段
   - 在AbstractAutowireCapableBeanFactory#createBean中,resolveBeforeInstantiation 
 - Spring bean实例化后阶段
   - 在AbstractAutowireCapableBeanFactory#populateBean中,postProcessAfterInstantiation 
 - Spring bean属性赋值阶段
   - 在AbstractAutowireCapableBeanFactory#populateBean中
 - Spring bean Aware接口回调阶段
   - 在AbstractAutowireCapableBeanFactory#initializeBean中,invokeAwareMethods
 - Spring bean初始化前阶段
   - 在AbstractAutowireCapableBeanFactory#initializeBean中,applyBeanPostProcessorsBeforeInitialization
 - Spring bean初始化阶段
   - 在AbstractAutowireCapableBeanFactory#initializeBean中,invokeInitMethods
 - Spring bean初始化后阶段
   - 在AbstractAutowireCapableBeanFactory#initializeBean中,applyBeanPostProcessorsAfterInitialization
 - Spring bean销毁阶段
 
其中需要注意实例化和初始化的区别
 - 实例化:就单实例化这个动作来说可以理解为在堆上new了一个对象,此时属性还没有赋值
 - 初始化:初始化阶段就是给属性赋值的过程
       
              
咱们今天聊的是Spring Bean的加载流程,从AbstractBeanFactory的getBean开始分析~~~


getBean 顾名思义,获取bean实例
   @Override
   public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
      return doGetBean(name, requiredType, null, false);
   }
               
   protected <T> T doGetBean(final String name, @Nullable final Class<T> requiredType,
         @Nullable final Object[] args, boolean typeCheckOnly) throws BeansException {

      // 提取对于的beanName
      final String beanName = transformedBeanName(name);
      Object bean;

      // Eagerly check singleton cache for manually registered singletons.
      // 检查缓存中或者实例工厂中是否有对应的实例, 通过提前暴露ObjectFactory解决循环依赖
      // 放入singletonFactories缓存的时间点在 创建bean实例之后 populate属性赋值之前(在属性赋值的时候会根据@Autowired等注解尝试加载并注入依赖的实例)
      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 + "'");
            }
         }

         // 返回对应的实例,有时候存在诸如BeanFactory的情况并不是直接返回实例本身而是返回指定方法返回的实例
         bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
      }

      else {
         // Fail if we're already creating this bean instance:
         // We're assumably within a circular reference.
         // Prototype范围是不允许循环依赖,因为不会对Prototype范围的bean进行缓存
         if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
         }

         // Check if bean definition exists in this factory.
         // 如果beanDefinitionMap中也就是在所有已经加载的类中不包括beanName 则尝试从parentBeanFactory中检测
         BeanFactory parentBeanFactory = getParentBeanFactory();
         // 如果检查当前加载的XML配置文件中不包含beanName所对应的配置,就只能到parentBeanFactory去尝试下了
         if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
            // Not found -> check parent.
            String nameToLookup = originalBeanName(name);
            if (parentBeanFactory instanceof AbstractBeanFactory) {
               return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
                     nameToLookup, requiredType, args, typeCheckOnly);
            }
            else if (args != null) {
               // Delegation to parent with explicit args.
               return (T) parentBeanFactory.getBean(nameToLookup, args);
            }
            else if (requiredType != null) {
               // No args -> delegate to standard getBean method.
               return parentBeanFactory.getBean(nameToLookup, requiredType);
            }
            else {
               return (T) parentBeanFactory.getBean(nameToLookup);
            }
         }

         // 如果不是仅仅做类型检测则是创建bean,这里要进行记录
         if (!typeCheckOnly) {
            markBeanAsCreated(beanName);
         }

         try {
            // 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition, 如果
            // 指定beanName是子Bean的话同时会合并父类相关属性
            // 因为从XML配置文件中读取的Bean信息是存储在GenericBeanDefinition中的, 但是后续处理都是针对RootBeanDefinition
            final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            checkMergedBeanDefinition(mbd, beanName, args);

            // Guarantee initialization of beans that the current bean depends on.
            String[] dependsOn = mbd.getDependsOn();
            // 若存在依赖则需要递归实例化依赖的bean
            // 也就是这类型的,指定了depends-on, <bean id="xxx" class="xxx.xxx" depends-on="user">
            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);
                  }
               }
            }

            // 实例化依赖的bean后便可以实例化mbd本身了
            // 这里分了singleton、prototype和其他scope创建bean,处理逻辑上基本一致
            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实例做统一"清洗"
               bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
            }

            else if (mbd.isPrototype()) {
               // It's a prototype -> create a new instance.
               Object prototypeInstance = null;
               try {
                  beforePrototypeCreation(beanName);
                  prototypeInstance = createBean(beanName, mbd, args);
               }
               finally {
                  afterPrototypeCreation(beanName);
               }
               bean = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
            }

            else {
               // 指定的scope上实例化bean, request等
               String scopeName = mbd.getScope();
               final Scope scope = this.scopes.get(scopeName);
               if (scope == null) {
                  throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
               }
               try {
                  Object scopedInstance = scope.get(beanName, () -> {
                     beforePrototypeCreation(beanName);
                     try {
                        return createBean(beanName, mbd, args);
                     }
                     finally {
                        afterPrototypeCreation(beanName);
                     }
                  });
                  bean = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
               }
               catch (IllegalStateException ex) {
                  throw new BeanCreationException(beanName,
                        "Scope '" + scopeName + "' is not active for the current thread; consider " +
                        "defining a scoped proxy for this bean if you intend to refer to it from a singleton",
                        ex);
               }
            }
         }
         catch (BeansException ex) {
            cleanupAfterBeanCreationFailure(beanName);
            throw ex;
         }
      }

      // 这里就是对上面"千辛万苦"创建的bean实例做最后的把关, 检查需要的类型是否符合bean的实例类型, 不符合的话则进行类型转换
      // Check if required type matches the type of the actual bean instance.
      if (requiredType != null && !requiredType.isInstance(bean)) {
         try {
            T convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
            if (convertedBean == null) {
               throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
            }
            return convertedBean;
         }
         catch (TypeMismatchException ex) {
            if (logger.isTraceEnabled()) {
               logger.trace("Failed to convert bean '" + name + "' to required type '" +
                     ClassUtils.getQualifiedName(requiredType) + "'", ex);
            }
            throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
         }
      }
      return (T) bean;
   }           
此方法从流程上来看有三步:
   - 通过transformedBeanName方法来获取真正的beanName,因为有使用别名的情况,getBean方法传入的name并不一定是真实的beanName
   - 获取bean实例,此方法核心逻辑,其实是一个if else逻辑,如果是singleton范围先走if逻辑尝试从缓存拿bean实例,缓存没有则走else创建bean实例;其他范围则直接走else创建bean实例
   - 对获取的bean实例做一些类型上的转换处理




getSingleton(String beanName) 尝试从缓存中拿到bean实例
    // DefaultSingletonBeanRegistry#getSingleton
       public Object getSingleton(String beanName) {
          // true设置标志允许早期依赖
          return getSingleton(beanName, true);
       }
       
   protected Object getSingleton(String beanName, boolean allowEarlyReference) {
      // 检查缓存中是否存在实例,一级缓存
      Object singletonObject = this.singletonObjects.get(beanName);
      // 如果一级缓存中没有&是单例类型创建中
      if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
         synchronized (this.singletonObjects) {
            // 如果此bean正在加载则不处理,二级缓存
            singletonObject = this.earlySingletonObjects.get(beanName);
            // 如果二级缓存没有&允许早期引用(也就是循环引用时的提起曝光ObjectFactory)
            if (singletonObject == null && allowEarlyReference) {
               // 当某些方法需要提前初始化的时候则会调用addSingletonFactory将对应的factory初始化策略存储在singletonFactories
               ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
               if (singletonFactory != null) {
                  singletonObject = singletonFactory.getObject();
                  // 从三级缓存换到二级缓存
                  this.earlySingletonObjects.put(beanName, singletonObject);
                  this.singletonFactories.remove(beanName);
               }
            }
         }
      }
      return singletonObject;
   }


getObjectForBeanInstance 拿到"想要"的bean实例

因为有使用FactoryBean的情况,我们需要判断用户究竟是想要FactoryBean实例还是FactoryBean.getObject()对应的实例

     // AbstractBeanFactory#getObjectForBeanInstance
       protected Object getObjectForBeanInstance(
             Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
   
          // Don't let calling code try to dereference the factory if the bean isn't a factory.
          // 如果指定的name是工厂相关(以&为前缀)且beanInstance又不是FactoryBean类型则验证不通过
          if (BeanFactoryUtils.isFactoryDereference(name)) {
             if (beanInstance instanceof NullBean) {
                return beanInstance;
             }
             if (!(beanInstance instanceof FactoryBean)) {
                throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
             }
             if (mbd != null) {
                mbd.isFactoryBean = true;
             }
             return beanInstance;
          }
   
          // Now we have the bean instance, which may be a normal bean or a FactoryBean.
          // If it's a FactoryBean, we use it to create a bean instance, unless the
          // caller actually wants a reference to the factory.
          // 现在我们有了这个bean实例, 这个实例可能会是正常的bean或者FactoryBean
          // 如果是FactoryBean我们使用它创建实例,但是如果用户想要直接获取工厂实例而不是工厂的getObject()方法对应的实例
          // 那么传入的name应该加入前缀&
          if (!(beanInstance instanceof FactoryBean)) {
             return beanInstance;
          }
   
          Object object = null;
          if (mbd != null) {
             mbd.isFactoryBean = true;
          }
          else {
              // 尝试从缓存中加载bean
             object = getCachedObjectForFactoryBean(beanName);
          }
          if (object == null) {
             // Return bean instance from factory.
             FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
             // Caches object obtained from FactoryBean if it is a singleton.
             if (mbd == null && containsBeanDefinition(beanName)) {
                mbd = getMergedLocalBeanDefinition(beanName);
             }
             // 是否是用户定义的而不是应用程序本身定义的
             boolean synthetic = (mbd != null && mbd.isSynthetic());
             // 从Factory中解析bean
             object = getObjectFromFactoryBean(factory, beanName, !synthetic);
          }
          return object;
       }
       
       // FactoryBeanRegistrySupport#getObjectFromFactoryBean
   protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
      if (factory.isSingleton() && containsSingleton(beanName)) {
         synchronized (getSingletonMutex()) {
            Object object = this.factoryBeanObjectCache.get(beanName);
            if (object == null) {
               // 真正执行从FactoryBean中解析出bean
               // 直接调用getObject()方法
               object = doGetObjectFromFactoryBean(factory, beanName);
               // Only post-process and store if not put there already during getObject() call above
               // (e.g. because of circular reference processing triggered by custom getBean calls)
               Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
               if (alreadyThere != null) {
                  object = alreadyThere;
               }
               else {
                  if (shouldPostProcess) {
                     if (isSingletonCurrentlyInCreation(beanName)) {
                        // Temporarily return non-post-processed object, not storing it yet..
                        return object;
                     }
                     // bean创建前状态等信息记录
                     beforeSingletonCreation(beanName);
                     try {
                        // 调用ObjectFactory的后处理器
                        object = postProcessObjectFromFactoryBean(object, beanName);
                     }
                     catch (Throwable ex) {
                        throw new BeanCreationException(beanName,
                              "Post-processing of FactoryBean's singleton object failed", ex);
                     }
                     finally {
                        // bean创建后状态等信息删除
                        afterSingletonCreation(beanName);
                     }
                  }
                  if (containsSingleton(beanName)) {
                     this.factoryBeanObjectCache.put(beanName, object);
                  }
               }
            }
            return object;
         }
      }
      else {
         Object object = doGetObjectFromFactoryBean(factory, beanName);
         if (shouldPostProcess) {
            try {
               object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
               throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
            }
         }
         return object;
      }
   }
       
       // AbstractAutowireCapableBeanFactory#postProcessObjectFromFactoryBean
   protected Object postProcessObjectFromFactoryBean(Object object, String beanName) {
      // Spring获取bean的规则中有这样一条:尽可能保证所有bean初始化后都会调用注册的BeanPostProcessor的postProcessAfterInitialization方法进行处理
      // 在实际开发过程中大可以针对此特性设计自己的业务逻辑
      return applyBeanPostProcessorsAfterInitialization(object, beanName);
   }
       
       // AbstractAutowireCapableBeanFactory#applyBeanPostProcessorsAfterInitialization
   public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
         throws BeansException {

      Object result = existingBean;
      for (BeanPostProcessor processor : getBeanPostProcessors()) {
         // 初始化后的后处理器
         Object current = processor.postProcessAfterInitialization(result, beanName);
         if (current == null) {
            return result;
         }
         result = current;
      }
      return result;
   }      
      

getSingleton 获取单例
getSingleton(String beanName, ObjectFactory<?> singletonFactory)

    // DefaultSingletonBeanRegistry#getSingleton
    // 这里是单例对象创建bean实例,其中真正创建的逻辑是通过singletonFactory.getObject()以回调的形式创建
   public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
      Assert.notNull(beanName, "Bean name must not be null");
      // 多线程环境安全性,对全局变量加锁处理
      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 + "'");
            }
  
            // 记录加载状态, 将当前正在创建的bean记录在缓存中, 这样便可以对循环依赖进行检测
            beforeSingletonCreation(beanName);
            boolean newSingleton = false;
            boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = new LinkedHashSet<>();
            }
            try {
               // 初始化bean
               // 真正精华的部分就是这了,紧接着下面分析这块创建逻辑
               singletonObject = singletonFactory.getObject();
               newSingleton = true;
            }
            catch (IllegalStateException ex) {
               // Has the singleton object implicitly appeared in the meantime ->
               // if yes, proceed with it since the exception indicates that state.
               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;
               }
               // 和beforeSingletonCreation想对应,对缓存进行清理
               afterSingletonCreation(beanName);
            }
            if (newSingleton) {
               addSingleton(beanName, singletonObject);
            }
         }
         return singletonObject;
      }
   }
   
   protected void beforeSingletonCreation(String beanName) {
      // 记录加载状态, 将当前正在创建的bean记录在缓存中, 这样便可以对循环依赖进行检测
      if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.add(beanName)) {
         throw new BeanCurrentlyInCreationException(beanName);
      }
   }
   
   protected void afterSingletonCreation(String beanName) {
      // 移除缓存中对该bean的正在加载状态的记录
      if (!this.inCreationCheckExclusions.contains(beanName) && !this.singletonsCurrentlyInCreation.remove(beanName)) {
         throw new IllegalStateException("Singleton '" + beanName + "' isn't currently in creation");
      }
   }     
   
   protected void addSingleton(String beanName, Object singletonObject) {
      // 将结果记录至缓存并删除加载bean过程中所记录的各种辅助状态
      synchronized (this.singletonObjects) {
         this.singletonObjects.put(beanName, singletonObject);
         this.singletonFactories.remove(beanName);
         this.earlySingletonObjects.remove(beanName);
         this.registeredSingletons.add(beanName);
      }
   }
   
createBean 准备创建Bean
  createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
  再来看看上面创建单例对象的地方,是通过createBean来创建bean实例
       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);
       }   
       
        // AbstractAutowireCapableBeanFactory#createBean
       protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
             throws BeanCreationException {
    
          if (logger.isTraceEnabled()) {
             logger.trace("Creating instance of bean '" + beanName + "'");
          }
          RootBeanDefinition mbdToUse = mbd;
    
          // Make sure bean class is actually resolved at this point, and
          // clone the bean definition in case of a dynamically resolved Class
          // which cannot be stored in the shared merged bean definition.
          // 锁定class, 根据设置的class属性或者根据className来解析class
          Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
          if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
             mbdToUse = new RootBeanDefinition(mbd);
             mbdToUse.setBeanClass(resolvedClass);
          }
    
          // Prepare method overrides.
          // 验证及准备覆盖的方法
          // Spring配置中是存在lookup-method和replace-method的, 而这两个配置的加载就是将配置统一存放在BeanDefinition中的
          // methodOverrieds属性里, 这个方法就是针对这两个配置
          try {
             mbdToUse.prepareMethodOverrides();
          }
          catch (BeanDefinitionValidationException ex) {
             throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
                   beanName, "Validation of method overrides failed", ex);
          }
    
          try {
             // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
             // 给BeanPostProcessors一个机会来返回代理来替代真正的实例
             // 也就是在Spring Bean生命周期的实例化前阶段
             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 {
              // 如果上面的短路操作没有return,那么从此处开始才是真正的创建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);
          }
       }
    
        // 这可能是个短路操作,如果object不为null,就直接返回了,不会再进行后续初始化等操作
       protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
          Object bean = null;
          // 如果尚未被解析
          if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
             // Make sure bean class is actually resolved at this point.
             if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
                Class<?> targetType = determineTargetType(beanName, mbd);
                if (targetType != null) {
                   bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
                   if (bean != null) {
                      // 所以相当于初始化后处理器在整个生命周期来看是肯定会调用的(即使resolveBeforeInstantiation可能是个短路操作-bean有不为null就直接返回了)
                      // 因为一般情况在bean初始化之后触发从操作
                      bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
                   }
                }
             }
             mbd.beforeInstantiationResolved = (bean != null);
          }
          return bean;
       }      
       
  经过一层层校验等,抽丝剥茧终于到了开始创建bean实例的地方了 doCreateBean方法
   


doCreateBean 创建Bean
 doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
    // AbstractAutowireCapableBeanFactory#doCreateBean
   protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
         throws BeanCreationException {
  
      // Instantiate the bean.
      // 开始实例化这个bean,也就是空壳bean,还没有任何属性
      BeanWrapper instanceWrapper = null;
      if (mbd.isSingleton()) {
         instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
      }
      if (instanceWrapper == null) {
          // 实例化这个bean
          // 根据指定bean使用对应的策略创建新的实例,如:工厂方法,构造函数自动注入、简单初始化
         instanceWrapper = createBeanInstance(beanName, mbd, args);
      }
      final 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#postProcessMergedBeanDefinition后处理器
               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));
      // 这里就是解决循环引用关键的地方
      //  - 首先,它是在bean实例化之后,也就是在堆上已经分配了空间,只是还没有给属性填值~
      //  - 其次它是在给属性赋值之前将ObjectFactory放进缓存,在属性进行依赖查找 依赖注入的时候
      // 遇到循环引用就直接从缓存中取ObjectFactory.getObject(),也就拿到这个bean了              
      if (earlySingletonExposure) {
         if (logger.isTraceEnabled()) {
            logger.trace("Eagerly caching bean '" + beanName +
                  "' to allow for resolving potential circular references");
         }
         // 这里就是把bean包装成ObjectFactory放进SingletonFactory缓存中
         // 其中我们熟知的AOP就是在这里将advice动态织入bean中, 若没有则直接返回bean,不做任何处理
         addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
      }
  
      // Initialize the bean instance.
      Object exposedObject = bean;
      try {
          // 这里就是填充属性了
         populateBean(beanName, mbd, instanceWrapper);
         // 填充属性之后在根据设置进行一些初始化
         // 比如所在配置中设置的init-method方法,初始化前的后处理器,初始化后的后处理器
         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);
         }
      }
  
      if (earlySingletonExposure) {
         Object earlySingletonReference = getSingleton(beanName, false);
         // earlySingletonReference只有在检测到有循环依赖的情况下才会不为空
         if (earlySingletonReference != null) {
             // 如果exposedObject没有在初始化方法中被改变,也就是没有被增强
            if (exposedObject == bean) {
               exposedObject = earlySingletonReference;
            }
            else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
               String[] dependentBeans = getDependentBeans(beanName);
               Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
               for (String dependentBean : dependentBeans) {
                  // 检测依赖
                  if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
                     actualDependentBeans.add(dependentBean);
                  }
               }
               // 因为bean创建后其所依赖的bean一定是已经创建的
               // actualDependentBeans不为空则表示当前bean创建后其依赖的bean却没有全部创建完,也就是说存在循环依赖
               if (!actualDependentBeans.isEmpty()) {
                  throw new BeanCurrentlyInCreationException(beanName,
                        "Bean with name '" + beanName + "' has been injected into other beans [" +
                        StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                        "] in its raw version as part of a circular reference, but has eventually been " +
                        "wrapped. This means that said other beans do not use the final version of the " +
                        "bean. This is often the result of over-eager type matching - consider using " +
                        "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
               }
            }
         }
      }
  
      // Register bean as disposable.
      try {
          // 如果配置了destroy-method,这里需要注册以便于在销毁的时候调用
         registerDisposableBeanIfNecessary(beanName, bean, mbd);
      }
      catch (BeanDefinitionValidationException ex) {
         throw new BeanCreationException(
               mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
      }
  
      return exposedObject;
   }   
   
createBeanInstance 创建bean的实例,真正的new对象,堆上分配空间的操作
   protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
      // Make sure bean class is actually resolved at this point.
      Class<?> beanClass = resolveBeanClass(mbd, beanName);
 
      if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
      }
 
      Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
      if (instanceSupplier != null) {
         return obtainFromSupplier(instanceSupplier, beanName);
      }
 
      // 如果工厂方法不为空则使用工厂方法初始化策略
      // 也就是RootBeanDefinition中存在factoryMethodName属性,或者说在配置文件中配置了factory-method
      if (mbd.getFactoryMethodName() != null) {
         return instantiateUsingFactoryMethod(beanName, mbd, args);
      }
 
      // Shortcut when re-creating the same bean...
      boolean resolved = false;
      boolean autowireNecessary = false;
      if (args == null) {
         synchronized (mbd.constructorArgumentLock) {
            // 一个类有多个构造函数,每个构造函数都有不同的参数,所以调用前需要先根据参数锁定构造函数或者对应的工厂方法
            if (mbd.resolvedConstructorOrFactoryMethod != null) {
               resolved = true;
               autowireNecessary = mbd.constructorArgumentsResolved;
            }
         }
      }
      // 如果已经解析过了则使用解析好的构造函数 不需要再次锁定
      if (resolved) {
         if (autowireNecessary) {
            // 构造函数自动注入
            return autowireConstructor(beanName, mbd, null, null);
         }
         else {
            // 使用默认构造函数构造
            // 实例化策略(反射or动态代理)
            return instantiateBean(beanName, mbd);
         }
      }
 
      // Candidate constructors for autowiring?
      // 需要根据参数解析构造函数
      Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
      if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
            mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
         return autowireConstructor(beanName, mbd, ctors, args);
      }
 
      // Preferred constructors for default construction?
      ctors = mbd.getPreferredConstructors();
      if (ctors != null) {
         return autowireConstructor(beanName, mbd, ctors, null);
      }
 
      // No special handling: simply use no-arg constructor.
      return instantiateBean(beanName, mbd);
   } 
   
  
populateBean 属性注入,各种后处理器等等给属性赋值
    // AbstractAutowireCapableBeanFactory#populateBean
   protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
      if (bw == null) {
         if (mbd.hasPropertyValues()) {
            throw new BeanCreationException(
                  mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");
         }
         else {
            // Skip property population phase for null instance.
            return;
         }
      }

      // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the
      // state of the bean before properties are set. This can be used, for example,
      // to support styles of field injection.
      // 实例化后的后处理操作
      // 给InstantiationAwareBeanPostProcessor最后一次机会在属性设置前来改变bean
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
         for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
               // 返回值为是否继续填充bean
               if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
                  return;
               }
            }
         }
      }

      PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

      int resolvedAutowireMode = mbd.getResolvedAutowireMode();
      if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
         MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
         // Add property values based on autowire by name if applicable.
         // 根据名称自动注入
         if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
            autowireByName(beanName, mbd, bw, newPvs);
         }
         // Add property values based on autowire by type if applicable.
         // 根据类型自动注入
         if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
            autowireByType(beanName, mbd, bw, newPvs);
         }
         pvs = newPvs;
      }

      // 后处理器已经初始化
      boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
      // 需要依赖检查
      boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

      PropertyDescriptor[] filteredPds = null;
      if (hasInstAwareBpps) {
         if (pvs == null) {
            pvs = mbd.getPropertyValues();
         }
         for (BeanPostProcessor bp : getBeanPostProcessors()) {
            if (bp instanceof InstantiationAwareBeanPostProcessor) {
               InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
               // 对所有需要依赖检查的属性进行后处理
               PropertyValues pvsToUse = ibp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
               if (pvsToUse == null) {
                  if (filteredPds == null) {
                     filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
                  }
                  pvsToUse = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
                  if (pvsToUse == null) {
                     return;
                  }
               }
               pvs = pvsToUse;
            }
         }
      }
      if (needsDepCheck) {
         if (filteredPds == null) {
            filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
         }
         checkDependencies(beanName, mbd, filteredPds, pvs);
      }

      // 将属性应用到bean中
      if (pvs != null) {
         applyPropertyValues(beanName, mbd, bw, pvs);
      }
   }    
   

initializeBean 初始化bean
    // AbstractAutowireCapableBeanFactory#initializeBean
   protected Object initializeBean(final String beanName, final Object bean, @Nullable RootBeanDefinition mbd) {
      if (System.getSecurityManager() != null) {
         AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
            invokeAwareMethods(beanName, bean);
            return null;
         }, getAccessControlContext());
      }
      else {
         // 对特殊的bean处理,Aware、BeanClassLoaderAware、BeanFactoryAware
         invokeAwareMethods(beanName, bean);
      }

      Object wrappedBean = bean;
      if (mbd == null || !mbd.isSynthetic()) {
         // 应用初始化前的后处理器
         wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
      }

      try {
         // 激活用户自定义的init方法
         invokeInitMethods(beanName, wrappedBean, mbd);
      }
      catch (Throwable ex) {
         throw new BeanCreationException(
               (mbd != null ? mbd.getResourceDescription() : null),
               beanName, "Invocation of init method failed", ex);
      }
      if (mbd == null || !mbd.isSynthetic()) {
         // 应用初始化后的后处理器
         wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);
      }

      return wrappedBean;
   }  
  

注册DisposableBean
    // AbstractBeanFactory#registerDisposableBeanIfNecessary
   protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd) {
      AccessControlContext acc = (System.getSecurityManager() != null ? getAccessControlContext() : null);
      if (!mbd.isPrototype() && requiresDestruction(bean, mbd)) {
         if (mbd.isSingleton()) {
            // Register a DisposableBean implementation that performs all destruction
            // work for the given bean: DestructionAwareBeanPostProcessors,
            // DisposableBean interface, custom destroy method.
            // 单例模式下注册需要销毁的bean,此方法中会处理实现DisposableBean的bean,
            // 并且对所以的bean使用DestructionAwareBeanPostProcessor处理DisposableBean,
            registerDisposableBean(beanName,
                  new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
         }
         else {
            // A bean with a custom scope...
            // 自定义scope的处理
            Scope scope = this.scopes.get(mbd.getScope());
            if (scope == null) {
               throw new IllegalStateException("No Scope registered for scope name '" + mbd.getScope() + "'");
            }
            scope.registerDestructionCallback(beanName,
                  new DisposableBeanAdapter(bean, beanName, mbd, getBeanPostProcessors(), acc));
         }
      }
   }  

 

 

以上是个人理解,如有问题请指出,谢谢!

  • 1
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
评论 2
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

柏油

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付:¥1
获取中
扫码支付

您的余额不足,请更换扫码支付或充值

打赏作者

实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值