Spring源码学习笔记——Bean加载

public interface FactoryBean<T> {
    // 获取由FactoryBean创建的Bean实例：
    @Nullable
    T getObject() throws Exception;
    // 获得FactoryBean创建的Bean的类型：
    @Nullable
    Class<?> getObjectType();
    // 判断Bean实例的作用域是否是单例Singleton，是则返回true，否则返回false
    // 如果该实例是单例模式的，则该Bean实例会放到Spring容器的单例缓存池中：
    default boolean isSingleton() {
        return true;
    }
}

public interface BeanFactory {
    // 如果Bean实例对象对应的beanName开头带有&符号，说明是一个FactoryBean类型的对象
    String FACTORY_BEAN_PREFIX = "&";
    // 根据beanName从BeanFactory中获取Bean对象
    Object getBean(String name) throws BeansException;
    <T> T getBean(String name, Class<T> requiredType) throws BeansException;
    Object getBean(String name, Object... args) throws BeansException;
    // 从BeanFactory中获取指定类型(requiredType)的Bean对象
    <T> T getBean(Class<T> requiredType) throws BeansException;
    <T> T getBean(Class<T> requiredType, Object... args) throws BeansException;
    <T> ObjectProvider<T> getBeanProvider(Class<T> requiredType);
    <T> ObjectProvider<T> getBeanProvider(ResolvableType requiredType);
    // 判断BeanFactory中是否包含指定beanName的Bean对象
    boolean containsBean(String name);
    // 当前Bean对象是否是单例Singleton
    boolean isSingleton(String name) throws NoSuchBeanDefinitionException;
    // 当前Bean对象是否是Prototyp模式
    boolean isPrototype(String name) throws NoSuchBeanDefinitionException;
    boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException;
    oolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException;
    // 根据beanName获取Bean对象的类型
    Class<?> getType(String name) throws NoSuchBeanDefinitionException;
    Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException;
    // 获取指定Bean的别名列表
    String[] getAliases(String name);
}

public class Student {
   private int age;
   private String name;
   private String school;
   // setter/getter方法省略
}

public class StudentFactoryBean implements FactoryBean<Student> {
   private String studentInfo;
   public String getStudentInfo() {
      return studentInfo;
   }
   public void setStudentInfo(String studentInfo) {
      this.studentInfo = studentInfo;
   }
   @Override
   public Student getObject() throws Exception {
      Student stu = new Student();
      String[] splitInfo = studentInfo.split(",");
      stu.setAge(Integer.valueOf(splitInfo[0]));
      stu.setName(splitInfo[1]);
      stu.setSchool(splitInfo[2]);
      return stu;
   }
   @Override
   public Class<Student> getObjectType() {
      return Student.class;
   }
   @Override
   public boolean isSingleton() {
      return false;
   }
}

<bean id="studentFactoryBean" class="top.csp1999.StudentFactoryBean">
   <property name="studentInfo" value="18,csp,Haust" />
</bean>

public class ComponentA {
}

public class ComponentB {
}

public class BeanFactoryTest {
  public static void main(String[] args) {
    // 加载与解析XML配置文件，获得BeanFactory：
    BeanFactory beanFactory = new XmlBeanFactory(new ClassPathResource("spring-bf.xml"));
    // 从BeanFactory中获取Bean对象
    Object a = beanFactory.getBean("componentA");
    Object b = beanFactory.getBean("componentB");
    System.out.println(a);// com.myspring.test.xmltest.ComponentA@1c93084c
    System.out.println(b);// com.myspring.test.xmltest.ComponentB@6ef888f6
  }
}

/**
 * 根据参数name,requiredType,args获取Bean对象实例:
 *
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型 -> 获取Bean对象时，不仅要根据name去检索，还要判断Bean的类型是否一致
 * @param args 这个参数用到再做分析
 * @return 该方法返回目标Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args)
    throws BeansException {
  // 调用真正去获取Bean对象的方法：
  // 注：Spring框架源码的命名规范非常严谨,doXxx方法（内层方法）内封装的是具体执行逻辑的代码,而调用doXxx的方法是其外层方法
  return doGetBean(name, requiredType, args, false);
}
/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
@SuppressWarnings("unchecked")
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
  // transformedBeanName(name)方法：根据传入的name参数,获取真正的Bean对应的beanName,什么意思呢？
  // Spring中管理的Beand对象是可以指定设置别名的，Spring Bean设置别名的两种方式：参考 https://blog.csdn.net/qq_34129814/article/details/7
  // 参数传进来的name，有可能是一个别名（eg: alias设置的别名），也有可能是一个&开头的name（解释如下）：
  // （1）别名name（eg: alias设置的别名），transformedBeanName(name)方法就是通过别名重定向出来真实beanName名称
  // （2）&开头的name，说明，你要获取的Bean实例对象，是一个FactoryBean对象。
  // FactoryBean：如果某个Bean的配置非常复杂，使用Spring管理不容易、不够灵活，想要使用编码的形式去构建它，
  // 那么你就可以提供一个构建该Bean实例的工厂，这个工厂就是FactoryBean接口实现类。FactoryBean接口实现类还是需要使用Spring管理的。
  // 这里就涉及到两种对象，一种是FactoryBean接口实现类（IOC管理的），另一个就是FactoryBean接口内部管理的对象。
  // 如果要拿FactoryBean接口实现类，使用getBean时传的beanName需要带“&”开头。
  // 如果你要FactoryBean内部管理的对象，你直接传beanName不需要带“&”开头。
  String beanName = transformedBeanName(name);
  // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
  // 根据transformedBeanName方法转换后的真实beanName，直接尝试从缓存中获取Bean的共享单实例（单例）：
  // 注：
  // 第一个getSingleton(String beanName)方法是一个参数的，
  // 后面还有一个重载的getSingleton方法（2个参数），2个不要搞混了！
  Object sharedInstance = getSingleton(beanName);
  // CASE1：
  // 如果缓存中有对应的数据，此时缓存数据可能是普通单实例，也可能是 FactoryBean，所以需要根据name来进行判断
  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 + "'");
      }
    }
    // 这里为什么又要套呢？为啥不直接拿回去用呢？
    // 其实，你从IOC中拿到的对象，它可能是普通单实例，也可能是FactoryBean实例。
    // 如果是FactoryBean实例，这个时候还要进行处理。主要是看name是带“&” 还是不带“&”,
    // 带“&”：则说明这次getBean方法想要拿FactoryBean对象。
    // 不带“&”：则说明是要拿FactoryBean内部管理的实例。
    /**
     * 获取给定Bean实例的对象，如果是FactoryBean类型，则可以是该实例本身或其创建的子Bean对象。
     * 方法参数:
     * sharedInstance: 缓存中拿到的单实例对象
     * name: 未处理“&”的name
     * beanName: 处理过“&”和别名后的name
     * mbd: 合并过后的bd(BeanDefinition)信息。
     */
    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
  }
  // CASE2：
  // 如果根据beanName从缓存中没有找到对应的数据，那么我们就需要自己创建了...
  else {
    // 一、原型循环依赖问题判定：创建Bean时，判断是否出现循环依赖的情况
    // 举个例子：
    // prototypeA -> B， B -> prototypeA
    // 1.会向正在创建中的原型集合内添加一个字符串 “A”
    // 2.创建prototypeA对象，只是一个早期对象。
    // 3.处理prototypeA的依赖，发现A依赖了B类型的对象
    // 4.触发了Spring.getBean(“B”)的操作。
    // 5.根据B的构造方法反射创建出来了B的早期实例
    // 6.Spring处理B对象的依赖，发现依赖了A。
    // 7.Spring转头回来再次去获取A去了。getBean(“A”).
    // 8.条件会返回true，最终抛出异常，算是结束了循环依赖注入。
    if (isPrototypeCurrentlyInCreation(beanName)) {
      throw new BeanCurrentlyInCreationException(beanName);
    }
    // Check if bean definition exists in this factory.
    // 如果beanDefinitionMap中也就是已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
    BeanFactory parentBeanFactory = getParentBeanFactory();
    if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
      // Not found -> check parent.
      String nameToLookup = originalBeanName(name);
      if (parentBeanFactory instanceof AbstractBeanFactory) {
        return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
            nameToLookup, requiredType, args, typeCheckOnly);
      }
      else if (args != null) {
        // Delegation to parent with explicit args.
        // 递归到BeanFactory中寻找
        return (T) parentBeanFactory.getBean(nameToLookup, args);
      }
      else if (requiredType != null) {
        // No args -> delegate to standard getBean method.
        return parentBeanFactory.getBean(nameToLookup, requiredType);
      }
      else {
        return (T) parentBeanFactory.getBean(nameToLookup);
      }
    }
    // 如果不仅仅是做类型检查则是创建Bean，这里要进行记录
    if (!typeCheckOnly) {
      markBeanAsCreated(beanName);
    }
    StartupStep beanCreation = this.applicationStartup.start("spring.beans.instantiate")
        .tag("beanName", name);
    try {
      if (requiredType != null) {
        beanCreation.tag("beanType", requiredType::toString);
      }
      // 二、获取合并BD信息
      // 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition，
      // 如果指定BeanName是子Bean的话同时会合并父类的相关属性
      // 为什么需要合并呀？因为BD支持继承
      // BD: 在XML配置文件中用 parent 属性可以定义父 <bean> 和子 <bean> ，父 <bean> 用 RootBeanDefinition表示
      RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
      // 判断当前BD是否为抽象BD，抽象BD不能创建实例，只能作为父BD让子BD去继承。
      checkMergedBeanDefinition(mbd, beanName, args);
      // 三、depends-on属性处理..
      // <bean name="A" depends-on="B" ... />
      // <bean name="B" .../>
      // 循环依赖问题
      // <bean name="A" depends-on="B" ... />
      // <bean name="B" depends-on="A" .../>
      // Spring是处理不了这种情况的，需要报错..
      // Spring需要发现这种情况的产生。
      // 怎么发现呢? 依靠两个Map，一个map是 dependentBeanMap 另一个是 dependenciesForBeanMap
      // 1. dependentBeanMap 记录依赖当前beanName的其他beanName
      // 2. dependenciesForBeanMap 记录当前beanName依赖的其它beanName集合
      String[] dependsOn = mbd.getDependsOn();
      // 若存在依赖则需要递归实例化依赖的bean
      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 name="A" depends-on="B" ... />
          // dep:B，beanName:A
          // 以B为视角 dependentBeanMap {"B"：{"A"}}
          // 以A为视角 dependenciesForBeanMap {"A" :{"B"}}
          // 缓存依赖调用
          registerDependentBean(dep, beanName);
          try {
            getBean(dep);
          }
          catch (NoSuchBeanDefinitionException ex) {
            throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
          }
        }
      }
      // CASE-SINGLETON：Create bean instance.
      // 创建单实例的逻辑
      // 实例化依赖的Bean后便可以实例化mbd本身了（singleton模式的创建）
      if (mbd.isSingleton()) {
        // 第二个getSingleton方法，这个方法更倾向于创建实例并返回：
        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.
            destroySingleton(beanName);
            throw ex;
          }
        });
        //这 里为啥不直接返回，还调用getObjectForBeanInstance(...)?
        // 这里为什么又要套呢？为啥不直接拿回去用呢？
        // 其实，你从IOC中拿到的对象，它可能是普通单实例，也可能是FactoryBean实例。
        // 如果是FactoryBean实例，这个时候还要进行处理。主要是看name是带“&” 还是 不带“&”,
        // 带“&”说明这次getBean想要拿FactoryBean对象。
        // 否则是要拿FactoryBean内部管理的实例。
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
      }
      // CASE-PROTOTYPE: 创建多实例
      else if (mbd.isPrototype()) {
        // It's a prototype -> create a new instance.
        // prototype原型模式的创建(new)
        Object prototypeInstance = null;
        try {
          // 记录当前线程相关的正在创建的原型对象beanName
          beforePrototypeCreation(beanName);
          // createBean方法创建对象
          prototypeInstance = createBean(beanName, mbd, args);
        }
        finally {
          // 从正在创建中的集合中移除beanName对应的Bean。
          afterPrototypeCreation(beanName);
        }
        beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
      }
      // CASE-OTHER: 这一情况笔记复杂，不做分析！
      else {
        // 指定的scope上实例化bean
        String scopeName = mbd.getScope();
        if (!StringUtils.hasLength(scopeName)) {
          throw new IllegalStateException("No scope name defined for bean ´" + beanName + "'");
        }
        Scope scope = this.scopes.get(scopeName);
        if (scope == null) {
          throw new IllegalStateException("No Scope registered for scope name '" + scopeName + "'");
        }
        try {
          Object scopedInstance = scope.get(beanName, () -> {
            beforePrototypeCreation(beanName);
            try {
              return createBean(beanName, mbd, args);
            }
            finally {
              afterPrototypeCreation(beanName);
            }
          });
          beanInstance = getObjectForBeanInstance(scopedInstance, name, beanName, mbd);
        }
        catch (IllegalStateException ex) {
          throw new ScopeNotActiveException(beanName, scopeName, ex);
        }
      }
    }
    catch (BeansException ex) {
      beanCreation.tag("exception", ex.getClass().toString());
      beanCreation.tag("message", String.valueOf(ex.getMessage()));
      cleanupAfterBeanCreationFailure(beanName);
      throw ex;
    }
    finally {
      beanCreation.end();
    }
  }
  return adaptBeanInstance(name, beanInstance, requiredType);
}

<!-- 
    方式一: 
  *alias* 属性设置别名, 使用alias设置别名，alias的 name 要和 bean 的 ID 相同, 可以设置多个别名!
-->
<bean id="addOne" class="...">
    <alias name="addOne" alias="add"/>
    <alias name="addOne" alias="doAdd"/>
</bean>
<!-- 
    方式二: 
  *name* 属性设置别名, 多个别名用逗号隔开!
-->
<bean id="addOne" class="..." name="add,doAdd"">
</bean>

getBean("&beanName");// 这种情况获取的就是一个 FactoryBean 对象

/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 根据传入的name参数,获取真正的Bean对应的beanName
  String beanName = transformedBeanName(name);
    // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
    ...
}

/**
 * Return the bean name, stripping out the factory dereference prefix if necessary,
 * and resolving aliases to canonical names.
 * (翻译：返回Bean的真实名称，必要时去除工厂引用前缀，并将别名解析为规范名称)
 *
 * 根据传入的name参数(该参数可能是别名，也可能是&开头的name),获取真正的Bean对应的beanName：
 *
 * @param name 获取Bean对象时，要传入的name参数(该参数可能是别名，也可能是&开头的name)
 * @return 返回转换后真正的Bean名称（beanName）
 */
protected String transformedBeanName(String name) {
  // 1.BeanFactoryUtils.transformedBeanName(name) 调用工厂工具类的转换方法：
  // 根据传入的name参数去获取转换后的name参数(去掉"&"符号)：eg -> name="&abc" 则转换后获得 name="abc"
  // 2.canonicalName方法 -> 根据Bean的别名name，获取真实的beanName:
  // BeanFactoryUtils.transformedBeanName(name)方法转换后的name是最终值么？
  // 不是！BeanFactoryUtils.transformedBeanName(name)方法仅仅是去掉name参数的"&"符号而已！
  // 转换后得到的name还有可能是alias属性指定的别名：
  // aliasMap保存别名信息：
  // {"C":"B", "B":"A"} A有一个别名叫做“B”，但是别名“B” 它又被别名了，它有一个别名叫做“C”
  // 假设调用getBean(name)方法时,name传的是“C”，那最终要得到什么? 要得到“A”(真正的beanName),而不是"B"!
  return canonicalName(BeanFactoryUtils.transformedBeanName(name));
}

/**
 * Return the actual bean name, stripping out the factory dereference
 * prefix (if any, also stripping repeated factory prefixes if found).
 * (翻译：返回实际的bean名称，删除工厂取消引用前缀（如果有的话，还删除重复的工厂前缀（如果找到））)
 * 
 * 根据传入的name参数去获取转换后的name参数(去掉"&"符号)：eg -> name="&abc" 则转换后获得 name="abc"
 * @param name 获取Bean对象时，要传入的name参数(该参数可能是别名，也可能是&开头的name)
 * @return 返回转换后真正的Bean名称（beanName）
 * @see BeanFactory#FACTORY_BEAN_PREFIX
 */
// 位于BeanFactoryUtils工具类中的方法
public static String transformedBeanName(String name) {
  Assert.notNull(name, "'name' must not be null");
  // 如果条件成立：说明调用getBean方法时传的参数name，不是“&”符号开头的，所以直接返回name即可
  if (!name.startsWith(BeanFactory.FACTORY_BEAN_PREFIX)) {
    return name;
  }
  // 执行到这里，说明name一定是“&”符号开头的，说明这次getBean方法就是要拿封装为Bean的FactoryBean实例对象（有点套娃的感觉）！
  // 调用transformedBeanNameCache方法将去掉“&”符号得到的结果缓存起来。提高后续程序运行性能的。
  // 科普一下：map.computeIfAbsent(key, value)方法
  // 当map中对应的key为null或者 key->value是null时，这次put操作就会成功，写成功也会返回value。
  // 否则就会失败，并且返回原有key->value。
  return transformedBeanNameCache.computeIfAbsent(name, beanName -> {
    do {
      // 假设 name="&abc" 则转换后获得 name="abc"（将其返回）
      beanName = beanName.substring(BeanFactory.FACTORY_BEAN_PREFIX.length());
    }
    while (beanName.startsWith(BeanFactory.FACTORY_BEAN_PREFIX));
    return beanName;
  });
}

/**
 * Determine the raw name, resolving aliases to canonical names.
 * (翻译：确定原始名称，将别名解析为规范名称。)
 *
 * 根据Bean的别名name，获取真实的beanName:
 * @param name 根据Bean的别名name
 * @return 返回真实的beanName
 */
// 位于SimpleAliasRegistry类中的方法：
public String canonicalName(String name) {
  String canonicalName = name;
  String resolvedName;
  do {
    // aliasName 和 beanName 的映射关系被注册到 SimpleAliasRegistry 中,
    // do-while循环从该注册器中根据 aliasName 取到 真实的 beanName：
    resolvedName = this.aliasMap.get(canonicalName);
    if (resolvedName != null) {
      canonicalName = resolvedName;
    }
  }
  while (resolvedName != null);
  return canonicalName;
}
/** Map from alias to canonical name. */
//  位于SimpleAliasRegistry类中的成员属性：存储 映射别名和真实beanName的集合
private final Map<String, String> aliasMap = new ConcurrentHashMap<>(16);

/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 根据传入的name参数,获取真正的Bean对应的beanName
  String beanName = transformedBeanName(name);
    // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
    // 根据transformedBeanName方法转换后的真实beanName，直接尝试从缓存中获取Bean的共享单实例（单例）：
    Object sharedInstance = getSingleton(beanName);
    ...
}

// Spring一级缓存：用来保存实例化、初始化都完成的对象
// Key：beanName
// Value: Bean实例
private final Map<String, Object> singletonObjects = new ConcurrentHashMap<>(256);
// Spring二级缓存：用来保存实例化完成，但是未初始化完成的对象
// Key：beanName
// Value: Bean实例
// 和一级缓存一样也是保存BeanName和创建bean实例之间的关系，
// 与singletonObjects不同之处在于，当一个单例bean被放在里面后，
// 那么bean还在创建过程中，就可以通过getBean方法获取到了，其目的是用来循环检测引用！（后面会分析）
private final Map<String, Object> earlySingletonObjects = new ConcurrentHashMap<>(16);
// Spring三级缓存：用来保存一个对象工厂，提供一个匿名内部类，用于创建二级缓存中的对象
// Key：beanName
// Value: Bean的工厂
private final Map<String, ObjectFactory<?>> singletonFactories = new HashMap<>(16);

// 用来保存当前所有已注册的Bean 
private final Set<String> registeredSingletons = new LinkedHashSet<>(256); 

/**
 * 根据真实beanName到缓存中获取Bean的共享单实例（单例）：
 *
 * @param beanName Bean的真实beanName
 * @return
 */
@Override
@Nullable
public Object getSingleton(String beanName) {
     // 第二个参数为true表示允许早期依赖
  return getSingleton(beanName, true);
}
/**
 * 根据真实beanName到缓存中获取Bean的共享单实例（单例）：
 *
 * @param beanName Bean的真实beanName
 * @param allowEarlyReference 是否应创建早期参考
 * @return 注册的单例对象；如果找不到，则返回null
 */
// 位于DefaultSingletonBeanRegistry类中
@Nullable
protected Object getSingleton(String beanName, boolean allowEarlyReference) {
  // 首先到一级缓存中尝试获取beanName对应的单实例Bean对象: 
  Object singletonObject = this.singletonObjects.get(beanName);
  // 如果条件一成立（singletonObject == null）：有几种可能呢？（2种）
  // 1.单实例确实尚未创建...
  // 2.单实例正在创建中，当前发生循环依赖了...
  // 条件一成立，条件二也会成立:
  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {
    // 尝试从二级缓存中获取beanName对应的单实例Bean对象:
    singletonObject = this.earlySingletonObjects.get(beanName);
    // 条件成立：说明二级缓存没有找到~
         // 再尝试从三级缓存中获取beanName对应的单实例Bean对象:
    if (singletonObject == null && allowEarlyReference) {
      // 如果缓存中不存在，锁住一级缓存singletonObjects
      synchronized (this.singletonObjects) {
        // 这里再次从一级缓存中去检索beanName，是为了防止此时有其他线程给一级缓存中添加了该Bean对象（导致加锁对象singletonObjects被修改）
        singletonObject = this.singletonObjects.get(beanName);
        // 这里singletonObject == null 依然成立，说明没有其他线程修改singletonObjects中的缓存数据，则继续向下走！
        if (singletonObject == null) {
          // 同理：从二级缓存中去检索beanName
          singletonObject = this.earlySingletonObjects.get(beanName);
          // 同理：这里singletonObject == null 依然成立，说明没有其他线程修改singletonObjects中的缓存数据，则继续向下走！
          if (singletonObject == null) {
            // 从三级缓存中检索beanName
            ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);
            // 如果条件成立：说明3级缓存中有beanName对应的数据，这里涉及到缓存升级~
            if (singletonFactory != null) {
              singletonObject = singletonFactory.getObject();
                                // 记录在缓存中，earlySingletonObjects和singletonFactories互斥!
              // 向2级缓存中存入该数据
              this.earlySingletonObjects.put(beanName, singletonObject);
              // 将3级缓存的该数据干掉
              this.singletonFactories.remove(beanName);
            }
          }
        }
      }
    }
  }
  return singletonObject;
}

/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 根据传入的name参数,获取真正的Bean对应的beanName
  String beanName = transformedBeanName(name);
    // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
    // 根据transformedBeanName方法转换后的真实beanName，直接尝试从缓存中获取Bean的共享单实例（单例）：
    Object sharedInstance = getSingleton(beanName);
    // CASE1：
    // 如果缓存中有对应的数据，此时缓存数据可能是普通单实例，也可能是 FactoryBean（需要根据name来进行判断）
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            ... // 这里的代码只是打印日志，就不再加了
        }
        // 获取sharedInstance对应的Bean实例化对象，如果是FactoryBean类型，则可以是该实例本身或其创建的子Bean对象。
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    ...
}

/**
 * Get the object for the given bean instance, either the bean
 * instance itself or its created object in case of a FactoryBean.
 * (翻译：获取给定Bean实例的对象，如果是FactoryBean类型，则可以是该实例本身或其创建的子Bean对象)
 *
 * 获取给定Bean实例的对象，如果是FactoryBean类型，则可以获取该实例本身或其创建的子Bean对象。
 * @param beanInstance 缓存中拿到的单实例对象(初始化状态，尚未实例化)
 * @param name 未处转换处理过的name（可能带有&工厂符号）
 * @param beanName 经过转换处理过的真实beanName
 * @param mbd 合并过后的bd(BeanDefinition)对象
 * @return the object to expose for the bean
 */
protected Object getObjectForBeanInstance(
    Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd) {
  // 如果条件成立：说明当前要获取FactoryBean对象，即name中带有&符号：
  if (BeanFactoryUtils.isFactoryDereference(name)) {
    // 如果beanInstance是null，则直接返回
    if (beanInstance instanceof NullBean) {
      // 直接返回
      return beanInstance;
    }
    // 如果条件成立：说明单实例对象不是 FactoryBean接口实现类，则验证不通过，直接抛异常！
         // (指定的name是工厂相关且beanInstance不是FactoryBean类型，则验证不通过)
    if (!(beanInstance instanceof FactoryBean)) {
      throw new BeanIsNotAFactoryException(beanName, beanInstance.getClass());
    }
    // 给当前Bean实例对应的mbd打个标记，记录它表达的实例是一个FactoryBean.
    if (mbd != null) {
      mbd.isFactoryBean = true;
    }
    return beanInstance;
  }
  // 执行到这里，有几种情况呢？（2种）
  // 情况1.当前Bean实例就是普通单实例
  // 情况2.当前Bean实例是FactoryBean接口实现类，但是本次请求要拿的是FactoryBean实现类内部管理的实例。
     // 如果用户想要直接获取工厂实例而不是工厂的getObject方法对应的实例，那么传入的name应该加入&
  // 1.当前bean实例就是普通单实例
  if (!(beanInstance instanceof FactoryBean)) {
    // 直接返回该单实例
    return beanInstance;
  }
  // 2.当前Bean实例是FactoryBean接口实现类，但是本次请求要拿的是FactoryBean实现类内部管理的实例。
  // 用于保存FactoryBean实例调用getObject方法后得到的返回值.
  Object object = null;
  if (mbd != null) {
    mbd.isFactoryBean = true;
  }
  else {
    // 尝试从缓存中加载Bean，如果缓存中已经存在 beanName 对应的工厂 Bean 生成的对象,则直接返回
    // (即，尝试到缓存获取FactoryBean.getObject返回值)
    object = getCachedObjectForFactoryBean(beanName);
  }
     // 加载FactoryBean
  // 如果条件成立：说明缓存中没有，就需要到FactoryBean.getObject获取
  if (object == null) {
    // 到这里已经明确知道beanInstance一定是FactoryBean类型
    FactoryBean<?> factory = (FactoryBean<?>) beanInstance;
    // 判断Spring中是否有当前beanName对应的BD信息：
    // containsBeanDefinition检测beanDefinitionMap中也就是在所有已经加载的类中检测是否定义beanName
    if (mbd == null && containsBeanDefinition(beanName)) {
      // 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition，
      // 如果指定BeanName是子Bean的话同时会合并父类的相关属性
      // 为什么是合并后的呢？因为咱们的BD是直接继承的。合并后的BD信息是包含继承回来的BD。
      mbd = getMergedLocalBeanDefinition(beanName);
    }
    // 是否是用户定义的而不是应用程序本身定义的：
    // synthetic 默认值是false 表示这是一个用户对象，如果是true 表示是系统对象。
    boolean synthetic = (mbd != null && mbd.isSynthetic());
    /**
     * getObjectFromFactoryBean是本方法的核心，从给定的FactoryBean中获取一个Bean对象:
     *
     * factory：FactoryBean实例
     * beanName：FactoryBean实例中的Bean对应的beanName
     * synthetic：如果是用户对象，这个值就是true，大部分情况下都是true。
     */
    object = getObjectFromFactoryBean(factory, beanName, !synthetic);
  }
  return object;
}

/**
 * 从给定的FactoryBean中获取一个Bean对象:
 * @param factory FactoryBean实例
 * @param beanName FactoryBean实例中的Bean对应的beanName
 * @param shouldPostProcess 如果是用户对象，这个值就是true，大部分情况下都是true。
 * @return 返回从FactoryBean获得的Bean对象
 * @throws BeanCreationException if FactoryBean object creation failed
 * @see org.springframework.beans.factory.FactoryBean#getObject()
 */
// 位于FactoryBeanRegistrySupport中的方法：
protected Object getObjectFromFactoryBean(FactoryBean<?> factory, String beanName, boolean shouldPostProcess) {
  // 如果条件成立：说明factory是单例的同时,factory还得已经被实例化
  if (factory.isSingleton() && containsSingleton(beanName)) {
    synchronized (getSingletonMutex()) {
      // 再次尝试从缓存中获取bean
      Object object = this.factoryBeanObjectCache.get(beanName);
      if (object == null) {
        // 委托doGetObjectFromFactoryBean方法产生Bean
        object = doGetObjectFromFactoryBean(factory, beanName);
        // 再次判断缓存中是存在beanName对应的Bean
        Object alreadyThere = this.factoryBeanObjectCache.get(beanName);
        if (alreadyThere != null) {
          object = alreadyThere;
        }
        else {
          if (shouldPostProcess) {
            if (isSingletonCurrentlyInCreation(beanName)) {
              // Temporarily return non-post-processed object, not storing it yet..
              return object;
            }
            beforeSingletonCreation(beanName);
            try {
              // 调用ObjectFactory的后处理器
              object = postProcessObjectFromFactoryBean(object, beanName);
            }
            catch (Throwable ex) {
              throw new BeanCreationException(beanName,
                  "Post-processing of FactoryBean's singleton object failed", ex);
            }
            finally {
              afterSingletonCreation(beanName);
            }
          }
          // 单例模式下：已经加载的bean要记录下来，便于下次复用
          if (containsSingleton(beanName)) {
            this.factoryBeanObjectCache.put(beanName, object);
          }
        }
      }
      return object;
    }
  }
  else {
    Object object = doGetObjectFromFactoryBean(factory, beanName);
    if (shouldPostProcess) {
      try {
        object = postProcessObjectFromFactoryBean(object, beanName);
      }
      catch (Throwable ex) {
        throw new BeanCreationException(beanName, "Post-processing of FactoryBean's object failed", ex);
      }
    }
    return object;
  }
}

/**
 * 真正从FactoryBean中获取一个Bean实例的方法
 * @param factory FactoryBean实例
 * @param beanName FactoryBean实例中的Bean对应的beanName
 * @return 返回从FactoryBean获得的Bean对象
 * @throws BeanCreationException if FactoryBean object creation failed
 * @see org.springframework.beans.factory.FactoryBean#getObject()
 */
private Object doGetObjectFromFactoryBean(FactoryBean<?> factory, String beanName) throws BeanCreationException {
    // 作为要返回的结果
    Object object;
  try {
         // 需要权限认证(略)
    if (System.getSecurityManager() != null) {
      ...
    }
    else {
              //  factory.getObject()方法获取bean 
      object = factory.getObject();
    }
  }
  catch (FactoryBeanNotInitializedException ex) {// 略}
  catch (Throwable ex) {// 略}
  if (object == null) {
    if (isSingletonCurrentlyInCreation(beanName)) {
      ...
    }
    object = new NullBean();
  }
  return object;
}

/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 1.根据传入的name参数,获取真正的Bean对应的beanName
  String beanName = transformedBeanName(name);
    // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
    // 2.根据transformedBeanName方法转换后的真实beanName，直接尝试从缓存中获取Bean的共享单实例（单例）：
    Object sharedInstance = getSingleton(beanName);
    // CASE1：
    // 如果缓存中有对应的数据，此时缓存数据可能是普通单实例，也可能是 FactoryBean（需要根据name来进行判断）
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            ... // 这里的代码只是打印日志，就不再加了
        }
        // 3.Bean的实例化
        // 获取sharedInstance对应的Bean实例化对象，如果是FactoryBean类型，则可以是该实例本身或其创建的子Bean对象。
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    // CASE2：
    // 如果根据beanName从缓存中没有找到对应的数据 (那么我们就需要自己创建了...)
    else {
        // 4.原型模式(prototype)的依赖检查: Spring只能给解决单例模式下的循环依赖问题，
        // 如果原型模式(prototype)出现循环依赖，则直接抛异常~
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        // 5.检测parentBeanFactory
        // 如果beanDefinitionMap中也就是已经加载的类中不包括beanName，则尝试从parentBeanFactory中检测
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
           ...
        }
        ...
    }                                             
}

// 3.原型模式(prototype)的依赖检查: Spring只能给解决单例模式下的循环依赖问题，
// 如果原型模式(prototype)出现循环依赖，则直接抛异常~
if (isPrototypeCurrentlyInCreation(beanName)) {
    throw new BeanCurrentlyInCreationException(beanName);
}

@Override
@Nullable
public BeanFactory getParentBeanFactory() {
  return this.parentBeanFactory;
}
/** Parent bean factory, for bean inheritance support. */
// 父Bean工厂，用于支持Bean的继承
@Nullable
private BeanFactory parentBeanFactory;

// 如果条件成立，说明：父工厂不为空，且当前BeanDefinitionMap中无法获取beanName对应的Bean对象
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
    // 那么就只能到父工程parentBeanFactory中尝试去获取Bean了
    // parentBeanFactory.doGetBean() 相当于递归调用~
    ...
}

// 如果beanDefinitionMap中也就是已经加载的类中不包括beanName则尝试从parentBeanFactory中检测
BeanFactory parentBeanFactory = getParentBeanFactory();
if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
  // Not found -> check parent.
  String nameToLookup = originalBeanName(name);
  if (parentBeanFactory instanceof AbstractBeanFactory) {
    return ((AbstractBeanFactory) parentBeanFactory).doGetBean(
        nameToLookup, requiredType, args, typeCheckOnly);
  }
  else if (args != null) {
    // Delegation to parent with explicit args.
    // 递归到BeanFactory中寻找
    return (T) parentBeanFactory.getBean(nameToLookup, args);
  }
  else if (requiredType != null) {
    // No args -> delegate to standard getBean method.
    return parentBeanFactory.getBean(nameToLookup, requiredType);
  }
  else {
    return (T) parentBeanFactory.getBean(nameToLookup);
  }
}

/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 1.根据传入的name参数,获取真正的Bean对应的beanName
  String beanName = transformedBeanName(name);
    // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
    // 2.根据transformedBeanName方法转换后的真实beanName，直接尝试从缓存中获取Bean的共享单实例（单例）：
    Object sharedInstance = getSingleton(beanName);
    // CASE1：
    // 如果缓存中有对应的数据，此时缓存数据可能是普通单实例，也可能是 FactoryBean（需要根据name来进行判断）
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            ... // 这里的代码只是打印日志，就不再加了
        }
        // 3.Bean的实例化
        // 获取sharedInstance对应的Bean实例化对象，如果是FactoryBean类型，则可以是该实例本身或其创建的子Bean对象。
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    // CASE2：
    // 如果根据beanName从缓存中没有找到对应的数据 (那么我们就需要自己创建了...)
    else {
        // 4.原型模式(prototype)的依赖检查: Spring只能给解决单例模式下的循环依赖问题，
        // 如果原型模式(prototype)出现循环依赖，则直接抛异常~
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        // 5.检测parentBeanFactory
        // 如果beanDefinitionMap中也就是已经加载的类中不包括beanName，则尝试从parentBeanFactory中检测
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
           ...
        }
        // 如果从缓存中获取不到, 同时当前的 beanDefinitionMap 中存在对应 beanName 的配置，
        // 我们就可以依据包含有XML配置文件信息的 beanDefinition 进行创建 bean 了。
        try {
            ...
            // 6.GenericBeanDefinition转为RootBeanDefinition:
            // 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition，
            // 如果指定BeanName是子Bean的话同时会合并父类的相关属性    
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 判断当前BD是否为抽象BD，抽象BD不能创建实例，只能作为父BD让子BD去继承。
            checkMergedBeanDefinition(mbd, beanName, args);
            // 7.寻找依赖
            String[] dependsOn = mbd.getDependsOn();
            // 若存在依赖则需要递归实例化依赖的bean
            if (dependsOn != null) {
                ...
            }
            ...
        catch (BeansException ex) {
            ...
        }
        finally {
            beanCreation.end();
        }
    }                                             
}

// 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition，
// 如果指定BeanName是子Bean的话同时会合并父类的相关属性
RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
// 判断当前BD是否为抽象BD，抽象BD不能创建实例，只能作为父BD让子BD去继承。
checkMergedBeanDefinition(mbd, beanName, args);

// 7.寻找依赖
// eg: <bean name="A" depends-on="B" ... />
String[] dependsOn = mbd.getDependsOn();
// 若存在依赖则需要递归实例化依赖的Bean
if (dependsOn != null) {
   for (String dep : dependsOn) {
      // 判断循环依赖:\
      // <bean name="A" depends-on="B" ... />
   // <bean name="B" depends-on="A" .../>
      // Spring是处理不了这种情况的，需要抛异常...
      if (isDependent(beanName, dep)) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
      }
      // 缓存依赖调用
      registerDependentBean(dep, beanName);
      try {
         getBean(dep);
      }
      catch (NoSuchBeanDefinitionException ex) {
         throw new BeanCreationException(mbd.getResourceDescription(), beanName,
               "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
      }
   }
}

// 8.根据不同的scope作用域创建Bean
// CASE-SINGLETON：创建单实例Bean的逻辑（singleton模式的创建）
if (mbd.isSingleton()) {
    // 第二个getSingleton方法，获取单例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 ther
            // eagerly by the creation process, to allow for circular reference resolution.
            // Also remove any beans that received a temporary reference to the bean.
            destroySingleton(beanName);
            throw ex;
        }
    });
    //这 里为啥不直接返回，还调用getObjectForBeanInstance(...)?
    // 这里为什么又要套呢？为啥不直接拿回去用呢？
    // 其实，你从IOC中拿到的对象，它可能是普通单实例，也可能是FactoryBean实例。
    // 如果是FactoryBean实例，这个时候还要进行处理。主要是看name是带“&” 还是 不带“&”,
    // 带“&”说明这次getBean想要拿FactoryBean对象。
    // 否则是要拿FactoryBean内部管理的实例。
    beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
}
// CASE-PROTOTYPE: 创建多实例Bean的逻辑（prototype模式的创建）
else if (mbd.isPrototype()) {
   // prototype原型模式的创建(new)
   .....
}
// CASE-OTHER：其他scope作用域创建Bean的逻辑，例如request、session、global session
else {
   // 指定的scope上实例化bean
   .....
}

/**
 * 缓存中没有需要新创建单例初始状态的bean
 * @param beanName Bean对象对应的beanName
 * @param singletonFactory Bean工厂
 * @return the registered singleton object
 */
public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
   Assert.notNull(beanName, "Bean name must not be null");
   // 全局变量需要同步
   synchronized (this.singletonObjects) {
      // 首先检查对应的bean是否已经加载过，因为是单例模式的，如果有直接返回
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
         // 单例bean的初始化
         if (this.singletonsCurrentlyInDestruction) {
            ... // 抛异常
         }
         if (logger.isDebugEnabled()) {
            ... // 日志打印
         }
         // 记录加载状态，通过this.singletonsCurrentlyInCreation.add(beanName)将当前正要创建的bean记录在缓存中，
         // 便于对循环依赖进行检测
         beforeSingletonCreation(beanName);
         // 创建单例bean是否成功的标识
         boolean newSingleton = false;
         boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
         if (recordSuppressedExceptions) {
            this.suppressedExceptions = new LinkedHashSet<>();
         }
         try {
            // 初始化Bean
            singletonObject = singletonFactory.getObject();
            newSingleton = true;
         }
         catch (IllegalStateException ex) {
            // Has the singleton object implicitly appeared in the meantime ->
            // if yes, proceed with it since the exception indicates that state.
            singletonObject = this.singletonObjects.get(beanName);
            if (singletonObject == null) {
               throw ex;
            }
         }
         catch (BeanCreationException ex) {
            ... // 捕获异常
         }
         finally {
            if (recordSuppressedExceptions) {
               this.suppressedExceptions = null;
            }
            // 创建完Bean之后需要移除缓存中对该Bean正在加载状态的记录
            afterSingletonCreation(beanName);
         }
         // 加入缓存并删除加载Bean过程中所记录的各种辅助状态
         if (newSingleton) {
            addSingleton(beanName, singletonObject);
         }
      }
      // 返回处理结果
      return singletonObject;
   }
}

/**
 * 添加缓存并移除辅助变量
 * @param beanName the name of the bean
 * @param singletonObject the singleton object
 */
protected void addSingleton(String beanName, Object singletonObject) {
    synchronized (this.singletonObjects) {
        // 加入缓存
        this.singletonObjects.put(beanName, singletonObject);
        this.singletonFactories.remove(beanName);
        this.earlySingletonObjects.remove(beanName);
        this.registeredSingletons.add(beanName);
    }
}

/**
 * 创建单例Bean的核心方法：(其实是准备创建Bean之前需要做的一些工作)
 * @see #doCreateBean
 */
@Override
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
   // mbdToUse: 创建实例时使用mbd
   // 在XML配置文件中用 parent 属性可以定义父 <bean> 和子 <bean> ，父 <bean> 用 RootBeanDefinition表示
   RootBeanDefinition mbdToUse = mbd;
   // 锁定class，根据设置的class属性或者根据className来解析Class
   Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
   // 当解析出class同时mbd中beanClass属性设置为字符串对象而不是Class对象时，需要对mbd进行更新为Class类型：
   // 条件一 resolvedClass != null：说明拿到了mbd实例化对象时的真实Class对象。
   // 条件二 !mbd.hasBeanClass()：条件成立，说明mbd在resolveBeanClass之前，是没有Class对象的。
   // 条件三 bd.getBeanClassName()!= null：成立，说明mbd有ClassName 
   if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
   }
   // 验证override及准备覆盖的方法（预处理...直接跳过，不作为重点）
   try {
      mbdToUse.prepareMethodOverrides();
   }
   catch (BeanDefinitionValidationException ex) {
      ... // 异常抛出
   }
   try {
      // 对BeanDefinition中的属性做些前置处理，给BeanPostProcessors一个机会来返回代理来替代真正的实例
      // 注意，这里的代理对象不是Spring AOP逻辑实现的地方。！
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      // 如果前置处理返回的不为空，则直接返回（AOP功能就是这里判断的），否则需要进行常规bean的创建
      // bean != null：条件成立会形成一个短路操作，这里直接返回了.
      if (bean != null) {
         return bean;
      }
   }
   catch (Throwable ex) {
      ... // 异常抛出
   }
   try {
      // 核心方法（真正创建Bean的方法）：创建Bean实例对象，并且生命周期的动作大部分都在这里 
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isDebugEnabled()) {
         ... // 日志打印
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
      ... // 异常处理
   }
   catch (Throwable ex) {
      ... // 异常处理
   }
}

/**
 * 真正去获取Bean对象的方法：
 * @param name Bean对象的名称 -> 根据name参数获取对应的Bean对象
 * @param requiredType 检索所需的Bean类型
 * @param args 使用显式参数创建bean实例时要使用的参数（仅在创建新实例而不是检索现有实例时才应用）
 * @param typeCheckOnly 是否获取实例用于类型检查而不是实际使用
 * @return 返回Bean的一个实例
 * @throws BeansException if the bean could not be created
 */
protected <T> T doGetBean(
    String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
    throws BeansException {
    // 1.根据传入的name参数,获取真正的Bean对应的beanName
  String beanName = transformedBeanName(name);
    // 用于保留返回值（要返回的Bean实例对象）
  Object beanInstance;
    // 2.根据transformedBeanName方法转换后的真实beanName，直接尝试从缓存中获取Bean的共享单实例（单例）：
    Object sharedInstance = getSingleton(beanName);
    // CASE1：
    // 如果缓存中有对应的数据，此时缓存数据可能是普通单实例，也可能是 FactoryBean（需要根据name来进行判断）
    if (sharedInstance != null && args == null) {
        if (logger.isTraceEnabled()) {
            ... // 这里的代码只是打印日志，就不再加了
        }
        // 3.Bean的实例化
        // 获取sharedInstance对应的Bean实例化对象，如果是FactoryBean类型，则可以是该实例本身或其创建的子Bean对象。
        beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }
    // CASE2：
    // 如果根据beanName从缓存中没有找到对应的数据 (那么我们就需要自己创建了...)
    else {
        // 4.原型模式(prototype)的依赖检查: Spring只能给解决单例模式下的循环依赖问题，
        // 如果原型模式(prototype)出现循环依赖，则直接抛异常~
        if (isPrototypeCurrentlyInCreation(beanName)) {
            throw new BeanCurrentlyInCreationException(beanName);
        }
        // 5.检测parentBeanFactory
        // 如果beanDefinitionMap中也就是已经加载的类中不包括beanName，则尝试从parentBeanFactory中检测
        BeanFactory parentBeanFactory = getParentBeanFactory();
        if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
           ...
        }
        // 如果从缓存中获取不到, 同时当前的 beanDefinitionMap 中存在对应 beanName 的配置，
        // 我们就可以依据包含有XML配置文件信息的 beanDefinition 进行创建 bean 了。
        try {
            ...
            // 6.GenericBeanDefinition转为RootBeanDefinition:
            // 将存储XML配置文件的GenericBeanDefinition转换为RootBeanDefinition，
            // 如果指定BeanName是子Bean的话同时会合并父类的相关属性    
            RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
            // 判断当前BD是否为抽象BD，抽象BD不能创建实例，只能作为父BD让子BD去继承。
            checkMergedBeanDefinition(mbd, beanName, args);
            // 7.寻找依赖
            String[] dependsOn = mbd.getDependsOn();
            // 若存在依赖则需要递归实例化依赖的bean
            if (dependsOn != null) {
                ...
            }
            // 8.根据不同的scope作用域创建Bean
            // CASE-SINGLETON：创建单实例Bean的逻辑（singleton模式的创建）
            if (mbd.isSingleton()) {
                ...
            }
            // CASE-PROTOTYPE: 创建多实例Bean的逻辑（prototype模式的创建）
            else if (mbd.isPrototype()) {
               // prototype原型模式的创建(new)
               .....
            }
            // CASE-OTHER：其他scope作用域创建Bean的逻辑，例如request、session、global session
            else {
               // 指定的scope上实例化bean
               .....
            }
        catch (BeansException ex) {
            ...
        }
        finally {
            beanCreation.end();
        }
        // 9.对最终得到的Bean实例进行类型转换
        return adaptBeanInstance(name, beanInstance, requiredType);
    }                                             
}

@SuppressWarnings("unchecked")
<T> T adaptBeanInstance(String name, Object bean, @Nullable Class<?> requiredType) {
  // 检查需要的类型是否符合Bean的实际类型
  if (requiredType != null && !requiredType.isInstance(bean)) {
    try {
             // 类型转换：
      Object convertedBean = getTypeConverter().convertIfNecessary(bean, requiredType);
      if (convertedBean == null) {
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
      return (T) convertedBean;
    }
    catch (TypeMismatchException ex) {
      if (logger.isTraceEnabled()) {
        logger.trace("Failed to convert bean '" + name + "' to required type '" +
            ClassUtils.getQualifiedName(requiredType) + "'", ex);
      }
      throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
    }
  }
  return (T) bean;
}