// 這里是對 BeanFactory 接口的實現(xiàn)，比如getBean接口方法
  //這些getBean接口方法最終是通過調用doGetBean來實現(xiàn)的
  @Override
  public Object getBean(String name) throws BeansException {
    return doGetBean(name, null, null, false);
  }

  @Override
  public <T> T getBean(String name, Class<T> requiredType) throws BeansException {
    return doGetBean(name, requiredType, null, false);
  }

  @Override
  public Object getBean(String name, Object... args) throws BeansException {
    return doGetBean(name, null, args, false);
  }

  public <T> T getBean(String name, Class<T> requiredType, Object... args) throws BeansException {
    return doGetBean(name, requiredType, args, false);
  }

    //這里是實際取得Bean的地方,也就是觸發(fā)依賴注入發(fā)生的地方
  @SuppressWarnings("unchecked")
  protected <T> T doGetBean(
      final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)
      throws BeansException {

    final String beanName = transformedBeanName(name);
    Object bean;

    // Eagerly check singleton cache for manually registered singletons.
        //急切地檢查單例人士緩存手動注冊的單例
        //先從緩存中取得Bean,處理那些已經(jīng)被創(chuàng)建過的單例Bean,這種Bean不要重復創(chuàng)建
    Object sharedInstance = getSingleton(beanName);
    if (sharedInstance != null && args == null) {
      if (logger.isDebugEnabled()) {
        if (isSingletonCurrentlyInCreation(beanName)) {
          logger.debug("Returning eagerly cached instance of singleton bean '" + beanName +
              "' that is not fully initialized yet - a consequence of a circular reference");
        }
        else {
          logger.debug("Returning cached instance of singleton bean '" + beanName + "'");
        }
      }
            //這里的getObjectForBeanInstance完成的是FactoryBean的相關處理，以取得FactoryBean的相關處理,以取得FactoryBean的生產(chǎn)結果,BeanFactory和FactoryBean的區(qū)別已在前面講過,這個過程在后面還會詳細地分析
      bean = getObjectForBeanInstance(sharedInstance, name, beanName, null);
    }

    else {
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      if (isPrototypeCurrentlyInCreation(beanName)) {
        throw new BeanCurrentlyInCreationException(beanName);
      }

            // // 檢查IoC容器中的BeanDefinition是否存在,若在當前工廠不存在則去順著雙親BeanFactory鏈一直向上找
      BeanFactory parentBeanFactory = getParentBeanFactory();
      if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {
        // Not found -> check parent.
        String nameToLookup = originalBeanName(name);
        if (args != null) {
          // Delegation to parent with explicit args.
          return (T) parentBeanFactory.getBean(nameToLookup, args);
        }
        else {
          // No args -> delegate to standard getBean method.
          return parentBeanFactory.getBean(nameToLookup, requiredType);
        }
      }

      if (!typeCheckOnly) {
        markBeanAsCreated(beanName);
      }

      try {
                //根據(jù)Bean的名字取得BeanDefinition 
        final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
        checkMergedBeanDefinition(mbd, beanName, args);

        // Guarantee initialization of beans that the current bean depends on.
                //遞歸獲得當前Bean依賴的所有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 + "'");
            }
            registerDependentBean(dep, beanName);
            getBean(dep);
          }
        }

                //通過調用createBean方法創(chuàng)建Singleton bean實例
        if (mbd.isSingleton()) {
          sharedInstance = getSingleton(beanName, new ObjectFactory<Object>() {
            @Override
            public Object getObject() throws BeansException {
              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;
              }
            }
          });
          bean = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
        }
                //這里是創(chuàng)建prototype bean的地方
        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);
        }

        else {
          String scopeName = mbd.getScope();
          final 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, new ObjectFactory<Object>() {
              @Override
              public Object getObject() throws BeansException {
                beforePrototypeCreation(beanName);
                try {
                  return createBean(beanName, mbd, args);
                }
                finally {
                  afterPrototypeCreation(beanName);
                }
              }
            });
            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);
          }
        }
      }
      catch (BeansException ex) {
        cleanupAfterBeanCreationFailure(beanName);
        throw ex;
      }
    }

    // Check if required type matches the type of the actual bean instance.
        // 這里對創(chuàng)建的Bean進行類型檢查,如果沒有問題,就返回這個新創(chuàng)建的Bean,這個Bean已經(jīng)是包含了依賴關系的Bean
    if (requiredType != null && bean != null && !requiredType.isAssignableFrom(bean.getClass())) {
      try {
        return getTypeConverter().convertIfNecessary(bean, requiredType);
      }
      catch (TypeMismatchException ex) {
        if (logger.isDebugEnabled()) {
          logger.debug("Failed to convert bean '" + name + "' to required type '" +
              ClassUtils.getQualifiedName(requiredType) + "'", ex);
        }
        throw new BeanNotOfRequiredTypeException(name, requiredType, bean.getClass());
      }
    }
    return (T) bean;
  }

@Override
  protected Object createBean(String beanName, RootBeanDefinition mbd, Object[] args) throws BeanCreationException {
    if (logger.isDebugEnabled()) {
      logger.debug("Creating instance of bean '" + beanName + "'");
    }
    RootBeanDefinition mbdToUse = mbd;

    // Make sure bean class is actually resolved at this point, and
    // clone the bean definition in case of a dynamically resolved Class
    // which cannot be stored in the shared merged bean definition.
        //這里判斷需要創(chuàng)建的Bean是否可以被實例化,這個類是否可以通過類加載器來載入
    Class<?> resolvedClass = resolveBeanClass(mbd, beanName);
    if (resolvedClass != null && !mbd.hasBeanClass() && mbd.getBeanClassName() != null) {
      mbdToUse = new RootBeanDefinition(mbd);
      mbdToUse.setBeanClass(resolvedClass);
    }

    // Prepare method overrides.
    try {
      mbdToUse.prepareMethodOverrides();
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanDefinitionStoreException(mbdToUse.getResourceDescription(),
          beanName, "Validation of method overrides failed", ex);
    }

    try {
      // Give BeanPostProcessors a chance to return a proxy instead of the target bean instance.
            //如果Bean配置了PostProcessor,那么這里返回的是一個Proxy
      Object bean = resolveBeforeInstantiation(beanName, mbdToUse);
      if (bean != null) {
        return bean;
      }
    }
    catch (Throwable ex) {
      throw new BeanCreationException(mbdToUse.getResourceDescription(), beanName,
          "BeanPostProcessor before instantiation of bean failed", ex);
    }

    try {
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isDebugEnabled()) {
        logger.debug("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
    }
    catch (BeanCreationException ex) {
      // A previously detected exception with proper bean creation context already...
      throw ex;
    }
    catch (ImplicitlyAppearedSingletonException ex) {
      // An IllegalStateException to be communicated up to DefaultSingletonBeanRegistry...
      throw ex;
    }
    catch (Throwable ex) {
      throw new BeanCreationException(
          mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
    }
  }



  //接著到doCreate中去看看Bean是怎樣生成的
  protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {
    // Instantiate the bean.
        //用來持有創(chuàng)建出來的Bean對象
    BeanWrapper instanceWrapper = null;
        //如果是單例,則先把緩存中的同名Bean清除
    if (mbd.isSingleton()) {
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
    }
        //這里是創(chuàng)建Bean的地方,由createBeanInstance來完成
    if (instanceWrapper == null) {
            //根據(jù)指定bean使用對應的策略創(chuàng)建新的實例,如:工廠方法,構造函數(shù)自動注入,簡單初始化
      instanceWrapper = createBeanInstance(beanName, mbd, args);
    }
    final Object bean = (instanceWrapper != null ? instanceWrapper.getWrappedInstance() : null);
    Class<?> beanType = (instanceWrapper != null ? instanceWrapper.getWrappedClass() : null);

    // Allow post-processors to modify the merged bean definition.
    synchronized (mbd.postProcessingLock) {
      if (!mbd.postProcessed) {
        applyMergedBeanDefinitionPostProcessors(mbd, beanType, beanName);
        mbd.postProcessed = true;
      }
    }

    // Eagerly cache singletons to be able to resolve circular references
    // even when triggered by lifecycle interfaces like BeanFactoryAware.
        //是否需要提前曝光:單例&允許循環(huán)依賴&當前bean正在創(chuàng)建中,檢測循環(huán)依賴
    boolean earlySingletonExposure = (mbd.isSingleton() && this.allowCircularReferences &&
        isSingletonCurrentlyInCreation(beanName));
    if (earlySingletonExposure) {
      if (logger.isDebugEnabled()) {
        logger.debug("Eagerly caching bean '" + beanName +
            "' to allow for resolving potential circular references");
      }
            //為避免后期循環(huán)依賴,可以在bean初始化完成前將創(chuàng)建實例的ObjectFactory加入工廠
      addSingletonFactory(beanName, new ObjectFactory<Object>() {
        @Override
        public Object getObject() throws BeansException {
                    //對bean再次依賴引用,主要應用SMartInstantialiationAware BeanPostProcessor,
                    //其中我們熟知的AOP就是在這里將advice動態(tài)織入bean中,若無則直接返回bean,不做任何處理
          return getEarlyBeanReference(beanName, mbd, bean);
        }
      });
    }

    // Initialize the bean instance.
        //這里是對Bean的初始化,依賴注入往往在這里發(fā)生,這個exposedObject在初始化處理完后悔返回作為依賴注入完成后的Bean
    Object exposedObject = bean;
    try {
            //對bean進行填充,將各個屬性值注入,其中可能存在依賴于其他bean的屬性,則會遞歸初始化依賴bean
      populateBean(beanName, mbd, instanceWrapper);
      if (exposedObject != null) {
                //調用初始化方法,比如init-method
        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) {
      Object earlySingletonReference = getSingleton(beanName, false);
            // earlySingletonReference 只有在檢測到有循環(huán)依賴的情況下才會非空
      if (earlySingletonReference != null) {
        if (exposedObject == bean) {
                    //如果exposedObject 沒有在初始化方法中被改變,也就是沒有被增強
          exposedObject = earlySingletonReference;
        }
        else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
          String[] dependentBeans = getDependentBeans(beanName);
          Set<String> actualDependentBeans = new LinkedHashSet<String>(dependentBeans.length);
          for (String dependentBean : dependentBeans) {
                        //檢測依賴
            if (!removeSingletonIfCreatedForTypeCheckOnly(dependentBean)) {
              actualDependentBeans.add(dependentBean);
            }
          }
                    //因為bean創(chuàng)建后其所依賴的bean一定是已經(jīng)創(chuàng)建的,actualDependentBeans非空則表示當前bean創(chuàng)建后其依賴的bean卻沒有全部創(chuàng)建完,也就是說存在循環(huán)依賴
          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 {
            //根據(jù)scope注冊bean
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
    }
    catch (BeanDefinitionValidationException ex) {
      throw new BeanCreationException(mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
    }

    return exposedObject;
  }

/**
   * Create a new instance for the specified bean, using an appropriate instantiation strategy:
   * factory method, constructor autowiring, or simple instantiation.
   * @param beanName the name of the bean
   * @param mbd the bean definition for the bean
   * @param args explicit arguments to use for constructor or factory method invocation
   * @return a BeanWrapper for the new instance
   */
  protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args) {
    // Make sure bean class is actually resolved at this point.
        // 確認需要創(chuàng)建的Bean實例的類可以實例化
    Class<?> beanClass = resolveBeanClass(mbd, beanName);

    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<?> 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) {
                //一個類有多個構造函數(shù),每個構造函數(shù)都有不同的參數(shù),所以調用前需要先根據(jù)參數(shù)鎖定構造函數(shù)或對應的工廠方法
        if (mbd.resolvedConstructorOrFactoryMethod != null) {
          resolved = true;
          autowireNecessary = mbd.constructorArgumentsResolved;
        }
      }
    }
        //如果已經(jīng)解析過則使用解析好的構造函數(shù)方法不需要再次鎖定
    if (resolved) {
      if (autowireNecessary) {
                //構造函數(shù)自動注入
        return autowireConstructor(beanName, mbd, null, null);
      }
      else {
                //使用默認構造函數(shù)構造
        return instantiateBean(beanName, mbd);
      }
    }

    // Need to determine the constructor...
         // 使用構造函數(shù)對Bean進行實例化
    Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
    if (ctors != null ||
        mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_CONSTRUCTOR ||
        mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
      return autowireConstructor(beanName, mbd, ctors, args);
    }

    // No special handling: simply use no-arg constructor.
        //使用默認的構造函數(shù)對Bean進行實例化
    return instantiateBean(beanName, mbd);
  }

  /**
   * Instantiate the given bean using its default constructor.
   * @param beanName the name of the bean
   * @param mbd the bean definition for the bean
   * @return a BeanWrapper for the new instance
   */
    //最常見的實例化過程instantiateBean
  protected BeanWrapper instantiateBean(final String beanName, final RootBeanDefinition mbd) {
         //使用默認的實例化策略對Bean進行實例化,默認的實例化策略是
    //CglibSubclassingInstantiationStrategy,也就是使用CGLIB實例化Bean 
    try {
      Object beanInstance;
      final BeanFactory parent = this;
      if (System.getSecurityManager() != null) {
        beanInstance = AccessController.doPrivileged(new PrivilegedAction<Object>() {
          @Override
          public Object run() {
            return getInstantiationStrategy().instantiate(mbd, beanName, parent);
          }
        }, getAccessControlContext());
      }
      else {
        beanInstance = getInstantiationStrategy().instantiate(mbd, beanName, parent);
      }
      BeanWrapper bw = new BeanWrapperImpl(beanInstance);
      initBeanWrapper(bw);
      return bw;
    }
    catch (Throwable ex) {
      throw new BeanCreationException(
          mbd.getResourceDescription(), beanName, "Instantiation of bean failed", ex);
    }
  }

public class SimpleInstantiationStrategy implements InstantiationStrategy {
@Override
  public Object instantiate(RootBeanDefinition bd, String beanName, BeanFactory owner) {
    // Don't override the class with CGLIB if no overrides.
    if (bd.getMethodOverrides().isEmpty()) {
            //這里取得指定的構造器或者生成對象的工廠方法來對Bean進行實例化
      Constructor<?> constructorToUse;
      synchronized (bd.constructorArgumentLock) {
        constructorToUse = (Constructor<?>) bd.resolvedConstructorOrFactoryMethod;
        if (constructorToUse == null) {
          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(new PrivilegedExceptionAction<Constructor<?>>() {
                @Override
                public Constructor<?> run() throws Exception {
                  return clazz.getDeclaredConstructor((Class[]) null);
                }
              });
            }
            else {
              constructorToUse = clazz.getDeclaredConstructor((Class[]) null);
            }
            bd.resolvedConstructorOrFactoryMethod = constructorToUse;
          }
          catch (Throwable ex) {
            throw new BeanInstantiationException(clazz, "No default constructor found", ex);
          }
        }
      }
      //通過BeanUtils進行實例化，這個BeanUtils的實例化通過Constructor來實例化Bean,在BeanUtils中可以看到具體的調用ctor.newInstance(args)
      return BeanUtils.instantiateClass(constructorToUse);
    }
    else {   
      // 使用CGLIB來實例化對象
      return instantiateWithMethodInjection(bd, beanName, owner);
    }
  }
}