BeanFactory体系介绍

private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

public void registerBeanDefinition(String beanName, BeanDefinition beanDefinition)  
      throws BeanDefinitionStoreException {  
   // 校验beanDefinition信息的完整性
   if (beanDefinition instanceof AbstractBeanDefinition) {  
      try {  
         ((AbstractBeanDefinition) beanDefinition).validate();  
      }  
      catch (BeanDefinitionValidationException ex) {  
         throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName, "Validation of bean definition failed", ex);  
      }  
   }  
  
   // 获取缓存
   BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);  
   // 如果该beanDefinition已经注册
   if (existingDefinition != null) {  
      // 如果beanFactory不允许beanDefinition重载，抛出异常
      if (!isAllowBeanDefinitionOverriding()) {  
         throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);  
      }  
      // 如果beanFactory允许beanDefinition重载，进行覆盖（默认会进行覆盖）
      this.beanDefinitionMap.put(beanName, beanDefinition);  
   }  
   // 如果该beanDefinition未注册
   else {  
      // 如果beanFactory已经创建bean
      if (hasBeanCreationStarted()) {  
         // 加锁，更新beanDefinitionMap缓存
         synchronized (this.beanDefinitionMap) {  
            this.beanDefinitionMap.put(beanName, beanDefinition);  
            List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);  
            updatedDefinitions.addAll(this.beanDefinitionNames);  
            updatedDefinitions.add(beanName);  
            this.beanDefinitionNames = updatedDefinitions;  
            removeManualSingletonName(beanName);  
         }  
      }  
      // 如果beanFactory还没有创建bean，仍处于注册bean阶段
      else {  
         // 直接更新beanDefinitionMap缓存
         this.beanDefinitionMap.put(beanName, beanDefinition);  
         this.beanDefinitionNames.add(beanName);  
         removeManualSingletonName(beanName);  
      }  
      this.frozenBeanDefinitionNames = null;  
   }  
   // 如果beanDefinition已存在，或单例bean已存在，需要清除相关缓存信息：mergedBeanDefinitions、singletonObjects等
   if (existingDefinition != null || containsSingleton(beanName)) {  
      resetBeanDefinition(beanName);  
   }  
   // 如果beanDefinition不存在，并且单例bean不存在，并且beanFactory会缓存所有beanDefinition的元数据
   else if (isConfigurationFrozen()) {  
      // 清除allBeanNamesByType和singletonBeanNamesByType
      clearByTypeCache();  
   }  
}

protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {  
   RootBeanDefinition mbdToUse = mbd;  
   // 解析bean对应的beanClass对象，用于后面的实例化
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);  
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {  
      mbdToUse = new RootBeanDefinition(mbd);  
      mbdToUse.setBeanClass(resolvedClass);  
   }  
  
   // Prepare method overrides：校验lookup方法是否存在
   try {  
      mbdToUse.prepareMethodOverrides();  
   }  
   catch (BeanDefinitionValidationException ex) {  
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),  
            beanName, "Validation of method overrides failed", ex);  
   }  
  
   try {  
      // 触发InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()和BeanPostProcessor#postProcessAfterInitialization()方法
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);  
      // 如果通过InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()方法实例化对象，就直接返回了
      if (bean != null) {  
         return bean;  
      }  
   }  
   catch (Throwable ex) {  
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,  
            "BeanPostProcessor before instantiation of bean failed", ex);  
   }  
  
   try {  
      // 使用BeanFactory默认策略实例化对象：使用instanceSupplier、factoryMethodName或构造函数
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      return beanInstance;  
   }  
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      throw ex;  
   }  
   catch (Throwable ex) {  
      throw new BeanCreationException(  
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);  
   }  
}

public Class<?> resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {  
   String className = getBeanClassName();  
   if (className == null) {  
      return null;  
   }  
   Class<?> resolvedClass = ClassUtils.forName(className, classLoader);  
   this.beanClass = resolvedClass;  
   return resolvedClass;  
}

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) {  
            // InstantiationAwareBeanPostProcessor#postProcessBeforeInstantiation()回调
            bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);  
            if (bean != null) {  
               // BeanPostProcessor#postProcessAfterInitialization()
               bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);  
            }  
         }  
      }  
      mbd.beforeInstantiationResolved = (bean != null);  
   }  
   return bean;  
}

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException {  
   BeanWrapper instanceWrapper = null;  
   if (mbd.isSingleton()) {  
      // 如果factoryBeanInstanceCache有，直接取
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  
   }  
   if (instanceWrapper == null) {  
      /* 创建bean：
         1、instanceSupplier#get()方法创建
         2、factoryMethod工厂方法创建
         3、有参构造函数创建
         4、无参构造函数创建
      */
      instanceWrapper = createBeanInstance(beanName, mbd, args);  
   }  
   
   Object bean = instanceWrapper.getWrappedInstance();  
   Class<?> beanType = instanceWrapper.getWrappedClass();  
   if (beanType != NullBean.class) {  
      mbd.resolvedTargetType = beanType;  
   }  
  
   // 触发MergedBeanDefinitionPostProcessor#postProcessMergedBeanDefinition()回调
   synchronized (mbd.postProcessingLock) {  
      if (!mbd.postProcessed) {  
         try {  
            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) {  
      // 如果是提前暴露的单例bean：缓存单例对象：singletonFactories和registeredSingletons
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));  
   }  
  
   // 实例化bean
   Object exposedObject = bean;  
   try {  
      /* 
         1、InstantiationAwareBeanPostProcessor#postProcessAfterInstantiation()回调
         2、InstantiationAwareBeanPostProcessor#postProcessProperties()回调
         3、依赖注入
      */ 
      populateBean(beanName, mbd, instanceWrapper);  
      /*
	     1、触发BeanNameAware、BeanClassLoaderAware和BeanFactoryAware回调
	     2、触发BeanPostProcessor#postProcessBeforeInitialization()回调
	     3、触发InitializingBean#afterPropertiesSet()回调
	     4、触发initMethod回调
	     5、触发BeanPostProcessor#postProcessAfterInitialization()回调
      */
      exposedObject = initializeBean(beanName, exposedObject, mbd);  
   }  
   catch (Throwable ex) {  
      
   }  
   // 如果是提前暴露的单例bean
   if (earlySingletonExposure) {  
      // 从缓存中获取：singletonObjects、earlySingletonObjects、singletonFactories
      Object earlySingletonReference = getSingleton(beanName, false);  
      if (earlySingletonReference != null) {  
         if (exposedObject == bean) {  
            exposedObject = earlySingletonReference;  
         }  
         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {  
            // 清除依赖bean的缓存
            String[] dependentBeans = getDependentBeans(beanName);  
            Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);  
            for (String dependentBean : dependentBeans) {  
               if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {  
                  actualDependentBeans.add(dependentBean);  
               }  
            }  
            if (!actualDependentBeans.isEmpty()) {  
               throw new BeanCurrentlyInCreationException();  
            }  
         }  
      }  
   }  
  
   // Register bean as disposable.  
   try {  
      registerDisposableBeanIfNecessary(beanName, bean, mbd);  
   }  
   catch (BeanDefinitionValidationException ex) {  
      throw new BeanCreationException(  
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);  
   }  
  
   return exposedObject;  
}

protected <T> T doGetBean(  
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)  
      throws BeansException {  
  
   // 获取最原始的beanName：别名处理、"&"前缀（factoryBean）
   String beanName = transformedBeanName(name);  
   Object beanInstance;  
  
   // 依次从获取singletonObjects、earlySingletonObjects和singletonFactories三级缓存中获取（解决循环依赖）
   Object sharedInstance = getSingleton(beanName);  
   if (sharedInstance != null && args == null) {    
      // 已存在，直接返回
      beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);  
   }  
   else {  
      // Fail if we're already creating this bean instance:  
      // We're assumably within a circular reference.      
      if (isPrototypeCurrentlyInCreation(beanName)) {  
         throw new BeanCurrentlyInCreationException(beanName);  
      }  
  
      // 先从父容器中获取
      BeanFactory parentBeanFactory = getParentBeanFactory();  
      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);  
         }  
      }  
      // 标记已创建
      if (!typeCheckOnly) {  
         markBeanAsCreated(beanName);  
      }  
      try {
         // 合并BeanDefinition
         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);  
         checkMergedBeanDefinition(mbd, beanName, args);  
  
         // 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 + "'");  
               }  
               // 注册依赖的bean
               registerDependentBean(dep, beanName);  
               try {  
                  // 创建依赖的bean
                  getBean(dep);  
               }  
               catch (NoSuchBeanDefinitionException ex) {  
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,  
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);  
               }  
            }  
         }  
  
         // 创建单例bean，保存到singletonObjects、registeredSingletons缓存，从singletonFactories、earlySingletonObjects移除
         if (mbd.isSingleton()) {  
            sharedInstance = getSingleton(beanName, () -> {  
               try {  
                  return createBean(beanName, mbd, args);  
               }  
               catch (BeansException ex) {             
                  destroySingleton(beanName);  
                  throw ex;  
               }  
            });  
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);  
         }  
         // 创建prototype的bean
         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);  
            }  
            beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);  
         }  
         // 创建自定义作用域的bean
         else {  
            String scopeName = mbd.getScope();  
            if (!StringUtils.hasLength(scopeName)) {  
               throw new IllegalStateException("No scope name defined for bean '" + beanName + "'");  
            }  
            Scope scope = this.scopes.get(scopeName);  
            if (scope == null) {  
               throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");  
            }  
            try {  
               // 根据自定义作用域的规则创建bean
               Object scopedInstance = scope.get(beanName, () -> {  
                  beforePrototypeCreation(beanName);  
                  try {  
                     return createBean(beanName, mbd, args);  
                  }  
                  finally {  
                     afterPrototypeCreation(beanName);  
                  }  
               });  
               beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);  
            }  
            catch (IllegalStateException ex) {  
               throw new ScopeNotActiveException(beanName, scopeName, ex);  
            }  
         }  
      }  
      catch (BeansException ex) {
         cleanupAfterBeanCreationFailure(beanName);  
         throw ex;  
      }  
      finally {  
         beanCreation.end();  
      }  
   }  
  
   return adaptBeanInstance(name, beanInstance, requiredType);  
}