Spring AbstractBeanFactory

protected String transformedBeanName(String name) {
   // 转换 beanName .
   // 1. 通过·BeanFactoryUtils.transformedBeanName· 求beanName
   // 2. 如果是有别名的(方法参数是别名) . 会从别名列表中获取对应的 beanName
   return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

	public static String transformedBeanName(String name) {
		Assert.notNull(name, "'name' must not be null");
		// 名字不是 & 开头直接返回
		if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
			return name;
		}
		// 截取字符串 在返回
		return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
			do {
				beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
			}
			while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
			return beanName;
		});
	}

public String canonicalName(String name) {
   String canonicalName = name;
   // Handle aliasing...
   String resolvedName;
   do {
      // 别名的获取
      resolvedName = this.aliasMap.get(canonicalName);
      if (resolvedName != null) {
         canonicalName = resolvedName;
      }
   }
   while (resolvedName != null);
   return canonicalName;
}

protected String originalBeanName(String name) {
   // 转换 beanName
   String beanName = transformedBeanName(name);
   // 是否是 & 开头, & 开头代表工厂bean
   if (name.startsWith(FACTORY_BEAN_PREFIX)) {
      // 计算新的名字
      beanName = FACTORY_BEAN_PREFIX + beanName;
   }
   return beanName;
}

// 转换beanName
final String beanName = transformedBeanName(name);
Object bean;

// Eagerly check singleton cache for manually registered singletons.
// 获取单例对象
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 + "'");
      }
   }
   // 获取bean实例
   bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
}

// Create bean instance.
// 单例创建
// 判断是否是单例
if (mbd.isSingleton()) {
   // 获取bean单例bean
   sharedInstance = getSingleton(beanName, () -> {
      try {
         // 创建bean
         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.
         // 摧毁单例的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);
}

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

// Check if bean definition exists in this factory.
// 获取父bean工厂
// 从 父bean工厂中创建
BeanFactory parentBeanFactory = getParentBeanFactory();
// 从 父bean 工厂中查询
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // Not found -> check parent.
   // 确定beanName
   String nameToLookup = originalBeanName(name);
      // 父bean工厂 类型判断
   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);
   }
}

else {
   // 获取作用域名称
   String scopeName = mbd.getScope();
   // 从作用域容器中获取当前作用域名称对应的作用域接口 scope
   final Scope scope = this.scopes.get(scopeName);
   if (scope == null) {
      throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
   }
   try {
      // 从 scope 接口卓获取
      Object scopedInstance = scope.get(beanName, () -> {
         // 创建之前做的行为
         beforePrototypeCreation(beanName);
         try {
            // 创建 bean
            return createBean(beanName, mbd, args);
         }
         finally {
            // 创建之后做的行为
            afterPrototypeCreation(beanName);
         }
      });
      // 获取 bean 实例
      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);
   }
}

final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
checkMergedBeanDefinition(mbd, beanName, args);

// Guarantee initialization of beans that the current bean depends on.
// 需要依赖的bean
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);
      }
   }
}

	private final Map<String, Set<String>> dependentBeanMap = new ConcurrentHashMap<>(64);


	private final Map<String, Set<String>> dependenciesForBeanMap = new ConcurrentHashMap<>(64);

public void registerDependentBean(String beanName, String dependentBeanName) {
   // 别名
   String canonicalName = canonicalName(beanName);

   synchronized (this.dependentBeanMap) {
      // 向依赖关系中放入数据
      Set<String> dependentBeans =
            this.dependentBeanMap.computeIfAbsent(canonicalName, k -> new LinkedHashSet<>(8));
      if (!dependentBeans.add(dependentBeanName)) {
         return;
      }
   }

   synchronized (this.dependenciesForBeanMap) {
      Set<String> dependenciesForBean =
            this.dependenciesForBeanMap.computeIfAbsent(dependentBeanName, k -> new LinkedHashSet<>(8));
      dependenciesForBean.add(canonicalName);
   }
}

Object object = null;
if (mbd != null) {
   mbd.isFactoryBean = true;
}
else {
   // 缓存中获取
   object = getCachedObjectForFactoryBean(beanName);
}
if (object == null) {
   // Return bean instance from factory.
   // 如果还是 null 从 factory bean 中创建
   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());
   // 从 FactoryBean 中获取bean实例
   object = getObjectFromFactoryBean(factory, beanName, !synthetic);
}

@SuppressWarnings("unchecked")
protected void beforePrototypeCreation(String beanName) {
   // 从正在创建的bean名称列表中获取
   Object curVal = this.prototypesCurrentlyInCreation.get();
   if (curVal == null) {
      // 设置正在创建的bean
      this.prototypesCurrentlyInCreation.set(beanName);
   }
   else if (curVal instanceof String) {
      // 设置正在创建的bean Name
      Set<String> beanNameSet = new HashSet<>(2);
      beanNameSet.add((String) curVal);
      beanNameSet.add(beanName);
      this.prototypesCurrentlyInCreation.set(beanNameSet);
   }
   else {
      // 其他情况
      Set<String> beanNameSet = (Set<String>) curVal;
      beanNameSet.add(beanName);
   }
}

@SuppressWarnings("unchecked")
protected void afterPrototypeCreation(String beanName) {
   // 获取当前正在创建的beanName
   Object curVal = this.prototypesCurrentlyInCreation.get();
   // 是否字符串类型
   if (curVal instanceof String) {
      // 直接移除
      this.prototypesCurrentlyInCreation.remove();
   }
   // 是否是 set 类型
   else if (curVal instanceof Set) {
      Set<String> beanNameSet = (Set<String>) curVal;
      // set 类型中移除 beanName
      beanNameSet.remove(beanName);
      if (beanNameSet.isEmpty()) {
         // 清空set
         this.prototypesCurrentlyInCreation.remove();
      }
   }
}

if (containsSingleton(beanName) || containsBeanDefinition(beanName))

protected abstract boolean containsBeanDefinition(String beanName);

return (!BeanFactoryUtils.isFactoryDereference(name) || isFactoryBean(name));

 BeanFactory parentBeanFactory = getParentBeanFactory();

   return (parentBeanFactory != null && parentBeanFactory.containsBean(originalBeanName(name)));

// 获取 beanName
String beanName = transformedBeanName(name);

// 获取单例对象实例
Object beanInstance = getSingleton(beanName, false);
if (beanInstance != null) {
   if (beanInstance instanceof FactoryBean) {
      // beanName 是否是 & 开头
      // FactoryBean 是否是单例的
      return (BeanFactoryUtils.isFactoryDereference(name) || ((FactoryBean<?>) beanInstance).isSingleton());
   }
   else {
      // 是否是 & 开头
      return !BeanFactoryUtils.isFactoryDereference(name);
   }
}

// 获取 父beanFactory
BeanFactory parentBeanFactory = getParentBeanFactory();
// 父beanFactory 是否为空
// 是否包含 beanName
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // No bean definition found in this factory -> delegate to parent.
   // 通过父BeanFactory 判断是否是单例的
   return parentBeanFactory.isSingleton(originalBeanName(name));
}

/**
 * Determines if the class or interface represented by this
 * {@code Class} object is either the same as, or is a superclass or
 * superinterface of, the class or interface represented by the specified
 * {@code Class} parameter. It returns {@code true} if so;
 * otherwise it returns {@code false}. If this {@code Class}
 * object represents a primitive type, this method returns
 * {@code true} if the specified {@code Class} parameter is
 * exactly this {@code Class} object; otherwise it returns
 * {@code false}.
 *
 * <p> Specifically, this method tests whether the type represented by the
 * specified {@code Class} parameter can be converted to the type
 * represented by this {@code Class} object via an identity conversion
 * or via a widening reference conversion. See <em>The Java Language
 * Specification</em>, sections 5.1.1 and 5.1.4 , for details.
 *
 * @param cls the {@code Class} object to be checked
 * @return the {@code boolean} value indicating whether objects of the
 * type {@code cls} can be assigned to objects of this class
 * @exception NullPointerException if the specified Class parameter is
 *            null.
 * @since JDK1.1
 */
public native boolean isAssignableFrom(Class<?> cls);

interface D {

}

public class JvmDemoApplication {

   public static void main(String[] args) {
      System.out.println(A.class.isAssignableFrom(B.class)); // false
      System.out.println(C.class.isAssignableFrom(A.class)); // false
      System.out.println(A.class.isAssignableFrom(C.class)); // true
      System.out.println(D.class.isAssignableFrom(A.class)); // false

      C c = new C();
      A a = new A();
      A a1 = c;
      C c1 = (C) a; // 转换异常 java.lang.ClassCastException
      System.out.println();
   }

}

class A {
}

class B {
}

class C extends A
      implements D {

}

// 获取 beanName
String beanName = transformedBeanName(name);
// 判断是否是 & 开头
boolean isFactoryDereference = BeanFactoryUtils.isFactoryDereference(name);

// Check manually registered singletons.
// 获取 bean实例
Object beanInstance = getSingleton(beanName, false);

if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
   // 是否是 FactoryBean 类型
   if (beanInstance instanceof FactoryBean) {
      if (!isFactoryDereference) {
         // 从 factoryBean中获取类型.
         Class<?> type = getTypeForFactoryBean((FactoryBean<?>) beanInstance);
         // 类型不为空
         // typeToMatch类型是否来自 type
         return (type != null && typeToMatch.isAssignableFrom(type));
      }
      else {
         // 是否是接口实现
         return typeToMatch.isInstance(beanInstance);
      }
   }

@Nullable
protected Class<?> getTypeForFactoryBean(final FactoryBean<?> factoryBean) {
   try {
      if (System.getSecurityManager() != null) {
         // 从 factoryBean 获取类型后通过 AccessController 绕一圈获取
         return AccessController.doPrivileged((PrivilegedAction<Class<?>>)
               factoryBean::getObjectType, getAccessControlContext());
      }
      else {
         // 调用 factoryBean 的 getObjectType 方法获取类型
         return factoryBean.getObjectType();
      }
   }
   catch (Throwable ex) {
      // Thrown from the FactoryBean's getObjectType implementation.
      logger.info("FactoryBean threw exception from getObjectType, despite the contract saying " +
            "that it should return null if the type of its object cannot be determined yet", ex);
      return null;
   }
}

return (type != null && typeToMatch.isAssignableFrom(type));

return typeToMatch.isInstance(beanInstance);

else if (typeToMatch.hasGenerics() && containsBeanDefinition(beanName)) {}	

// 获取 合并后的 BeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 获取 beanDefinition 的类型
Class<?> targetType = mbd.getTargetType();

if (targetType != null && targetType != ClassUtils.getUserClass(beanInstance)) {}

public static Class<?> getUserClass(Class<?> clazz) {
   if (clazz.getName().contains(CGLIB_CLASS_SEPARATOR)) {
      Class<?> superclass = clazz.getSuperclass();
      if (superclass != null && superclass != Object.class) {
         return superclass;
      }
   }
   return clazz;
}

// 类型解析得到真实类型
Class<?> classToMatch = typeToMatch.resolve();
// 真实类型是否为空
// 真是类型是否是bean实例的实现
if (classToMatch != null && !classToMatch.isInstance(beanInstance)) {
   return false;
}
// typeToMatch 是否来自 targetType
if (typeToMatch.isAssignableFrom(targetType)) {
   return true;
}

// 获取目标类型
ResolvableType resolvableType = mbd.targetType;
if (resolvableType == null) {
   // 类型设置成 工厂方法的返回值类型
   resolvableType = mbd.factoryMethodReturnType;
}
// typeToMatch 是否来自 resolvableType
return (resolvableType != null && typeToMatch.isAssignableFrom(resolvableType));

// 不是单例 && 不存在beanName
else if (containsSingleton(beanName) && !containsBeanDefinition(beanName)) {
   // null instance registered
   return false;
}

// 获取父bean工厂
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
   // No bean definition found in this factory -> delegate to parent.
   // 父 bean 工厂判断类型是否匹配
   return parentBeanFactory.isTypeMatch(originalBeanName(name), typeToMatch);
}

// Retrieve corresponding bean definition.
// 获取当前 beanName 合并后的BeanDefinition
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 获取 beanName 对应的 beanDefinition 持有类
BeanDefinitionHolder dbd = mbd.getDecoratedDefinition();

// Setup the types that we want to match against
// 解析类型
Class<?> classToMatch = typeToMatch.resolve();
if (classToMatch == null) {
   // 强制等于 FactoryBean
   classToMatch = FactoryBean.class;
}
// 创建待匹配的类型数组
Class<?>[] typesToMatch = (FactoryBean.class == classToMatch ?
      new Class<?>[] {classToMatch} : new Class<?>[] {FactoryBean.class, classToMatch});


// Attempt to predict the bean type
// 预测bean类型
Class<?> predictedType = null;

if (!isFactoryDereference && dbd != null && isFactoryBean(beanName, mbd)) {
   // We should only attempt if the user explicitly set lazy-init to true
   // and we know the merged bean definition is for a factory bean.
   // 是否懒加载
   // 是否允许 factoryBean 初始化
   if (!mbd.isLazyInit() || allowFactoryBeanInit) {
      // 获取合并的beanDefinition
      RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
      // 类型猜测
      Class<?> targetType = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);
      // 类型是否为空
      // targetType 是否来自 FactoryBean
      if (targetType != null && !FactoryBean.class.isAssignableFrom(targetType)) {
         predictedType = targetType;
      }
   }
}

@Nullable
protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch) {
   // 获取目标类型
   Class<?> targetType = mbd.getTargetType();
   // 是否为空
   if (targetType != null) {
      return targetType;
   }
   // 获取 工厂方法的返回值 判断是否为空
   if (mbd.getFactoryMethodName() != null) {
      return null;
   }
   // 解析 beanClass
   return resolveBeanClass(mbd, beanName, typesToMatch);
}

@Nullable
protected Class<?> resolveBeanClass(final RootBeanDefinition mbd, String beanName, final Class<?>... typesToMatch)
      throws CannotLoadBeanClassException {

   try {
      // 是否包含 bean 类型
      if (mbd.hasBeanClass()) {
         // 直接返回
         return mbd.getBeanClass();
      }
      if (System.getSecurityManager() != null) {
         return AccessController.doPrivileged((PrivilegedExceptionAction<Class<?>>) () ->
               doResolveBeanClass(mbd, typesToMatch), getAccessControlContext());
      }
      else {
         // 从 bean definition 中获取
         return doResolveBeanClass(mbd, typesToMatch);
      }
   }
   catch (PrivilegedActionException pae) {
      ClassNotFoundException ex = (ClassNotFoundException) pae.getException();
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
   }
   catch (ClassNotFoundException ex) {
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), ex);
   }
   catch (LinkageError err) {
      throw new CannotLoadBeanClassException(mbd.getResourceDescription(), beanName, mbd.getBeanClassName(), err);
   }
}

// 类加载器
ClassLoader beanClassLoader = getBeanClassLoader();
// 类加载器
ClassLoader dynamicLoader = beanClassLoader;
// 是否需要刷新
boolean freshResolve = false;

// 判断 typesToMatch 是否为空
if (!ObjectUtils.isEmpty(typesToMatch)) {
   // When just doing type checks (i.e. not creating an actual instance yet),
   // use the specified temporary class loader (e.g. in a weaving scenario).
   // 获取临时类加载器
   ClassLoader tempClassLoader = getTempClassLoader();
   if (tempClassLoader != null) {
      dynamicLoader = tempClassLoader;
      freshResolve = true;
      // 类型比较
      if (tempClassLoader instanceof DecoratingClassLoader) {
         DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
         for (Class<?> typeToMatch : typesToMatch) {
            // 添加排除的类
            dcl.excludeClass(typeToMatch.getName());
         }
      }
   }
}

DecoratingClassLoader dcl = (DecoratingClassLoader) tempClassLoader;
for (Class<?> typeToMatch : typesToMatch) {
   // 添加排除的类
   dcl.excludeClass(typeToMatch.getName());
}

// 获取className
String className = mbd.getBeanClassName();
if (className != null) {
   // bean 属性值
   Object evaluated = evaluateBeanDefinitionString(className, mbd);

   if (!className.equals(evaluated)) {
      // A dynamically resolved expression, supported as of 4.2...
      if (evaluated instanceof Class) {
         return (Class<?>) evaluated;
      }
      else if (evaluated instanceof String) {
         className = (String) evaluated;
         freshResolve = true;
      }
      else {
         throw new IllegalStateException("Invalid class name expression result: " + evaluated);
      }
   }

      // 工具方法创建
      return ClassUtils.forName(className, dynamicLoader);
   }
}

if (freshResolve) {
   // When resolving against a temporary class loader, exit early in order
   // to avoid storing the resolved Class in the bean definition.
   if (dynamicLoader != null) {
      try {
         // 动态加载器
         return dynamicLoader.loadClass(className);
      }
      catch (ClassNotFoundException ex) {
         if (logger.isTraceEnabled()) {
            logger.trace("Could not load class [" + className + "] from " + dynamicLoader + ": " + ex);
         }
      }
   }
   // 工具方法创建
   return ClassUtils.forName(className, dynamicLoader);
}

public static Class<?> forName(String name, @Nullable ClassLoader classLoader)
      throws ClassNotFoundException, LinkageError {

   Assert.notNull(name, "Name must not be null");

   // 基类的映射关系, int -> int.class 等
   Class<?> clazz = resolvePrimitiveClassName(name);
   if (clazz == null) {
      // 缓存中获取
      clazz = commonClassCache.get(name);
   }
   if (clazz != null) {
      // 返回
      return clazz;
   }

   // "java.lang.String[]" style arrays
   if (name.endsWith(ARRAY_SUFFIX)) {
      String elementClassName = name.substring(0, name.length() - ARRAY_SUFFIX.length());
      Class<?> elementClass = forName(elementClassName, classLoader);
      return Array.newInstance(elementClass, 0).getClass();
   }

   // "[Ljava.lang.String;" style arrays
   if (name.startsWith(NON_PRIMITIVE_ARRAY_PREFIX) && name.endsWith(";")) {
      String elementName = name.substring(NON_PRIMITIVE_ARRAY_PREFIX.length(), name.length() - 1);
      Class<?> elementClass = forName(elementName, classLoader);
      return Array.newInstance(elementClass, 0).getClass();
   }

   // "[[I" or "[[Ljava.lang.String;" style arrays
   if (name.startsWith(INTERNAL_ARRAY_PREFIX)) {
      String elementName = name.substring(INTERNAL_ARRAY_PREFIX.length());
      Class<?> elementClass = forName(elementName, classLoader);
      return Array.newInstance(elementClass, 0).getClass();
   }

   ClassLoader clToUse = classLoader;
   if (clToUse == null) {
      // 获取默认的 class loader
      clToUse = getDefaultClassLoader();
   }
   try {
      // 调用  class 方法生成 class 对象
      return Class.forName(name, false, clToUse);
   }
   catch (ClassNotFoundException ex) {
      int lastDotIndex = name.lastIndexOf(PACKAGE_SEPARATOR);
      if (lastDotIndex != -1) {
         String innerClassName =
               name.substring(0, lastDotIndex) + INNER_CLASS_SEPARATOR + name.substring(lastDotIndex + 1);
         try {
            return Class.forName(innerClassName, false, clToUse);
         }
         catch (ClassNotFoundException ex2) {
            // Swallow - let original exception get through
         }
      }
      throw ex;
   }
}

@Nullable
public Class<?> resolveBeanClass(@Nullable ClassLoader classLoader) throws ClassNotFoundException {
   // 获取beanClassName
   String className = getBeanClassName();
   if (className == null) {
      return null;
   }
   // 加载类
   Class<?> resolvedClass = ClassUtils.forName(className, classLoader);
   this.beanClass = resolvedClass;
   // 返回
   return resolvedClass;
}

if (!mbd.isLazyInit() || allowFactoryBeanInit) {
   // 获取合并的beanDefinition
   RootBeanDefinition tbd = getMergedBeanDefinition(dbd.getBeanName(), dbd.getBeanDefinition(), mbd);
   // 类型猜测
   Class<?> targetType = predictBeanType(dbd.getBeanName(), tbd, typesToMatch);
   // 类型是否为空
   // targetType 是否来自 FactoryBean
   if (targetType != null && !FactoryBean.class.isAssignableFrom(targetType)) {
      predictedType = targetType;
   }
}

// If we couldn't use the target type, try regular prediction.
if (predictedType == null) {
   // 类型猜测
   predictedType = predictBeanType(beanName, mbd, typesToMatch);
   if (predictedType == null) {
      return false;
   }
}

// Attempt to get the actual ResolvableType for the bean.
ResolvableType beanType = null;

// If it's a FactoryBean, we want to look at what it creates, not the factory class.
if (FactoryBean.class.isAssignableFrom(predictedType)) {
   if (beanInstance == null && !isFactoryDereference) {
      // 从 factoryBean 中获取类型
      beanType = getTypeForFactoryBean(beanName, mbd, allowFactoryBeanInit);
      // 解析类型. 设置bean类型
      predictedType = beanType.resolve();
      if (predictedType == null) {
         return false;
      }
   }
}

protected ResolvableType getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit) {
   ResolvableType result = getTypeForFactoryBeanFromAttributes(mbd);
   if (result != ResolvableType.NONE) {
      return result;
   }

   if (allowInit && mbd.isSingleton()) {
      try {
         FactoryBean<?> factoryBean = doGetBean(FACTORY_BEAN_PREFIX + beanName, FactoryBean.class, null, true);
         Class<?> objectType = getTypeForFactoryBean(factoryBean);
         return (objectType != null) ? ResolvableType.forClass(objectType) : ResolvableType.NONE;
      }
      catch (BeanCreationException ex) {
         if (ex.contains(BeanCurrentlyInCreationException.class)) {
            logger.trace(LogMessage.format("Bean currently in creation on FactoryBean type check: %s", ex));
         }
         else if (mbd.isLazyInit()) {
            logger.trace(LogMessage.format("Bean creation exception on lazy FactoryBean type check: %s", ex));
         }
         else {
            logger.debug(LogMessage.format("Bean creation exception on non-lazy FactoryBean type check: %s", ex));
         }
         onSuppressedException(ex);
      }
   }
   return ResolvableType.NONE;
}

protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd) {
   // RootBeanDefinition 进行判断
   Boolean result = mbd.isFactoryBean;
   if (result == null) {
      // 类型推测
      Class<?> beanType = predictBeanType(beanName, mbd, FactoryBean.class);
      // 判断是否空, 判断是否来自 FactoryBean
      result = (beanType != null && FactoryBean.class.isAssignableFrom(beanType));
      mbd.isFactoryBean = result;
   }
   return result;
}

protected void markBeanAsCreated(String beanName) {
   // 已创建的beanName 是否包含当前beanName
   if (!this.alreadyCreated.contains(beanName)) {
      synchronized (this.mergedBeanDefinitions) {
         if (!this.alreadyCreated.contains(beanName)) {
            // Let the bean definition get re-merged now that we're actually creating
            // the bean... just in case some of its metadata changed in the meantime.
            // 将属性stale设置true
            clearMergedBeanDefinition(beanName);
            // 放入已创建集合中
            this.alreadyCreated.add(beanName);
         }
      }
   }
}

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException {
   // Quick check on the concurrent map first, with minimal locking.
   // 缓存中获取
   RootBeanDefinition mbd = this.mergedBeanDefinitions.get(beanName);
   if (mbd != null && !mbd.stale) {
      return mbd;
   }
   // 合并的 bean 定义
   return getMergedBeanDefinition(beanName, getBeanDefinition(beanName));
}

// 合并的bean定义
RootBeanDefinition mbd = null;
// 历史 bean定义
RootBeanDefinition previous = null;

if (containingBd == null) {
   // 从缓存中获取
   mbd = this.mergedBeanDefinitions.get(beanName);
}

private final Map<String, RootBeanDefinition> mergedBeanDefinitions = new ConcurrentHashMap<>(256);

if (mbd == null || mbd.stale) {
    previous = mbd;
    // 是否存在父名称
    if (bd.getParentName() == null) {
       // Use copy of given root bean definition.
       // 类型是否等于RootBeanDefinition
       if (bd instanceof RootBeanDefinition) {
          // 做一次对象拷贝
          mbd = ((RootBeanDefinition) bd).cloneBeanDefinition();
       }
       else {
          // 将 beanDefinition 创建成 RootBeanDefinition
          // merge BeanDefinition
          mbd = new RootBeanDefinition(bd);
       }
    }

// Deep copy with overridden values.
// 将 父 BeanDefinition 对象拷贝
mbd = new RootBeanDefinition(pbd);
// 覆盖 beanDefinition
mbd.overrideFrom(bd);

// Set default singleton scope, if not configured before.
// 作用域设置
if (!StringUtils.hasLength(mbd.getScope())) {
   // 没有设置作用域直接给单例类型
   mbd.setScope(SCOPE_SINGLETON);
}

// A bean contained in a non-singleton bean cannot be a singleton itself.
// Let's correct this on the fly here, since this might be the result of
// parent-child merging for the outer bean, in which case the original inner bean
// definition will not have inherited the merged outer bean's singleton status.
// 修正 作用域
if (containingBd != null && !containingBd.isSingleton() && mbd.isSingleton()) {
   mbd.setScope(containingBd.getScope());
}

// Cache the merged bean definition for the time being
// (it might still get re-merged later on in order to pick up metadata changes)
if (containingBd == null && isCacheBeanMetadata()) {
   // 放入缓存
   this.mergedBeanDefinitions.put(beanName, mbd);
}

if (previous != null) {
   // 设置部分bean定义信息
   copyRelevantMergedBeanDefinitionCaches(previous, mbd);
}
return mbd;

private void copyRelevantMergedBeanDefinitionCaches(RootBeanDefinition previous, RootBeanDefinition mbd) {
		if (ObjectUtils.nullSafeEquals(mbd.getBeanClassName(), previous.getBeanClassName()) &&
				ObjectUtils.nullSafeEquals(mbd.getFactoryBeanName(), previous.getFactoryBeanName()) &&
				ObjectUtils.nullSafeEquals(mbd.getFactoryMethodName(), previous.getFactoryMethodName())) {
			ResolvableType targetType = mbd.targetType;
			ResolvableType previousTargetType = previous.targetType;
			if (targetType == null || targetType.equals(previousTargetType)) {
				mbd.targetType = previousTargetType;
				mbd.isFactoryBean = previous.isFactoryBean;
				mbd.resolvedTargetType = previous.resolvedTargetType;
				mbd.factoryMethodReturnType = previous.factoryMethodReturnType;
				mbd.factoryMethodToIntrospect = previous.factoryMethodToIntrospect;
			}
		}
	}

String beanName = transformedBeanName(name);

// Check manually registered singletons.
// 获取 bean 实例
Object beanInstance = getSingleton(beanName, false);
// bean 实例是否为空, bean 实例的类型是否是 NullBean
if (beanInstance != null && beanInstance.getClass() != NullBean.class) {
    if (beanInstance instanceof FactoryBean && !BeanFactoryUtils.isFactoryDereference(name)) {
        // 从 FactoryBean 中获取类型 factoryBean.getObjectType()
        return getTypeForFactoryBean((FactoryBean<?>) beanInstance);
    }
    else {
        // 获取实例的类型
        return beanInstance.getClass();
    }
}