public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {
    Assert.notNull(beanName, "Bean name must not be null");
    synchronized (this.singletonObjects) {
      //尝试从一级缓存中获取
      Object singletonObject = this.singletonObjects.get(beanName);
      if (singletonObject == null) {
        if (this.singletonsCurrentlyInDestruction) {
          throw new BeanCreationNotAllowedException(beanName,
              "Singleton bean creation not allowed while singletons of this factory are in destruction " +
              "(Do not request a bean from a BeanFactory in a destroy method implementation!)");
        }
        if (logger.isDebugEnabled()) {
          logger.debug("Creating shared instance of singleton bean '" + beanName + "'");
        }
        //添加到singletonsCurrentlyInCreation缓存中
        beforeSingletonCreation(beanName);
        boolean newSingleton = false;
        boolean recordSuppressedExceptions = (this.suppressedExceptions == null);
        if (recordSuppressedExceptions) {
          this.suppressedExceptions = new LinkedHashSet<>();
        }
        try {
          //调用ObjectFactory对象的getObject方法返回实例，getObject方法的实现就是传参时的匿名内部类
          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) {
          if (recordSuppressedExceptions) {
            for (Exception suppressedException : this.suppressedExceptions) {
              ex.addRelatedCause(suppressedException);
            }
          }
          throw ex;
        }
        finally {
          if (recordSuppressedExceptions) {
            this.suppressedExceptions = null;
          }
          //从singletonsCurrentlyInCreation缓存中移除
          afterSingletonCreation(beanName);
        }
        //添加到一级缓存中，移除二级缓存、三级缓存
        if (newSingleton) {
          addSingleton(beanName, singletonObject);
        }
      }
      return singletonObject;
    }
  }

          sharedInstance = getSingleton(beanName, () -> {
            try {
              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;
            }
          });

  public void prepareMethodOverrides() throws BeanDefinitionValidationException {
    // Check that lookup methods exist and determine their overloaded status.
    //判断当前Bean定义信息中是否有methodOverrides标识
    if (hasMethodOverrides()) {
      //遍历校验当前bean中是否存在该方法
      getMethodOverrides().getOverrides().forEach(this::prepareMethodOverride);
    }
  }
  /**
   * Validate and prepare the given method override.
   * Checks for existence of a method with the specified name,
   * marking it as not overloaded if none found.
   * @param mo the MethodOverride object to validate
   * @throws BeanDefinitionValidationException in case of validation failure
   */
  protected void prepareMethodOverride(MethodOverride mo) throws BeanDefinitionValidationException {
    //查询校验是否存在override属性值对应的方法
    int count = ClassUtils.getMethodCountForName(getBeanClass(), mo.getMethodName());
    if (count == 0) {
      throw new BeanDefinitionValidationException(
          "Invalid method override: no method with name '" + mo.getMethodName() +
          "' on class [" + getBeanClassName() + "]");
    }
    else if (count == 1) {
      // Mark override as not overloaded, to avoid the overhead of arg type checking.
      mo.setOverloaded(false);
    }
  }

  protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd) {
    Object bean = null;
    //默认该属性为false
    if (!Boolean.FALSE.equals(mbd.beforeInstantiationResolved)) {
      // Make sure bean class is actually resolved at this point.
      //不是合成的，并且BeanFactory中存在InstantiationAwareBeanPostProcessor
      if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
        //获取beanName对应的class对象
        Class<?> targetType = determineTargetType(beanName, mbd);
        if (targetType != null) {
          //执行InstantiationAwareBeanPostProcessor类型的postProcessBeforeInstantiation方法，并返回实例
          bean = applyBeanPostProcessorsBeforeInstantiation(targetType, beanName);
          if (bean != null) {
            //执行所有BeanPostProcessor后置处理器的postProcessAfterInitialization
            bean = applyBeanPostProcessorsAfterInitialization(bean, beanName);
          }
        }
      }
      mbd.beforeInstantiationResolved = (bean != null);
    }
    return bean;
  }

protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName) {
    //遍历执行InstantiationAwareBeanPostProcessor类型对象的postProcessBeforeInstantiation方法
    for (BeanPostProcessor bp : getBeanPostProcessors()) {
      if (bp instanceof InstantiationAwareBeanPostProcessor) {
        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;
        Object result = ibp.postProcessBeforeInstantiation(beanClass, beanName);
        if (result != null) {
          return result;
        }
      }
    }
    return null;
  }

  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final @Nullable Object[] args)
      throws BeanCreationException {
    // Instantiate the bean.
    BeanWrapper instanceWrapper = null;
    if (mbd.isSingleton()) {
    //如果是单例并且是FactoryBean则尝试移除
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
    if (instanceWrapper == null) {
      //创建Bean实例，通过策略进行创建，如果选择有参构造或无参构造
      instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    //获取当前实例对象
    final Object bean = instanceWrapper.getWrappedInstance();
    //当前实例的Calss对象
    Class<?> beanType = instanceWrapper.getWrappedClass();
    if (beanType != NullBean.class) {
      //设置当前bean定义信息的目标类型
      mbd.resolvedTargetType = beanType;
    }
    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
        try {
          //执行MergedBeanDefinitionPostProcessor类型后置处理器的postProcessMergedBeanDefinition方法，
          //如@Autowire注解，就是通过该后置处理器进行解析
          applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
        }
        catch (Throwable ex) {
          throw new BeanCreationException(mbd.getResourceDescription(), beanName,
              "Post-processing of merged bean definition failed", ex);
        }
        mbd.postProcessed = true;
      }
    }
    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
    //如果是单例，允许循环依赖，并且beanName正在创建中
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
      if (logger.isTraceEnabled()) {
        logger.trace("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
      }
      //包装成FactoryObject对象，并添加到三级缓存中
      addSingletonFactory(beanName, () -> getEarlyBeanReference(beanName, mbd, bean));
    }
    // Initialize the bean instance.
    Object exposedObject = bean;
    try {
      //初始化过程，进行属性注入。该过程递归创建其依赖的属性。如果A中有B，B中有C，则创建B跟C。
      populateBean(beanName, mbd, instanceWrapper);
      //该过程执行后置处理器的before方法，bean的init方法，后置处理器的after方法，可能会生成新的bean对象
      exposedObject = initializeBean(beanName, exposedObject, mbd);
    }
    catch (Throwable ex) {
      if (ex instanceof BeanCreationException && beanName.equals(((BeanCreationException) ex).getBeanName())) {
        throw (BeanCreationException) ex;
      }
      else {
        throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Initialization of bean failed", ex);
      }
    }
    if (earlySingletonExposure) {
      //从缓存中获取，因为上面我们将其添加到三级缓存中，从三级缓存中获取会调用FactoryObject对象的getObject方法，可能会触发AOP代理。返回代理对象
      Object earlySingletonReference = getSingleton(beanName, false);
      if (earlySingletonReference != null) {
        //如果bean对象还是原来的，则将三级缓存中获取的对象赋值过去
        if (exposedObject == bean) {
          exposedObject = earlySingletonReference;
        }
        //如果exposedObject在initializeBean方法中被增强 && 不允许在循环引用的情况下使用注入原始bean实例
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
          //  获取依赖当前beanName的所有bean名称
          String[] dependentBeans = getDependentBeans(beanName);
          Set<String> actualDependentBeans = new LinkedHashSet<>(dependentBeans.length);
          //尝试移除这些bean的实例，因为这些bean依赖的bean已经被增强了，他们依赖的bean相当于脏数据
          for (String dependentBean : dependentBeans) {
            if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
              actualDependentBeans.add(dependentBean);
            }
          }
          if (!actualDependentBeans.isEmpty()) {
            throw new BeanCurrentlyInCreationException(beanName,
                "Bean with name '" + beanName + "' has been injected into other beans [" +
                StringUtils.collectionToCommaDelimitedString(actualDependentBeans) +
                "] in its raw version as part of a circular reference, but has eventually been " +
                "wrapped. This means that said other beans do not use the final version of the " +
                "bean. This is often the result of over-eager type matching - consider using " +
                "'getBeanNamesOfType' with the 'allowEagerInit' flag turned off, for example.");
          }
        }
      }
    }
    // Register bean as disposable.
    try {
      //注册用于销毁的bean，执行销毁操作的有三种：自定义destroy方法、DisposableBean接口、DestructionAwareBeanPostProcessor
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }
    return exposedObject;
  }

  protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
    // Make sure bean class is actually resolved at this point.
    //解析class信息
    Class<?> beanClass = resolveBeanClass(mbd, beanName);
    //判断 beanClass不为空 && beanClass不是public修饰 && 该bean不允许访问非公共构造函数和方法，则抛异常
    if (beanClass != null && !Modifier.isPublic(beanClass.getModifiers()) && !mbd.isNonPublicAccessAllowed()) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName,
          "Bean class isn't public, and non-public access not allowed: " + beanClass.getName());
    }
    //使用Supplier的方式直接创建bean
    Supplier<?> instanceSupplier = mbd.getInstanceSupplier();
    if (instanceSupplier != null) {
      return obtainFromSupplier(instanceSupplier, beanName);
    }
    //使用工厂方法实例化bean对象
    if (mbd.getFactoryMethodName() != null) {
      return instantiateUsingFactoryMethod(beanName, mbd, args);
    }
    // Shortcut when re-creating the same bean...
    //标识是否解析
    boolean resolved = false;
    boolean autowireNecessary = false;
    if (args == null) {
      synchronized (mbd.constructorArgumentLock) {
        //判断构造函数或者工厂方法缓存中是否有值
        if (mbd.resolvedConstructorOrFactoryMethod != null) {
          resolved = true;
          //构造函数解析标识
          autowireNecessary = mbd.constructorArgumentsResolved;
        }
      }
    }
    if (resolved) {
      if (autowireNecessary) {
        //使用有参构造函数创建实例
        return autowireConstructor(beanName, mbd, null, null);
      }
      else {
        //使用无参构造函数创建实例
        return instantiateBean(beanName, mbd);
      }
    }
    // Candidate constructors for autowiring?
    //调用SmartInstantiationAwareBeanPostProcessor类型的determineCandidateConstructors方法，返回构造函数
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    //解析的构造器不为空 || 注入类型为构造函数自动注入 || bean定义中有构造器参数 || 传入参数不为空
    if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
    }
    // Preferred constructors for default construction?
    //获取默认构造器
    ctors = mbd.getPreferredConstructors();
    if (ctors != null) {
      return autowireConstructor(beanName, mbd, ctors, null);
    }
    // No special handling: simply use no-arg constructor.
    //使用无参构造方法
    return instantiateBean(beanName, mbd);
  }

  protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName) {
    Object instance;
    //获取当前正在创建的BeanName
    String outerBean = this.currentlyCreatedBean.get();
    //设置当前beanName到当前线程中
    this.currentlyCreatedBean.set(beanName);
    try {
      //调用Supplier的get自定义方法，创建实例对象
      instance = instanceSupplier.get();
    }
    finally {
      if (outerBean != null) {
        this.currentlyCreatedBean.set(outerBean);
      }
      else {
        this.currentlyCreatedBean.remove();
      }
    }
    if (instance == null) {
      instance = new NullBean();
    }
    //封装成BeanWrapper 包装类
    BeanWrapper bw = new BeanWrapperImpl(instance);
    initBeanWrapper(bw);
    return bw;
  }

  protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName)
      throws BeansException {
    if (beanClass != null && hasInstantiationAwareBeanPostProcessors()) {
      for (BeanPostProcessor bp : getBeanPostProcessors()) {
        if (bp instanceof SmartInstantiationAwareBeanPostProcessor) {
          SmartInstantiationAwareBeanPostProcessor ibp = (SmartInstantiationAwareBeanPostProcessor) bp;
          //调用determineCandidateConstructors方法，按照策略查询构造函数
          //如果bean的构造函数带有@Autowire注解或有且仅有一个有参构造函数则会被解析到
          Constructor<?>[] ctors = ibp.determineCandidateConstructors(beanClass, beanName);
          if (ctors != null) {
            return ctors;
          }
        }
      }
    }
    return null;
  }

  protected BeanWrapper autowireConstructor(
      String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs) {
    return new ConstructorResolver(this).autowireConstructor(beanName, mbd, ctors, explicitArgs);
  }

  public static void main(String[] args) {
    ClassPathXmlApplicationContext applicationContext=new ClassPathXmlApplicationContext("application-context.xml");
    Teacher teacher = (Teacher) applicationContext.getBean("teacher");
  }

private int resolveConstructorArguments(String beanName, RootBeanDefinition mbd, BeanWrapper bw,
      ConstructorArgumentValues cargs, ConstructorArgumentValues resolvedValues) {
    TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
    TypeConverter converter = (customConverter != null ? customConverter : bw);
    BeanDefinitionValueResolver valueResolver =
        new BeanDefinitionValueResolver(this.beanFactory, beanName, mbd, converter);
    //设置xml配置的构造函数参数个数
    int minNrOfArgs = cargs.getArgumentCount();
    //遍历
    for (Map.Entry<Integer, ConstructorArgumentValues.ValueHolder> entry : cargs.getIndexedArgumentValues().entrySet()) {
      //获取xml配置的构造函数注入index的值
      int index = entry.getKey();
      if (index < 0) {
        throw new BeanCreationException(mbd.getResourceDescription(), beanName,
            "Invalid constructor argument index: " + index);
      }
      //判断配置的下标值是否大于配置参数的个数
      if (index > minNrOfArgs) {
        minNrOfArgs = index + 1;
      }
      //获取需要注入的值
      ConstructorArgumentValues.ValueHolder valueHolder = entry.getValue();
      //判断是否解析过了，如果解析过则将下标跟注入值添加到resolvedValues中，
      if (valueHolder.isConverted()) {
        resolvedValues.addIndexedArgumentValue(index, valueHolder);
      }
      else {
        //将值进行转换封装创建，如 为BeanDefinition，进行实例化创建
        Object resolvedValue =
            valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
        //将生成的对象进行封装
        ConstructorArgumentValues.ValueHolder resolvedValueHolder =
            new ConstructorArgumentValues.ValueHolder(resolvedValue, valueHolder.getType(), valueHolder.getName());
        //设置原始值
        resolvedValueHolder.setSource(valueHolder);
        //添加到ConstructorArgumentValues的indexedArgumentValues集合中
        resolvedValues.addIndexedArgumentValue(index, resolvedValueHolder);
      }
    }
    //遍历其他类型注入方式
    for (ConstructorArgumentValues.ValueHolder valueHolder : cargs.getGenericArgumentValues()) {
      //判断是否完成转换
      if (valueHolder.isConverted()) {
        resolvedValues.addGenericArgumentValue(valueHolder);
      }
      else {
        //获取创建后的实例值
        Object resolvedValue =
            valueResolver.resolveValueIfNecessary("constructor argument", valueHolder.getValue());
        //封装成ValueHolder 对象
        ConstructorArgumentValues.ValueHolder resolvedValueHolder = new ConstructorArgumentValues.ValueHolder(
            resolvedValue, valueHolder.getType(), valueHolder.getName());
        //设置初始对象值
        resolvedValueHolder.setSource(valueHolder);
        //添加到ConstructorArgumentValues的genericArgumentValues集合中
        resolvedValues.addGenericArgumentValue(resolvedValueHolder);
      }
    }
    return minNrOfArgs;
  }

private ArgumentsHolder createArgumentArray(
      String beanName, RootBeanDefinition mbd, @Nullable ConstructorArgumentValues resolvedValues,
      BeanWrapper bw, Class<?>[] paramTypes, @Nullable String[] paramNames, Executable executable,
      boolean autowiring, boolean fallback) throws UnsatisfiedDependencyException {
    TypeConverter customConverter = this.beanFactory.getCustomTypeConverter();
    TypeConverter converter = (customConverter != null ? customConverter : bw);
    //新建一个ArgumentsHolder来存放匹配到的参数
    ArgumentsHolder args = new ArgumentsHolder(paramTypes.length);
    Set<ConstructorArgumentValues.ValueHolder> usedValueHolders = new HashSet<>(paramTypes.length);
    Set<String> autowiredBeanNames = new LinkedHashSet<>(4);
    for (int paramIndex = 0; paramIndex < paramTypes.length; paramIndex++) {
      //获取参数类型的class对象,如String
      Class<?> paramType = paramTypes[paramIndex];
      //获取该位置的参数名称
      String paramName = (paramNames != null ? paramNames[paramIndex] : "");
      // Try to find matching constructor argument value, either indexed or generic.
      ConstructorArgumentValues.ValueHolder valueHolder = null;
      if (resolvedValues != null) {
        //根据下标，参数名称、参数下标获取ValueHolder 
        valueHolder = resolvedValues.getArgumentValue(paramIndex, paramType, paramName, usedValueHolders);
        // If we couldn't find a direct match and are not supposed to autowire,
        // let's try the next generic, untyped argument value as fallback:
        // it could match after type conversion (for example, String -> int).
        //如果查询不到，则尝试使用可以进行类型之间转换的类型进行查询，如String -> int
        if (valueHolder == null && (!autowiring || paramTypes.length == resolvedValues.getArgumentCount())) {
          valueHolder = resolvedValues.getGenericArgumentValue(null, null, usedValueHolders);
        }
      }
      if (valueHolder != null) {
        // We found a potential match - let's give it a try.
        // Do not consider the same value definition multiple times!
        //添加到ValueHolder集合中
        usedValueHolders.add(valueHolder);
        //获取原始值
        Object originalValue = valueHolder.getValue();
        Object convertedValue;
        if (valueHolder.isConverted()) {
          //如果转换过，则直接进行赋值
          convertedValue = valueHolder.getConvertedValue();
          //添加到预选参数中
          args.preparedArguments[paramIndex] = convertedValue;
        }
        else {
          //将构造函数跟下标封装成MethodParameter 
          MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
          try {
            //将原始值转换成参数所需类型，转换失败则抛异常
            convertedValue = converter.convertIfNecessary(originalValue, paramType, methodParam);
          }
          catch (TypeMismatchException ex) {
            throw new UnsatisfiedDependencyException(
                mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
                "Could not convert argument value of type [" +
                    ObjectUtils.nullSafeClassName(valueHolder.getValue()) +
                    "] to required type [" + paramType.getName() + "]: " + ex.getMessage());
          }
          //获取原属性值
          Object sourceHolder = valueHolder.getSource();
          if (sourceHolder instanceof ConstructorArgumentValues.ValueHolder) {
            Object sourceValue = ((ConstructorArgumentValues.ValueHolder) sourceHolder).getValue();
            //标记为需要解析
            args.resolveNecessary = true;
            //添加sourceValue作为预备参数
            args.preparedArguments[paramIndex] = sourceValue;
          }
        }
        //将convertedValue作为args在paramIndex位置的参数
        args.arguments[paramIndex] = convertedValue;
        //将originalValue作为args在paramIndex位置的原始参数
        args.rawArguments[paramIndex] = originalValue;
      }
      else {
        MethodParameter methodParam = MethodParameter.forExecutable(executable, paramIndex);
        // No explicit match found: we're either supposed to autowire or
        // have to fail creating an argument array for the given constructor.
        //如果不是@Autowire注解的构造函数，则抛异常
        if (!autowiring) {
          throw new UnsatisfiedDependencyException(
              mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam),
              "Ambiguous argument values for parameter of type [" + paramType.getName() +
              "] - did you specify the correct bean references as arguments?");
        }
        try {
          //如果是自动装配，则调用用于解析自动装配参数的方法，返回的结果为依赖的bean实例对象
             // 例如：@Autowire修饰构造函数，自动注入构造函数中的参数bean就是在这边处理
          Object autowiredArgument = resolveAutowiredArgument(
              methodParam, beanName, autowiredBeanNames, converter, fallback);
          //设置原始值
          args.rawArguments[paramIndex] = autowiredArgument;
          //设置值
          args.arguments[paramIndex] = autowiredArgument;
          //设置预备值
          args.preparedArguments[paramIndex] = autowiredArgumentMarker;
          //标记为需要解析
          args.resolveNecessary = true;
        }
        catch (BeansException ex) {
          throw new UnsatisfiedDependencyException(
              mbd.getResourceDescription(), beanName, new InjectionPoint(methodParam), ex);
        }
      }
    }
    //依赖了其他的bean，则注册依赖关系
    for (String autowiredBeanName : autowiredBeanNames) {
      this.beanFactory.registerDependentBean(autowiredBeanName, beanName);
      if (logger.isDebugEnabled()) {
        logger.debug("Autowiring by type from bean name '" + beanName +
            "' via " + (executable instanceof Constructor ? "constructor" : "factory method") +
            " to bean named '" + autowiredBeanName + "'");
      }
    }
    return args;
  }

  protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
    try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
        beanInstance = AccessController.doPrivileged((PrivilegedAction<Object>) () ->
            getInstantiationStrategy().instantiate(mbd, beanName, parent),
            getAccessControlContext());
      }
      else {
        //获取策略进行实例化
        beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      //封装成BeanWrapper 对象
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      //初始化设置BeanWrapper属性值
      initBeanWrapper(bw);
      return bw;
    }
    catch (Throwable ex) {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
  }

@Override
  public Object instantiate(RootBeanDefinition bd, @Nullable String beanName, BeanFactory owner) {
    // Don't override the class with CGLIB if no overrides.
    if (!bd.hasMethodOverrides()) {
      Constructor<?> constructorToUse;
      synchronized (bd.constructorArgumentLock) {
        //获取构造函数
        constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
        if (constructorToUse == null) {
          //获取class对象
          final Class<?> clazz = bd.getBeanClass();
          if (clazz.isInterface()) {
            throw new BeanInstantiationException(clazz, "Specified class is an interface");
          }
          try {
            if (System.getSecurityManager() != null) {
              constructorToUse = AccessController.doPrivileged(
                  (PrivilegedExceptionAction<Constructor<?>>) clazz::getDeclaredConstructor);
            }
            else {
            //获取无参构造器
              constructorToUse = clazz.getDeclaredConstructor();
            }
            //设置无参构造器，下次实例化时可直接获取使用
            bd.resolvedConstructorOrFactoryMethod = constructorToUse;
          }
          catch (Throwable ex) {
            throw new BeanInstantiationException(clazz, "No default constructor found", ex);
          }
        }
      }
      //实例化
      return BeanUtils.instantiateClass(constructorToUse);
    }
    else {
      // Must generate CGLIB subclass.
      //使用cglib方式进行实例化
      return instantiateWithMethodInjection(bd, beanName, owner);
    }
  }

public static <T> T instantiateClass(Constructor<T> ctor, Object... args) throws BeanInstantiationException {
    Assert.notNull(ctor, "Constructor must not be null");
    try {
      //如果构造函数非Public，则设置Accessible权限
      ReflectionUtils.makeAccessible(ctor);
      //判断是否使用kotlin语言，如果是则使用kotlin语言进行实例化
      if (KotlinDetector.isKotlinReflectPresent() && KotlinDetector.isKotlinType(ctor.getDeclaringClass())) {
        return KotlinDelegate.instantiateClass(ctor, args);
      }
      else {
        //获取构造函数个数
        Class<?>[] parameterTypes = ctor.getParameterTypes();
        //参数个数不能比构造函数参数个数多
        Assert.isTrue(args.length <= parameterTypes.length, "Can't specify more arguments than constructor parameters");
        Object[] argsWithDefaultValues = new Object[args.length];
        //遍历传进来的参数
        for (int i = 0 ; i < args.length; i++) {
          if (args[i] == null) {
            //获取构造函数参数类型
            Class<?> parameterType = parameterTypes[i];
            //判断类型是否是基本数据类型，并尝试从默认类型中获取值
            //void、Integer、Double、Short、Long、Character、Byte、Boolean、Float
            argsWithDefaultValues[i] = (parameterType.isPrimitive() ? DEFAULT_TYPE_VALUES.get(parameterType) : null);
          }
          else {
            //赋值给参数数组
            argsWithDefaultValues[i] = args[i];
          }
        }
        //实例化
        return ctor.newInstance(argsWithDefaultValues);
      }
    }
    catch (InstantiationException ex) {
      throw new BeanInstantiationException(ctor, "Is it an abstract class?", ex);
    }
    catch (IllegalAccessException ex) {
      throw new BeanInstantiationException(ctor, "Is the constructor accessible?", ex);
    }
    catch (IllegalArgumentException ex) {
      throw new BeanInstantiationException(ctor, "Illegal arguments for constructor", ex);
    }
    catch (InvocationTargetException ex) {
      throw new BeanInstantiationException(ctor, "Constructor threw exception", ex.getTargetException());
    }
  }