Spring DefaultListableBeanFactory

public class DefaultListableBeanFactory extends AbstractAutowireCapableBeanFactory
      implements ConfigurableListableBeanFactory, BeanDefinitionRegistry, Serializable {

   /**
    * Map from serialized id to factory instance.
    *
    * key: 序列化id
    *
    * value: DefaultListableBeanFactory
    *
    * */
   private static final Map<String, Reference<DefaultListableBeanFactory>> serializableFactories =
         new ConcurrentHashMap<>(8);

   @Nullable
   private static Class<?> javaxInjectProviderClass;

   /**
    * Map from dependency type to corresponding autowired value.
    *
    * key: 依赖类型
    * value: 依赖类型对应的值
    *
    * */
   private final Map<Class<?>, Object> resolvableDependencies = new ConcurrentHashMap<>(16);

   /**
    * Map of bean definition objects, keyed by bean name.
    *
    * bean定义容器
    * key: beanName
    * value: BeanDefinition
    *
    *  */
   private final Map<String, BeanDefinition> beanDefinitionMap = new ConcurrentHashMap<>(256);

   /**
    *  Map of singleton and non-singleton bean names, keyed by dependency type.
    * 类型和别名的映射关系
    * key: 类型
    * value: 别名
    * */
   private final Map<Class<?>, String[]> allBeanNamesByType = new ConcurrentHashMap<>(64);

   /**
    *  Map of singleton-only bean names, keyed by dependency type.
    *  单例bean的别名映射
    *
    *  key: 类型
    *  value: 别名
    *
    * */
   private final Map<Class<?>, String[]> singletonBeanNamesByType = new ConcurrentHashMap<>(64);

   /**
    *  Optional id for this factory, for serialization purposes.
    * 序列化 id (BeanFactory 的id)
    * */
   @Nullable
   private String serializationId;

   /**
    *  Whether to allow re-registration of a different definition with the same name.
    * 是否允许名字不同但是bean定义相同
    * */
   private boolean allowBeanDefinitionOverriding = true;

   /**
    *  Whether to allow eager class loading even for lazy-init beans.
    * 延迟加载的Bean是否立即加载
    * */
   private boolean allowEagerClassLoading = true;

   /** Optional OrderComparator for dependency Lists and arrays. */
   @Nullable
   private Comparator<Object> dependencyComparator;

   /**
    *  Resolver to use for checking if a bean definition is an autowire candidate.
    *  用来进行 自动注入(自动装配)的解析类
    * */
   private AutowireCandidateResolver autowireCandidateResolver = new SimpleAutowireCandidateResolver();

   /**
    * List of bean definition names, in registration order.
    * bean definition 名称列表
    * */
   private volatile List<String> beanDefinitionNames = new ArrayList<>(256);

   /**
    * List of names of manually registered singletons, in registration order.
    * 按照注册顺序放入 单例的beanName , 手动注册的单例对象
    *
    * */
   private volatile Set<String> manualSingletonNames = new LinkedHashSet<>(16);

   /**
    *
    * Cached array of bean definition names in case of frozen configuration.
    * bean definition 的名称列表
    * */
   @Nullable
   private volatile String[] frozenBeanDefinitionNames;

   /**
    *  Whether bean definition metadata may be cached for all beans.
    * 是否需要给bean元数据进行缓存
    * */
   private volatile boolean configurationFrozen = false;
}

@Override
public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory) {
   super.copyConfigurationFrom(otherFactory);
   if (otherFactory instanceof DefaultListableBeanFactory) {
      DefaultListableBeanFactory otherListableFactory = (DefaultListableBeanFactory) otherFactory;
      this.allowBeanDefinitionOverriding = otherListableFactory.allowBeanDefinitionOverriding;
      this.allowEagerClassLoading = otherListableFactory.allowEagerClassLoading;
      this.dependencyComparator = otherListableFactory.dependencyComparator;
      // A clone of the AutowireCandidateResolver since it is potentially BeanFactoryAware...
      setAutowireCandidateResolver(
            BeanUtils.instantiateClass(otherListableFactory.getAutowireCandidateResolver().getClass()));
      // Make resolvable dependencies (e.g. ResourceLoader) available here as well...
      this.resolvableDependencies.putAll(otherListableFactory.resolvableDependencies);
   }
}

@SuppressWarnings("unchecked")
@Override
public <T> T getBean(Class<T> requiredType, @Nullable Object... args) throws BeansException {
   Assert.notNull(requiredType, "Required type must not be null");
   // 解析bean
   Object resolved = resolveBean(ResolvableType.forRawClass(requiredType), args, false);
   if (resolved == null) {
      throw new NoSuchBeanDefinitionException(requiredType);
   }
   return (T) resolved;
}

public static ResolvableType forRawClass(@Nullable Class<?> clazz) {
   return new ResolvableType(clazz) {
      @Override
      public ResolvableType[] getGenerics() {
         return EMPTY_TYPES_ARRAY;
      }
      @Override
      public boolean isAssignableFrom(Class<?> other) {
         return (clazz == null || ClassUtils.isAssignable(clazz, other));
      }
      @Override
      public boolean isAssignableFrom(ResolvableType other) {
         Class<?> otherClass = other.resolve();
         return (otherClass != null && (clazz == null || ClassUtils.isAssignable(clazz, otherClass)));
      }
   };
}

// 解析 beanName
NamedBeanHolder<T> namedBean = resolveNamedBean(requiredType, args, nonUniqueAsNull);
if (namedBean != null) {
   // 获取实例
   return namedBean.getBeanInstance();
}

public class NamedBeanHolder<T> implements NamedBean {
   /**
    * bean name
    */
   private final String beanName;

   /**
    * bean 实例
    */
   private final T beanInstance;
}

@Override
public String[] getBeanNamesForType(@Nullable Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {
   // 参数验证 通过后做 doGetBeanNamesForType
   if (!isConfigurationFrozen() || type == null || !allowEagerInit) {
      return doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, allowEagerInit);
   }
   // 缓存容器的获取 , 根据是否包含非单例的条件来确定使用那个 beanClass -> name 容器
   Map<Class<?>, String[]> cache =
         (includeNonSingletons ? this.allBeanNamesByType : this.singletonBeanNamesByType);
   // 从容器中获取 类型对应的 beanName 列表
   String[] resolvedBeanNames = cache.get(type);
   // 不为空返回
   if (resolvedBeanNames != null) {
      return resolvedBeanNames;
   }
   // 继续尝试获取
   resolvedBeanNames = doGetBeanNamesForType(ResolvableType.forRawClass(type), includeNonSingletons, true);
   if (ClassUtils.isCacheSafe(type, getBeanClassLoader())) {
      cache.put(type, resolvedBeanNames);
   }
   return resolvedBeanNames;
}

// 第一部分
// Check all bean definitions.
// 循环所有的 beanName
for (String beanName : this.beanDefinitionNames) {
   // Only consider bean as eligible if the bean name
   // is not defined as alias for some other bean.
   // 确定是否存在别名
   if (!isAlias(beanName)) {
      try {
         // 获取合并的 beanDefinition
         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         // Only check bean definition if it is complete.
         // bean 定义检查
         // 1. 是否 abstract 修饰
         // 2. beanClass 是否等于 Class
         // 3. 是否懒加载
         // 4. allowEagerClassLoading 是否true
         // 5. allowEagerInit 是否急切加载
         // 6. requiresEagerInitForType
         if (!mbd.isAbstract() && (allowEagerInit ||
               (mbd.hasBeanClass() || !mbd.isLazyInit() || isAllowEagerClassLoading()) &&
                     !requiresEagerInitForType(mbd.getFactoryBeanName()))) {
            // 是否时 工厂bean
            boolean isFactoryBean = isFactoryBean(beanName, mbd);
            // bean 定义持有对象
            BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();
            // 是否匹配
            boolean matchFound = false;
            // 是否允许 工厂bean 初始化
            boolean allowFactoryBeanInit = allowEagerInit || containsSingleton(beanName);
            // 是否懒加载
            boolean isNonLazyDecorated = dbd != null && !mbd.isLazyInit();
            if (!isFactoryBean) {
               if (includeNonSingletons || isSingleton(beanName, mbd, dbd)) {
                  matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
               }
            }
            else {
               if (includeNonSingletons || isNonLazyDecorated ||
                     (allowFactoryBeanInit && isSingleton(beanName, mbd, dbd))) {
                  matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
               }
               if (!matchFound) {
                  // In case of FactoryBean, try to match FactoryBean instance itself next.
                  beanName = FACTORY_BEAN_PREFIX + beanName;
                  matchFound = isTypeMatch(beanName, type, allowFactoryBeanInit);
               }
            }
            if (matchFound) {
               result.add(beanName);
            }
         }
      }
      catch (CannotLoadBeanClassException | BeanDefinitionStoreException ex) {
         if (allowEagerInit) {
            throw ex;
         }
         // Probably a placeholder: let's ignore it for type matching purposes.
         LogMessage message = (ex instanceof CannotLoadBeanClassException) ?
               LogMessage.format("Ignoring bean class loading failure for bean '%s'", beanName) :
               LogMessage.format("Ignoring unresolvable metadata in bean definition '%s'", beanName);
         logger.trace(message, ex);
         onSuppressedException(ex);
      }
   }
}

// 第二部分
// Check manually registered singletons too.
for (String beanName : this.manualSingletonNames) {
   try {
      // In case of FactoryBean, match object created by FactoryBean.
      // 是否是 工厂 bean
      if (isFactoryBean(beanName)) {
         if ((includeNonSingletons || isSingleton(beanName)) && isTypeMatch(beanName, type)) {
            result.add(beanName);
            // Match found for this bean: do not match FactoryBean itself anymore.
            continue;
         }
         // In case of FactoryBean, try to match FactoryBean itself next.
         // 如果是 工厂bean的情况下修正beanName
         beanName = FACTORY_BEAN_PREFIX + beanName;
      }
      // Match raw bean instance (might be raw FactoryBean).
      if (isTypeMatch(beanName, type)) {
         result.add(beanName);
      }
   }
   catch (NoSuchBeanDefinitionException ex) {
      // Shouldn't happen - probably a result of circular reference resolution...
      logger.trace(LogMessage.format("Failed to check manually registered singleton with name '%s'", beanName), ex);
   }
}

return StringUtils.toStringArray(result);

if (candidateNames.length > 1) {
   List<String> autowireCandidates = new ArrayList<>(candidateNames.length);
   for (String beanName : candidateNames) {
      if (!containsBeanDefinition(beanName) || getBeanDefinition(beanName).isAutowireCandidate()) {
         autowireCandidates.add(beanName);
      }
   }
   if (!autowireCandidates.isEmpty()) {
      candidateNames = StringUtils.toStringArray(autowireCandidates);
   }
}

// 第三部分
if (candidateNames.length == 1) {
   String beanName = candidateNames[0];
   return new NamedBeanHolder<>(beanName, (T) getBean(beanName, requiredType.toClass(), args));
}

// 第四部分
else if (candidateNames.length > 1) {
   // key: beanName value: beanInstance或者 class
   Map<String, Object> candidates = new LinkedHashMap<>(candidateNames.length);
   // 循环 beanName 获取bean实例
   for (String beanName : candidateNames) {
      // 判断是否单例 和构造函数参是是否为空
      if (containsSingleton(beanName) && args == null) {
         // 获取bean实例
         Object beanInstance = getBean(beanName);
         candidates.put(beanName, (beanInstance instanceof NullBean ? null : beanInstance));
      }
      else {
         candidates.put(beanName, getType(beanName));
      }
   }
   // 确定候选对象名称
   String candidateName = determinePrimaryCandidate(candidates, requiredType.toClass());
   if (candidateName == null) {
      // 确定优先级最高的候选对象名称
      candidateName = determineHighestPriorityCandidate(candidates, requiredType.toClass());
   }
   if (candidateName != null) {
      // 容器中获取 候选对象名称的值
      Object beanInstance = candidates.get(candidateName);
      if (beanInstance == null || beanInstance instanceof Class) {
         // 根据类型获取bean实例
         beanInstance = getBean(candidateName, requiredType.toClass(), args);
      }
      return new NamedBeanHolder<>(candidateName, (T) beanInstance);
   }
   if (!nonUniqueAsNull) {
      throw new NoUniqueBeanDefinitionException(requiredType, candidates.keySet());
   }
}

return null;

@Nullable
protected String determinePrimaryCandidate(Map<String, Object> candidates, Class<?> requiredType) {
   // 返回值
   String primaryBeanName = null;

   for (Map.Entry<String, Object> entry : candidates.entrySet()) {
      // 容器中的BeanName
      String candidateBeanName = entry.getKey();
      // 容器中的 BeanInstance / BeanClass
      Object beanInstance = entry.getValue();
      // 是否是主要的 primary 修饰
      if (isPrimary(candidateBeanName, beanInstance)) {
         if (primaryBeanName != null) {
            // 是否存在 bean 定义, 检查对象是 容器中的 key
            boolean candidateLocal = containsBeanDefinition(candidateBeanName);
            //  是否存在 bean 定义, 检查对象是 primaryBeanName
            boolean primaryLocal = containsBeanDefinition(primaryBeanName);
            if (candidateLocal && primaryLocal) {
               throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
                     "more than one 'primary' bean found among candidates: " + candidates.keySet());
            }
            else if (candidateLocal) {
               primaryBeanName = candidateBeanName;
            }
         }
         else {
            primaryBeanName = candidateBeanName;
         }
      }
   }
   return primaryBeanName;
}

protected boolean isPrimary(String beanName, Object beanInstance) {
   // 转换 beanName
   String transformedBeanName = transformedBeanName(beanName);
   // 是否包含 bean 定义
   if (containsBeanDefinition(transformedBeanName)) {
      // 获取 合并后的 BeanDefinition 然后调用 isPrimary 获取返回值
      return getMergedLocalBeanDefinition(transformedBeanName).isPrimary();
   }
   // 获取父bean工厂
   BeanFactory parent = getParentBeanFactory();
   // 从父类葛洪常州判断是否 primary
   return (parent instanceof DefaultListableBeanFactory &&
         ((DefaultListableBeanFactory) parent).isPrimary(transformedBeanName, beanInstance));
}

@Nullable
protected String determineHighestPriorityCandidate(Map<String, Object> candidates, Class<?> requiredType) {
   // 优先级最高的 beanName
   String highestPriorityBeanName = null;
   // 最大优先级
   Integer highestPriority = null;
   for (Map.Entry<String, Object> entry : candidates.entrySet()) {
      // 容器中的BeanName
      String candidateBeanName = entry.getKey();
      // 容器中的 BeanInstance / BeanClass
      Object beanInstance = entry.getValue();
      if (beanInstance != null) {
         // 优先级序号 当前对象的优先级
         Integer candidatePriority = getPriority(beanInstance);
         if (candidatePriority != null) {
            if (highestPriorityBeanName != null) {
               if (candidatePriority.equals(highestPriority)) {
                  throw new NoUniqueBeanDefinitionException(requiredType, candidates.size(),
                        "Multiple beans found with the same priority ('" + highestPriority +
                              "') among candidates: " + candidates.keySet());
               }
               // 当前对象优先级 < 最高优先级 重新赋值
               else if (candidatePriority < highestPriority) {
                  highestPriorityBeanName = candidateBeanName;
                  highestPriority = candidatePriority;
               }
            }
            else {
               highestPriorityBeanName = candidateBeanName;
               highestPriority = candidatePriority;
            }
         }
      }
   }
   return highestPriorityBeanName;
}

@Nullable
protected Integer getPriority(Object beanInstance) {
   Comparator<Object> comparator = getDependencyComparator();
   if (comparator instanceof OrderComparator) {
      return ((OrderComparator) comparator).getPriority(beanInstance);
   }
   return null;
}

@Override
public T getObject() throws BeansException {
   T resolved = resolveBean(requiredType, null, false);
   if (resolved == null) {
      throw new NoSuchBeanDefinitionException(requiredType);
   }
   return resolved;
}

@Override
public T getObject(Object... args) throws BeansException {
   T resolved = resolveBean(requiredType, args, false);
   if (resolved == null) {
      throw new NoSuchBeanDefinitionException(requiredType);
   }
   return resolved;
}

@Override
@Nullable
public T getIfAvailable() throws BeansException {
   return resolveBean(requiredType, null, false);
}

@Override
@Nullable
public T getIfUnique() throws BeansException {
   return resolveBean(requiredType, null, true);
}

private Comparator<Object> adaptOrderComparator(Map<String, ?> matchingBeans) {
   // 获取依赖比较对象
   Comparator<Object> dependencyComparator = getDependencyComparator();
   // 转换 OrderComparator
   OrderComparator comparator = (dependencyComparator instanceof OrderComparator ?
         (OrderComparator) dependencyComparator : OrderComparator.INSTANCE);
   return comparator.withSourceProvider(createFactoryAwareOrderSourceProvider(matchingBeans));
}

private int doCompare(@Nullable Object o1, @Nullable Object o2, @Nullable OrderSourceProvider sourceProvider) {
   boolean p1 = (o1 instanceof PriorityOrdered);
   boolean p2 = (o2 instanceof PriorityOrdered);
   if (p1 && !p2) {
      return -1;
   }
   else if (p2 && !p1) {
      return 1;
   }

   int i1 = getOrder(o1, sourceProvider);
   int i2 = getOrder(o2, sourceProvider);
   return Integer.compare(i1, i2);
}

private OrderComparator.OrderSourceProvider createFactoryAwareOrderSourceProvider(Map<String, ?> beans) {
   IdentityHashMap<Object, String> instancesToBeanNames = new IdentityHashMap<>();
   beans.forEach((beanName, instance) -> instancesToBeanNames.put(instance, beanName));
   return new FactoryAwareOrderSourceProvider(instancesToBeanNames);
}

@Override
@Nullable
public Object getOrderSource(Object obj) {
   String beanName = this.instancesToBeanNames.get(obj);
   // beanName 不为空
   // 存在 beanName 对应的 bean 定义
   if (beanName == null || !containsBeanDefinition(beanName)) {
      return null;
   }
   // 获取 beanName 的合并定义
   RootBeanDefinition beanDefinition = getMergedLocalBeanDefinition(beanName);
   List<Object> sources = new ArrayList<>(2);
   // 获取工厂函数
   Method factoryMethod = beanDefinition.getResolvedFactoryMethod();
   if (factoryMethod != null) {
      sources.add(factoryMethod);
   }
   // 获取 bean class 加入 sources 
   Class<?> targetType = beanDefinition.getTargetType();
   if (targetType != null && targetType != obj.getClass()) {
      sources.add(targetType);
   }
   return sources.toArray();
}

@Override
@SuppressWarnings("unchecked")
public <T> Map<String, T> getBeansOfType(@Nullable Class<T> type, boolean includeNonSingletons, boolean allowEagerInit)
      throws BeansException {

   // 根据类型获取所有的beanName
   String[] beanNames = getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
   // 返回结果
   Map<String, T> result = new LinkedHashMap<>(beanNames.length);
   // 循环beanName
   // 获取 bean 实例 放入返回结果. 
   for (String beanName : beanNames) {
      try {
         Object beanInstance = getBean(beanName);
         if (!(beanInstance instanceof NullBean)) {
            result.put(beanName, (T) beanInstance);
         }
      }
      catch (BeanCreationException ex) {
         Throwable rootCause = ex.getMostSpecificCause();
         if (rootCause instanceof BeanCurrentlyInCreationException) {
            BeanCreationException bce = (BeanCreationException) rootCause;
            String exBeanName = bce.getBeanName();
            if (exBeanName != null && isCurrentlyInCreation(exBeanName)) {
               if (logger.isTraceEnabled()) {
                  logger.trace("Ignoring match to currently created bean '" + exBeanName + "': " +
                        ex.getMessage());
               }
               onSuppressedException(ex);
               // Ignore: indicates a circular reference when autowiring constructors.
               // We want to find matches other than the currently created bean itself.
               continue;
            }
         }
         throw ex;
      }
   }
   return result;
}

@Override
public String[] getBeanNamesForAnnotation(Class<? extends Annotation> annotationType) {
   // 返回结果
   List<String> result = new ArrayList<>();
   // bean 定义名称的列表
   for (String beanName : this.beanDefinitionNames) {
      // 获取 bean 定义
      BeanDefinition beanDefinition = getBeanDefinition(beanName);
      // 1. bean 定义的 abstract 判断
      // 2. 寻找注解是否存在
      if (!beanDefinition.isAbstract() && findAnnotationOnBean(beanName, annotationType) != null) {
         result.add(beanName);
      }
   }
   // 手动注入的 单例对象 beanName 的处理
   for (String beanName : this.manualSingletonNames) {
      // 1. result 中是否已包含 当前正在处理的 beanName
      // 2. 寻找注解是否存在
      if (!result.contains(beanName) && findAnnotationOnBean(beanName, annotationType) != null) {
         result.add(beanName);
      }
   }
   return StringUtils.toStringArray(result);
}

@Override
@Nullable
public <A extends Annotation> A findAnnotationOnBean(String beanName, Class<A> annotationType)
      throws NoSuchBeanDefinitionException {

   return findMergedAnnotationOnBean(beanName, annotationType)
         .synthesize(MergedAnnotation::isPresent).orElse(null);
}

private <A extends Annotation> MergedAnnotation<A> findMergedAnnotationOnBean(
      String beanName, Class<A> annotationType) {

   // 获取 beanName 的类型
   Class<?> beanType = getType(beanName);
   if (beanType != null) {
      // 从 beanType 上获取注解的集合
      MergedAnnotation<A> annotation =
            MergedAnnotations.from(beanType, SearchStrategy.TYPE_HIERARCHY).get(annotationType);
      if (annotation.isPresent()) {
         return annotation;
      }
   }
   // 是否存在 bean 定义
   if (containsBeanDefinition(beanName)) {
      // 获取 合并的bean定义
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // Check raw bean class, e.g. in case of a proxy.
      if (bd.hasBeanClass()) {
         Class<?> beanClass = bd.getBeanClass();
         if (beanClass != beanType) {
            MergedAnnotation<A> annotation =
                  MergedAnnotations.from(beanClass, SearchStrategy.TYPE_HIERARCHY).get(annotationType);
            if (annotation.isPresent()) {
               return annotation;
            }
         }
      }
      // Check annotations declared on factory method, if any.
      Method factoryMethod = bd.getResolvedFactoryMethod();
      if (factoryMethod != null) {
         MergedAnnotation<A> annotation =
               MergedAnnotations.from(factoryMethod, SearchStrategy.TYPE_HIERARCHY).get(annotationType);
         if (annotation.isPresent()) {
            return annotation;
         }
      }
   }
   return MergedAnnotation.missing();
}

@Override
public Map<String, Object> getBeansWithAnnotation(Class<? extends Annotation> annotationType) {
   // 通过注解类型寻找 beanName
   String[] beanNames = getBeanNamesForAnnotation(annotationType);
   // 结果对象
   Map<String, Object> result = new LinkedHashMap<>(beanNames.length);
   for (String beanName : beanNames) {
      // 获取 bean 实例
      Object beanInstance = getBean(beanName);
      if (!(beanInstance instanceof NullBean)) {
         result.put(beanName, beanInstance);
      }
   }
   return result;
}

	protected boolean isAutowireCandidate(String beanName, DependencyDescriptor descriptor, AutowireCandidateResolver resolver)
			throws NoSuchBeanDefinitionException {

		// 转换 beanName
		String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
		// 是否存在 bean 定义
		if (containsBeanDefinition(beanDefinitionName)) {
			// 是否候选
			return isAutowireCandidate(beanName, getMergedLocalBeanDefinition(beanDefinitionName), descriptor, resolver);
		}
		// 是否是单例的
		else if (containsSingleton(beanName)) {
			// 是否候选
			return isAutowireCandidate(beanName, new RootBeanDefinition(getType(beanName)), descriptor, resolver);
		}

		// 父bean工厂执行 isAutowireCandidate
		BeanFactory parent = getParentBeanFactory();
		if (parent instanceof DefaultListableBeanFactory) {
			// No bean definition found in this factory -> delegate to parent.
			return ((DefaultListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor, resolver);
		}
		else if (parent instanceof ConfigurableListableBeanFactory) {
			// If no DefaultListableBeanFactory, can't pass the resolver along.
			return ((ConfigurableListableBeanFactory) parent).isAutowireCandidate(beanName, descriptor);
		}
		else {
			return true;
		}
	}

protected boolean isAutowireCandidate(String beanName, RootBeanDefinition mbd,
      DependencyDescriptor descriptor, AutowireCandidateResolver resolver) {

   // 转换 beanName
   String beanDefinitionName = BeanFactoryUtils.transformedBeanName(beanName);
   // 解析 bean class
   resolveBeanClass(mbd, beanDefinitionName);
   // 条件过滤
   // 1. 工厂方法是否唯一
   // 2. 工厂方法是否存在
   if (mbd.isFactoryMethodUnique && mbd.factoryMethodToIntrospect == null) {
      // ConstructorResolver 解析
      new ConstructorResolver(this).resolveFactoryMethodIfPossible(mbd);
   }
   // resolver 判断是否是候选注入对象
   return resolver.isAutowireCandidate(
         new BeanDefinitionHolder(mbd, beanName, getAliases(beanDefinitionName)), descriptor);
}

@Override
public void preInstantiateSingletons() throws BeansException {
   if (logger.isTraceEnabled()) {
      logger.trace("Pre-instantiating singletons in " + this);
   }

   // Iterate over a copy to allow for init methods which in turn register new bean definitions.
   // While this may not be part of the regular factory bootstrap, it does otherwise work fine.
   // beanNames 内容是 beanDefinition 的名称
   List<String> beanNames = new ArrayList<>(this.beanDefinitionNames);

   // Trigger initialization of all non-lazy singleton beans...
   // 处理非懒加载的bean进行实例化
   for (String beanName : beanNames) {
      // 获取 bean定义
      RootBeanDefinition bd = getMergedLocalBeanDefinition(beanName);
      // 条件过滤
      // 1. abstract 修饰
      // 2. 是否单例
      // 3. 是否懒加载
      if (!bd.isAbstract() && bd.isSingleton() && !bd.isLazyInit()) {
         // 是否是工厂bean
         if (isFactoryBean(beanName)) {
            // 获取 bean
            Object bean = getBean(FACTORY_BEAN_PREFIX + beanName);
            // 类型判断是否是 FactoryBean
            if (bean instanceof FactoryBean) {
               final FactoryBean<?> factory = (FactoryBean<?>) bean;
               // 是否立即加载
               boolean isEagerInit;
               // 计算 isEagerInit
               // 1. 是否是 SmartFactoryBean
               // 2. 执行SmartFactoryBean 的 isEagerInit 方法
               if (System.getSecurityManager() != null && factory instanceof SmartFactoryBean) {
                  isEagerInit = AccessController.doPrivileged((PrivilegedAction<Boolean>)
                              ((SmartFactoryBean<?>) factory)::isEagerInit,
                        getAccessControlContext());
               }
               else {
                  isEagerInit = (factory instanceof SmartFactoryBean &&
                        ((SmartFactoryBean<?>) factory).isEagerInit());
               }
               if (isEagerInit) {
                  getBean(beanName);
               }
            }
         }
         else {
            getBean(beanName);
         }
      }
   }

   // Trigger post-initialization callback for all applicable beans...
   // 触发回调方法
   for (String beanName : beanNames) {
      // 获取单例对象的实例
      Object singletonInstance = getSingleton(beanName);
      // 类型判断
      if (singletonInstance instanceof SmartInitializingSingleton) {
         // 执行 SmartInitializingSingleton 方法 afterSingletonsInstantiated
         final SmartInitializingSingleton smartSingleton = (SmartInitializingSingleton) singletonInstance;
         if (System.getSecurityManager() != null) {
            AccessController.doPrivileged((PrivilegedAction<Object>) () -> {
               smartSingleton.afterSingletonsInstantiated();
               return null;
            }, getAccessControlContext());
         }
         else {
            smartSingleton.afterSingletonsInstantiated();
         }
      }
   }
}

// 第一部分
// 类型验证
if (beanDefinition instanceof AbstractBeanDefinition) {
    try {
        // bean定义验证
        ((AbstractBeanDefinition) beanDefinition).validate();
    }
    catch (BeanDefinitionValidationException ex) {
        throw new BeanDefinitionStoreException(beanDefinition.getResourceDescription(), beanName,
                                               "Validation of bean definition failed", ex);
    }
}

// 第二部分 beanName 存在 BeanDefinition 的情况
// 从 map 中根据 beanName 获取 beanDefinition
BeanDefinition existingDefinition = this.beanDefinitionMap.get(beanName);
if (existingDefinition != null) {
   // bean name 是否允许重复注册
   if (!isAllowBeanDefinitionOverriding()) {
      throw new BeanDefinitionOverrideException(beanName, beanDefinition, existingDefinition);
   }
   // role 值比较
   else if (existingDefinition.getRole() < beanDefinition.getRole()) {
      // e.g. was ROLE_APPLICATION, now overriding with ROLE_SUPPORT or ROLE_INFRASTRUCTURE
      if (logger.isInfoEnabled()) {
         logger.info("Overriding user-defined bean definition for bean '" + beanName +
               "' with a framework-generated bean definition: replacing [" +
               existingDefinition + "] with [" + beanDefinition + "]");
      }
   }
   // map 中存储的 beanDefinition 是否和参数相同
   else if (!beanDefinition.equals(existingDefinition)) {
      if (logger.isDebugEnabled()) {
         logger.debug("Overriding bean definition for bean '" + beanName +
               "' with a different definition: replacing [" + existingDefinition +
               "] with [" + beanDefinition + "]");
      }
   }
   else {
      if (logger.isTraceEnabled()) {
         logger.trace("Overriding bean definition for bean '" + beanName +
               "' with an equivalent definition: replacing [" + existingDefinition +
               "] with [" + beanDefinition + "]");
      }
   }
   // 设置 beanName 和 beanDefinition 关系
   this.beanDefinitionMap.put(beanName, beanDefinition);
}

else {
   // 检查 bean 是否已经开始创建
   if (hasBeanCreationStarted()) {
      // Cannot modify startup-time collection elements anymore (for stable iteration)
      synchronized (this.beanDefinitionMap) {
         // 设置 beanName 和 beanDefinition 关系
         this.beanDefinitionMap.put(beanName, beanDefinition);
         // bean definition 的名称列表
         List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames.size() + 1);
         // 加入内存数据
         updatedDefinitions.addAll(this.beanDefinitionNames);
         // 加入当前的 beanName
         updatedDefinitions.add(beanName);
         // 对象替换
         this.beanDefinitionNames = updatedDefinitions;
         // 移除当前的beanName
         removeManualSingletonName(beanName);
      }
   }
   else {
      // Still in startup registration phase
      // 设置容器数据
      this.beanDefinitionMap.put(beanName, beanDefinition);
      this.beanDefinitionNames.add(beanName);
      // 移除当前的beanName
      removeManualSingletonName(beanName);
   }
   this.frozenBeanDefinitionNames = null;
}

private void removeManualSingletonName(String beanName) {
   updateManualSingletonNames(set -> set.remove(beanName), set -> set.contains(beanName));
}

/**
 * Update the factory's internal set of manual singleton names.
 * @param action the modification action
 * @param condition a precondition for the modification action
 * (if this condition does not apply, the action can be skipped)
 */

protected void resetBeanDefinition(String beanName) {
   // Remove the merged bean definition for the given bean, if already created.
   // 清空合并的BeanDefinition
   clearMergedBeanDefinition(beanName);

   // Remove corresponding bean from singleton cache, if any. Shouldn't usually
   // be necessary, rather just meant for overriding a context's default beans
   // (e.g. the default StaticMessageSource in a StaticApplicationContext).
   // 摧毁单例bean
   destroySingleton(beanName);

   // Notify all post-processors that the specified bean definition has been reset.
   for (BeanPostProcessor processor : getBeanPostProcessors()) {
      if (processor instanceof MergedBeanDefinitionPostProcessor) {
         // 执行后置方法的 resetBeanDefinition
         ((MergedBeanDefinitionPostProcessor) processor).resetBeanDefinition(beanName);
      }
   }

   // Reset all bean definitions that have the given bean as parent (recursively).
   for (String bdName : this.beanDefinitionNames) {
      if (!beanName.equals(bdName)) {
         BeanDefinition bd = this.beanDefinitionMap.get(bdName);
         // Ensure bd is non-null due to potential concurrent modification
         // of the beanDefinitionMap.
         if (bd != null && beanName.equals(bd.getParentName())) {
            // 递归刷新 beanName 对应的 beanDefinition
            resetBeanDefinition(bdName);
         }
      }
   }
}

@Override
public void removeBeanDefinition(String beanName) throws NoSuchBeanDefinitionException {
   Assert.hasText(beanName, "'beanName' must not be empty");

   // 删除 beanName key
   BeanDefinition bd = this.beanDefinitionMap.remove(beanName);
   if (bd == null) {
      if (logger.isTraceEnabled()) {
         logger.trace("No bean named '" + beanName + "' found in " + this);
      }
      throw new NoSuchBeanDefinitionException(beanName);
   }

   if (hasBeanCreationStarted()) {
      // Cannot modify startup-time collection elements anymore (for stable iteration)
      synchronized (this.beanDefinitionMap) {
         List<String> updatedDefinitions = new ArrayList<>(this.beanDefinitionNames);
         // 删除需要移除的BeanName
         updatedDefinitions.remove(beanName);
         // 重新赋值
         this.beanDefinitionNames = updatedDefinitions;
      }
   }
   else {
      // Still in startup registration phase
      // 移除 beanName
      this.beanDefinitionNames.remove(beanName);
   }
   this.frozenBeanDefinitionNames = null;

   // 刷新bean definition
   resetBeanDefinition(beanName);
}

// 第一部分
// 解析 实际方式 beanFactory.getBean
Object shortcut = descriptor.resolveShortcut(this);
if (shortcut != null) {
   return shortcut;
}

// 第二部分
// 获取依赖类型
Class<?> type = descriptor.getDependencyType();
// AutowireCandidateResolver 方法获取数据
Object value = getAutowireCandidateResolver().getSuggestedValue(descriptor);
if (value != null) {
   // el 表达式相关处理
   // 类型是否是 string
   if (value instanceof String) {
      // 解析字符串.
      String strVal = resolveEmbeddedValue((String) value);
      BeanDefinition bd = (beanName != null && containsBean(beanName) ?
            getMergedBeanDefinition(beanName) : null);
      // beanName , beanDefinition
      // el 表达式解析
      value = evaluateBeanDefinitionString(strVal, bd);
   }
   // 类型转换器
   TypeConverter converter = (typeConverter != null ? typeConverter : getTypeConverter());
   try {
      // 转换返回
      return converter.convertIfNecessary(value, type, descriptor.getTypeDescriptor());
   }
   catch (UnsupportedOperationException ex) {
      // A custom TypeConverter which does not support TypeDescriptor resolution...
      // 类型转换
      // 1. field 转换
      // 2. method parameter 转换
      return (descriptor.getField() != null ?
            converter.convertIfNecessary(value, type, descriptor.getField()) :
            converter.convertIfNecessary(value, type, descriptor.getMethodParameter()));
   }
}

// 第三部分
// 多个依赖的处理
Object multipleBeans = resolveMultipleBeans(descriptor, beanName, autowiredBeanNames, typeConverter);
if (multipleBeans != null) {
   return multipleBeans;
}

// 寻找 beanName 列表, 根据类型搜索. 这里会找出父容器中的 类型对应的名称 最后统一返回
public static String[] beanNamesForTypeIncludingAncestors(
      ListableBeanFactory lbf, Class<?> type, boolean includeNonSingletons, boolean allowEagerInit) {

   Assert.notNull(lbf, "ListableBeanFactory must not be null");

   // 通过 ListableBeanFactory 的 getBeanNamesForType 配合 类型搜索存在的 beanName
   String[] result = lbf.getBeanNamesForType(type, includeNonSingletons, allowEagerInit);
   // 类型验证
   if (lbf instanceof HierarchicalBeanFactory) {
      HierarchicalBeanFactory hbf = (HierarchicalBeanFactory) lbf;
      // 查询是否存在父工厂 , 存在的情况下且类型是ListableBeanFactory
      if (hbf.getParentBeanFactory() instanceof ListableBeanFactory) {
         String[] parentResult = beanNamesForTypeIncludingAncestors(
               (ListableBeanFactory) hbf.getParentBeanFactory(), type, includeNonSingletons, allowEagerInit);
         // 数据合并
         result = mergeNamesWithParent(result, parentResult, hbf);
      }
   }
   return result;
}j