Spring AbstractAutowireCapableBeanFactory

public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory
      implements AutowireCapableBeanFactory {

   /**
    * Dependency types to ignore on dependency check and autowire, as Set of Class objects: for
    * example, String. Default is none.
    *
    * 忽略的依赖类型
    */
   private final Set<Class<?>> ignoredDependencyTypes = new HashSet<>();

   /**
    * Dependency interfaces to ignore on dependency check and autowire, as Set of Class objects. By
    * default, only the BeanFactory interface is ignored.
    * 忽略的依赖接口
    */
   private final Set<Class<?>> ignoredDependencyInterfaces = new HashSet<>();

   /**
    * The name of the currently created bean, for implicit dependency registration on getBean etc
    * invocations triggered from a user-specified Supplier callback.
    * 正在创建的 bean Name
    */
   private final NamedThreadLocal<String> currentlyCreatedBean = new NamedThreadLocal<>("Currently created bean");

   /**
    * Cache of unfinished FactoryBean instances: FactoryBean name to BeanWrapper.
    * key: beanName
    * value: bean wrapper
    */
   private final ConcurrentMap<String, BeanWrapper> factoryBeanInstanceCache = new ConcurrentHashMap<>();

   /**
    * Cache of candidate factory methods per factory class.
    * 工厂方法缓存
    * key: 工厂类
    * value: 方法列表
    */
   private final ConcurrentMap<Class<?>, Method[]> factoryMethodCandidateCache = new ConcurrentHashMap<>();

   /**
    * Cache of filtered PropertyDescriptors: bean Class to PropertyDescriptor array.
    * key: 类
    * value: 属性描述
    */
   private final ConcurrentMap<Class<?>, PropertyDescriptor[]> filteredPropertyDescriptorsCache =
         new ConcurrentHashMap<>();

   /**
    * Strategy for creating bean instances.
    * 实例化策略
    */
   private InstantiationStrategy instantiationStrategy = new CglibSubclassingInstantiationStrategy();

   /**
    * Resolver strategy for method parameter names.
    * 参数名称发现接口
    */
   @Nullable
   private ParameterNameDiscoverer parameterNameDiscoverer = new DefaultParameterNameDiscoverer();

   /**
    * Whether to automatically try to resolve circular references between beans.
    * 是否允许循环引用
    */
   private boolean allowCircularReferences = true;

   /**
    * Whether to resort to injecting a raw bean instance in case of circular reference, even if the
    * injected bean eventually got wrapped.
    * 原始注解
    */
   private boolean allowRawInjectionDespiteWrapping = false;
}

@Override
public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
   super.copyConfigurationFrom(otherFactory);
   if (otherFactory instanceof AbstractAutowireCapableBeanFactory) {
      AbstractAutowireCapableBeanFactory otherAutowireFactory =
            (AbstractAutowireCapableBeanFactory) otherFactory;
      this.instantiationStrategy = otherAutowireFactory.instantiationStrategy;
      this.allowCircularReferences = otherAutowireFactory.allowCircularReferences;
      this.ignoredDependencyTypes.addAll(otherAutowireFactory.ignoredDependencyTypes);
      this.ignoredDependencyInterfaces.addAll(otherAutowireFactory.ignoredDependencyInterfaces);
   }
}

@Override
@SuppressWarnings("unchecked")
public <T> T createBean(Class<T> beanClass) throws BeansException {
   // Use prototype bean definition, to avoid registering bean as dependent bean.
   RootBeanDefinition bd = new RootBeanDefinition(beanClass);
   bd.setScope(SCOPE_PROTOTYPE);
   // 确认是否需要缓存
   bd.allowCaching = ClassUtils.isCacheSafe(beanClass, getBeanClassLoader());
   // 创建 bean
   return (T) createBean(beanClass.getName(), bd, null);
}

		// beanDefinition
		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<?> resolvedClass = resolveBeanClass(mbd, beanName);
		// 1. 待处理的类不为空
		// 2. bean定义中含有 beanClass
		// 3. className 不为空
		// 满足、上述三点的情况下会去创建 RootBeanDefinition
		if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
			// 创建 beanDefinition
			mbdToUse = new RootBeanDefinition(mbd);
			// 设置bean class
			mbdToUse.setBeanClass(resolvedClass);
		}

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.
   // 创建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
   );
}

	@Nullable
	protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
		Object bean = null;
		// 是否需要在 bean 初始化之前做一些关于 beanPostProcessor 相关的行为
		if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
			// Make sure bean class is actually resolved at this point.
			// 是否是合成bean
			// 是否拥有 BeanPostProcessor 接口
			if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
				// 目标类型确认
				Class<?> targetType = determineTargetType(beanName, mbd);
				// 前置方法 BeanPostProcessor 接口的调用
				if (targetType != null) {
					bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
					if (bean != null) {
						// 后置方法
						bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
					}
				}
			}
			mbd.beforeInstantiationResolved = (bean != null);
		}
		return bean;
	}

@Nullable
protected Class<?> determineTargetType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
   // beanDefinition 中的类型
   Class<?> targetType = mbd.getTargetType();
   // 不存在的情况下处理方式
   if (targetType == null) {
      targetType = (mbd.getFactoryMethodName() != null ?
            getTypeForFactoryMethod(beanName, mbd, typesToMatch) :
            resolveBeanClass(mbd, beanName, typesToMatch));
      if (ObjectUtils.isEmpty(typesToMatch) || getTempClassLoader() == null) {
         mbd.resolvedTargetType = targetType;
      }
   }
   return targetType;
}

// 获取 工厂方法的回调类型解析器
ResolvableType cachedReturnType = mbd.factoryMethodReturnType;
if (cachedReturnType != null) {
   // 类型解析器中获取类型
   return cachedReturnType.resolve();
}

// 公共父类
Class<?> commonType = null;
// 工厂方法
Method uniqueCandidate = mbd.factoryMethodToIntrospect;

Class<?> factoryClass;
boolean isStatic = true;

// 工厂bean名称
String factoryBeanName = mbd.getFactoryBeanName();
if (factoryBeanName != null) {
   // 工厂 bean 名称和 参数 bean名称是否相同
   if (factoryBeanName.equals(beanName)) {
      throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
            "factory-bean reference points back to the same bean definition"
      );
   }
   // Check declared factory method return type on factory class.
   // 获取 工厂bean的类型
   factoryClass = getType(factoryBeanName);
   isStatic = false;
}
else {
   // Check declared factory method return type on bean class.
   // 解析 bean 类型
   factoryClass = resolveBeanClass(mbd, beanName, typesToMatch);
}

if (factoryClass == null) {
   return null;
}
factoryClass = ClassUtils.getUserClass(factoryClass);

// If all factory methods have the same return type, return that type.
// Can't clearly figure out exact method due to type converting / autowiring!
int minNrOfArgs =
      (mbd.hasConstructorArgumentValues() ? mbd.getConstructorArgumentValues().getArgumentCount() : 0);
// 候选函数列表
Method[] candidates = this.factoryMethodCandidateCache.computeIfAbsent(
      factoryClass,
      clazz -> ReflectionUtils.getUniqueDeclaredMethods(clazz, ReflectionUtils.USER_DECLARED_METHODS)
);

for (Method candidate : candidates) {
   // 过滤条件
   if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate) &&
         candidate.getParameterCount() >= minNrOfArgs) {
      // Declared type variables to inspect?
      if (candidate.getTypeParameters().length > 0) {
         try {
            // Fully resolve parameter names and argument values.
            // 函数的参数类型
            Class<?>[] paramTypes = candidate.getParameterTypes();
            String[] paramNames = null;
            // 获取 参数名称发现器
            ParameterNameDiscoverer pnd = getParameterNameDiscoverer();
            if (pnd != null) {
               // 解析参数名称
               paramNames = pnd.getParameterNames(candidate);
            }
            // 构造函数参数对象
            ConstructorArgumentValues cav = mbd.getConstructorArgumentValues();
            // 获取 ConstructorArgumentValues 中的 ValueHolder
            Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
            // 参数对象
            Object[] args = new Object[paramTypes.length];
            // 循环中处理两个集合
            // 1. usedValueHolders 放入  ValueHolder
            // 2.  args 放入 ValueHolder 中存储的值
            for (int i = 0; i < args.length; i++) {
               ConstructorArgumentValues.ValueHolder valueHolder = cav.getArgumentValue(
                     i, paramTypes[i], (paramNames != null ? paramNames[i] : null), usedValueHolders);
               if (valueHolder == null) {
                  valueHolder = cav.getGenericArgumentValue(null, null, usedValueHolders);
               }
               if (valueHolder != null) {
                  args[i] = valueHolder.getValue();
                  usedValueHolders.add(valueHolder);
               }
            }

            // 获取返回值
            Class<?> returnType = AutowireUtils.resolveReturnTypeForFactoryMethod(
                  candidate, args, getBeanClassLoader());
            uniqueCandidate = (commonType == null && returnType == candidate.getReturnType() ?
                  candidate : null);

            // 公共父类获取
            commonType = ClassUtils.determineCommonAncestor(returnType, commonType);
            if (commonType == null) {
               // Ambiguous return types found: return null to indicate "not determinable".
               return null;
            }
         }
         catch (Throwable ex) {
            if (logger.isDebugEnabled()) {
               logger.debug("Failed to resolve generic return type for factory method: " + ex);
            }
         }
      }
      else {
         uniqueCandidate = (commonType == null ? candidate : null);
         // 公共父类获取
         commonType = ClassUtils.determineCommonAncestor(candidate.getReturnType(), commonType);
         if (commonType == null) {
            // Ambiguous return types found: return null to indicate "not determinable".
            return null;
         }
      }
   }
}

// Common return type found: all factory methods return same type. For a non-parameterized
// unique candidate, cache the full type declaration context of the target factory method.
// 获取 return 值
cachedReturnType = (uniqueCandidate != null ?
      ResolvableType.forMethodReturnType(uniqueCandidate) : ResolvableType.forClass(commonType));
mbd.factoryMethodReturnType = cachedReturnType;
return cachedReturnType.resolve();

@Nullable
protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
   // 获取 工厂方法的回调类型解析器
   ResolvableType cachedReturnType = mbd.factoryMethodReturnType;
   if (cachedReturnType != null) {
      // 类型解析器中获取类型
      return cachedReturnType.resolve();
   }

   // 公共父类
   Class<?> commonType = null;
   // 工厂方法
   Method uniqueCandidate = mbd.factoryMethodToIntrospect;

   if (uniqueCandidate == null) {
      Class<?> factoryClass;
      boolean isStatic = true;

      // 工厂bean名称
      String factoryBeanName = mbd.getFactoryBeanName();
      if (factoryBeanName != null) {
         // 工厂 bean 名称和 参数 bean名称是否相同
         if (factoryBeanName.equals(beanName)) {
            throw new BeanDefinitionStoreException(mbd.getResourceDescription(), beanName,
                  "factory-bean reference points back to the same bean definition"
            );
         }
         // Check declared factory method return type on factory class.
         // 获取 工厂bean的类型
         factoryClass = getType(factoryBeanName);
         isStatic = false;
      }
      else {
         // Check declared factory method return type on bean class.
         // 解析 bean 类型
         factoryClass = resolveBeanClass(mbd, beanName, typesToMatch);
      }

      if (factoryClass == null) {
         return null;
      }
      factoryClass = ClassUtils.getUserClass(factoryClass);

      // If all factory methods have the same return type, return that type.
      // Can't clearly figure out exact method due to type converting / autowiring!
      int minNrOfArgs =
            (mbd.hasConstructorArgumentValues() ? mbd.getConstructorArgumentValues().getArgumentCount() : 0);
      // 候选函数列表
      Method[] candidates = this.factoryMethodCandidateCache.computeIfAbsent(
            factoryClass,
            clazz -> ReflectionUtils.getUniqueDeclaredMethods(clazz, ReflectionUtils.USER_DECLARED_METHODS)
      );

      for (Method candidate : candidates) {
         // 过滤条件
         if (Modifier.isStatic(candidate.getModifiers()) == isStatic && mbd.isFactoryMethod(candidate) &&
               candidate.getParameterCount() >= minNrOfArgs) {
            // Declared type variables to inspect?
            if (candidate.getTypeParameters().length > 0) {
               try {
                  // Fully resolve parameter names and argument values.
                  // 函数的参数类型
                  Class<?>[] paramTypes = candidate.getParameterTypes();
                  String[] paramNames = null;
                  // 获取 参数名称发现器
                  ParameterNameDiscoverer pnd = getParameterNameDiscoverer();
                  if (pnd != null) {
                     // 解析参数名称
                     paramNames = pnd.getParameterNames(candidate);
                  }
                  // 构造函数参数对象
                  ConstructorArgumentValues cav = mbd.getConstructorArgumentValues();
                  // 获取 ConstructorArgumentValues 中的 ValueHolder
                  Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
                  // 参数对象
                  Object[] args = new Object[paramTypes.length];
                  // 循环中处理两个集合
                  // 1. usedValueHolders 放入  ValueHolder
                  // 2.  args 放入 ValueHolder 中存储的值
                  for (int i = 0; i < args.length; i++) {
                     ConstructorArgumentValues.ValueHolder valueHolder = cav.getArgumentValue(
                           i, paramTypes[i], (paramNames != null ? paramNames[i] : null), usedValueHolders);
                     if (valueHolder == null) {
                        valueHolder = cav.getGenericArgumentValue(null, null, usedValueHolders);
                     }
                     if (valueHolder != null) {
                        args[i] = valueHolder.getValue();
                        usedValueHolders.add(valueHolder);
                     }
                  }

                  // 获取返回值
                  Class<?> returnType = AutowireUtils.resolveReturnTypeForFactoryMethod(
                        candidate, args, getBeanClassLoader());
                  uniqueCandidate = (commonType == null && returnType == candidate.getReturnType() ?
                        candidate : null);

                  // 公共父类获取
                  commonType = ClassUtils.determineCommonAncestor(returnType, commonType);
                  if (commonType == null) {
                     // Ambiguous return types found: return null to indicate "not determinable".
                     return null;
                  }
               }
               catch (Throwable ex) {
                  if (logger.isDebugEnabled()) {
                     logger.debug("Failed to resolve generic return type for factory method: " + ex);
                  }
               }
            }
            else {
               uniqueCandidate = (commonType == null ? candidate : null);
               // 公共父类获取
               commonType = ClassUtils.determineCommonAncestor(candidate.getReturnType(), commonType);
               if (commonType == null) {
                  // Ambiguous return types found: return null to indicate "not determinable".
                  return null;
               }
            }
         }
      }

      mbd.factoryMethodToIntrospect = uniqueCandidate;
      if (commonType == null) {
         return null;
      }
   }

   // Common return type found: all factory methods return same type. For a non-parameterized
   // unique candidate, cache the full type declaration context of the target factory method.
   // 获取 return 值
   cachedReturnType = (uniqueCandidate != null ?
         ResolvableType.forMethodReturnType(uniqueCandidate) : ResolvableType.forClass(commonType));
   mbd.factoryMethodReturnType = cachedReturnType;
   return cachedReturnType.resolve();
}

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

@Override
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)
      throws BeansException {

   Object result = existingBean;
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
      // 执行 spring 容器中 BeanPostProcessor
      Object current = processor.postProcessAfterInitialization(result, beanName);
      if (current == null) {
         return result;
      }
      result = current;
   }
   return result;
}

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

// Instantiate the bean.
BeanWrapper instanceWrapper = null;
// 是否单例
if (mbd.isSingleton()) {
   // beanFactory 移除当前创建的beanName
   instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
}
// beanWrapper 是否存在
if (instanceWrapper == null) {
   // 创建 bean 实例
   instanceWrapper = createBeanInstance(beanName, mbd, args);
}

// Make sure bean class is actually resolved at this point.
// 第一部分
// 获取 bean class
Class<?> beanClass = resolveBeanClass(mbd, beanName);
// bean 是否可以被创建的验证
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()
                                   );
}

// 第二部分
// 返回一个用来创建bean实例的回调接口
// Supplier get 直接获取bean对象
Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
if (instanceSupplier != null) {
   return obtainFromSupplier(instanceSupplier, beanName);
}

protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
   Object instance;

    // 获取当前的beanName
   String outerBean = this.currentlyCreatedBean.get();
   // 设置当前处理的beanName
   this.currentlyCreatedBean.set(beanName);
   try {
      // 从 Supplier 中获取
      instance = instanceSupplier.get();
   }
   finally {
      if (outerBean != null) {
         // 如果 currentlyCreatedBean 取不到设置
         this.currentlyCreatedBean.set(outerBean);
      }
      else {
         // 移除
         this.currentlyCreatedBean.remove();
      }
   }

   if (instance == null) {
      // supplier 中获取不到, 将实例设置为 NullBean
      instance = new NullBean();
   }
   // beanWrapper 包装
   BeanWrapper bw = new BeanWrapperImpl(instance);
   // beanWrapper 实例化后的操作
   initBeanWrapper(bw);
   return bw;
}

// 第三部分
if (mbd.getFactoryMethodName() != null) {
   // 通过工厂方法创建
   return instantiateUsingFactoryMethod(beanName, mbd, args);
}

protected BeanWrapper instantiateUsingFactoryMethod(
      String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs) {
   // 调用 factory-method 方法
   return new ConstructorResolver(this).instantiateUsingFactoryMethod(beanName, mbd, explicitArgs);
}

// 第四部分
// 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) {
      // 自动构造 bean
      return autowireConstructor(beanName, mbd, null, null);
   }
   else {
      // 实例化bean
      return instantiateBean(beanName, mbd);
   }
}

protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
   try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
         // 获取实例化策略来进行实例化
         beanInstance = AccessController.doPrivileged(
               (PrivilegedAction<Object>) () ->
                     getInstantiationStrategy().instantiate(mbd, beanName, parent),
               getAccessControlContext()
         );
      }
      else {
         // 获取实例化策略来进行实例化
         beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }

      // beanWrapper 创建
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
   }
   catch (Throwable ex) {
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
   }
}

// 第六部分
// 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.
// 实例化 bean
return instantiateBean(beanName, mbd);

/**
 * Determine candidate constructors to use for the given bean, checking all registered {@link
 * SmartInstantiationAwareBeanPostProcessor SmartInstantiationAwareBeanPostProcessors}.
 *
 * 通过 BeanPostProcessor 的子接口  SmartInstantiationAwareBeanPostProcessor 来获取 Constructor 列表
 * @param beanClass the raw class of the bean
 * @param beanName  the name of the bean
 *
 * @return the candidate constructors, or {@code null} if none specified
 *
 * @throws org.springframework.beans.BeansException in case of errors
 * @see org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor#determineCandidateConstructors
 */
@Nullable
protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
      throws BeansException {

   if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
         if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
            SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
            //  SmartInstantiationAwareBeanPostProcessor 的实现类中获取
            Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
            if (ctors != null) {
               return ctors;
            }
         }
      }
   }
   return null;
}

// 第二部分
// 获取 实例
final Object bean = instanceWrapper.getWrappedInstance();
// beanWrapper中存储的实例.class
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 {
         // 后置方法执行 BeanPostProcessor
         applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
      }
      catch (Throwable ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Post-processing of merged bean definition failed", ex
         );
      }
      mbd.postProcessed = true;
   }
}

protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof MergedBeanDefinitionPostProcessor) {
         MergedBeanDefinitionPostProcessor bdp = (MergedBeanDefinitionPostProcessor) bp;
         bdp.postProcessMergedBeanDefinition(mbd, beanType, beanName);
      }
   }
}

// 是否需要提前暴露
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));
}

// 第四部分
// 实例化bean
// Initialize the bean instance.
Object exposedObject = bean;
try {
   // 设置属性
   populateBean(beanName, mbd, instanceWrapper);
   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 (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;
   }
}

if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
   for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
         InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
         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;
}

protected void autowireByName(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

   // 获取属性名称列表 (非普通类型)
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   // 循环赋值
   for (String propertyName : propertyNames) {
      // 属性是否是 bean
      if (containsBean(propertyName)) {
         // 获取 bean
         Object bean = getBean(propertyName);
         pvs.add(propertyName, bean);
         // 注册依赖
         registerDependentBean(propertyName, beanName);
         if (logger.isTraceEnabled()) {
            logger.trace("Added autowiring by name from bean name '" + beanName +
                  "' via property '" + propertyName + "' to bean named '" + propertyName + "'");
         }
      }
      else {
         if (logger.isTraceEnabled()) {
            logger.trace("Not autowiring property '" + propertyName + "' of bean '" + beanName +
                  "' by name: no matching bean found");
         }
      }
   }
}

protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw) {
   Set<String> result = new TreeSet<>();
   // 获取 PropertyValues
   PropertyValues pvs = mbd.getPropertyValues();
   // 获取 属性描述符对象列表
   PropertyDescriptor[] pds = bw.getPropertyDescriptors();
   // 循环属性描述符 , 通过条件判断来确定是否是一个不简单的属性
   for (PropertyDescriptor pd : pds) {
      // 1. 可写函数是否存在
      // 2. 是否是依赖检查中排除的
      // 3. pvc 中是否包含
      // 4. 是否是一个简单类型
      if (pd.getWriteMethod() != null && !isExcludedFromDependencyCheck(pd) && !pvs.contains(pd.getName()) &&
            !BeanUtils.isSimpleProperty(pd.getPropertyType())) {
         result.add(pd.getName());
      }
   }
   return StringUtils.toStringArray(result);
}

public static boolean isSimpleValueType(Class<?> type) {
   return (Void.class != type && void.class != type &&
         (ClassUtils.isPrimitiveOrWrapper(type) ||
               Enum.class.isAssignableFrom(type) ||
               CharSequence.class.isAssignableFrom(type) ||
               Number.class.isAssignableFrom(type) ||
               Date.class.isAssignableFrom(type) ||
               Temporal.class.isAssignableFrom(type) ||
               URI.class == type ||
               URL.class == type ||
               Locale.class == type ||
               Class.class == type));
}

protected void autowireByType(
      String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs) {

   // 类型转换器
   TypeConverter converter = getCustomTypeConverter();
   if (converter == null) {
      converter = bw;
   }

   // 需要注入的 beanName
   Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
   // 获取属性名称列表 (非普通类型)
   String[] propertyNames = unsatisfiedNonSimpleProperties(mbd, bw);
   // 循环处理 属性名称的bean
   for (String propertyName : propertyNames) {
      try {
         // 获取属性描述符
         PropertyDescriptor pd = bw.getPropertyDescriptor(propertyName);
         // Don't try autowiring by type for type Object: never makes sense,
         // even if it technically is a unsatisfied, non-simple property.
         // 类型判断 不会给 Object 类型的数据做处理
         if (Object.class != pd.getPropertyType()) {
            // 函数参数
            MethodParameter methodParam = BeanUtils.getWriteMethodParameter(pd);
            // Do not allow eager init for type matching in case of a prioritized post-processor.
            // 类型是否是 PriorityOrdered
            boolean eager = !(bw.getWrappedInstance() instanceof PriorityOrdered);
            // 依赖描述对象
            DependencyDescriptor desc = new AutowireByTypeDependencyDescriptor(methodParam, eager);

            // 获得依赖对象
            // 实现在 org.springframework.beans.factory.support.DefaultListableBeanFactory.resolveDependency
            Object autowiredArgument = resolveDependency(desc, beanName, autowiredBeanNames, converter);
            if (autowiredArgument != null) {
               // 设置值
               pvs.add(propertyName, autowiredArgument);
            }
            // 依赖注册到容器
            for (String autowiredBeanName : autowiredBeanNames) {
               registerDependentBean(autowiredBeanName, beanName);
               if (logger.isTraceEnabled()) {
                  logger.trace("Autowiring by type from bean name '" + beanName + "' via property '" +
                        propertyName + "' to bean named '" + autowiredBeanName + "'");
               }
            }
            // 清理对象
            autowiredBeanNames.clear();
         }
      }
      catch (BeansException ex) {
         throw new UnsatisfiedDependencyException(mbd.getResourceDescription(), beanName, propertyName, ex);
      }
   }
}

// 第一部分
if (System.getSecurityManager() != null) {
   AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
      invokeAwareMethods(beanName, bean);
      return null;
   }, getAccessControlContext());
}
else {
   // aware 接口执行
   invokeAwareMethods(beanName, bean);
}

private void invokeAwareMethods(final String beanName, final Object bean) {
   if (bean instanceof Aware) {
      if (bean instanceof BeanNameAware) {
         ((BeanNameAware) bean).setBeanName(beanName);
      }
      if (bean instanceof BeanClassLoaderAware) {
         ClassLoader bcl = getBeanClassLoader();
         if (bcl != null) {
            ((BeanClassLoaderAware) bean).setBeanClassLoader(bcl);
         }
      }
      if (bean instanceof BeanFactoryAware) {
         ((BeanFactoryAware) bean).setBeanFactory(AbstractAutowireCapableBeanFactory.this);
      }
   }
}

// 第二部分
Object wrappedBean = bean;
if (mbd == null || !mbd.isSynthetic()) {
   // BeanPostProcessor 前置方法执行
   wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);
}

// 第三部分
try {
   // 执行实例化函数
   invokeInitMethods(beanName, wrappedBean, mbd);
}
catch (Throwable ex) {
   throw new BeanCreationException(
         (mbd != null ? mbd.getResourceDescription() : null),
         beanName, "Invocation of init method failed", ex
   );
}