详解Spring中Bean的加载的方法

TestBean bean = factory.getBean("testBean");

@Overridepublic Object getBean(String name) throws BeansException {  return doGetBean(name, null, null, false);}

protected <T> T doGetBean(    final String name, final Class<T> requiredType, final Object[] args, boolean typeCheckOnly)    throws BeansException {  // 提取beanName  final String beanName = transformedBeanName(name);  Object bean;  // 试着从缓存或实例工厂中获取  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 + "'");      }    }    // 返回实例，有时存在如BeanFactory这样情况时并不是直接返回实例本身而是返回指定方法返回的实例    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);    }    // Check if bean definition exists in this factory.    BeanFactory parentBeanFactory = getParentBeanFactory();    // 如果在所有已经加载的类中没有beanName则会尝试从parentBeanFactory中检测    if (parentBeanFactory != null && !containsBeanDefinition(beanName)) {      // Not found -> check parent.      String nameToLookup = originalBeanName(name);      // 到BeanFactory查找      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);      }    }    // 如果不是只做类型检查则是创建bean    if (!typeCheckOnly) {      markBeanAsCreated(beanName);    }    try {      // 将存储XML配置文件的GernericBeanDefinition转换成RootBeanDefinition，如果BeanName是子Bean的话会合并父类的相关属性      final RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);      checkMergedBeanDefinition(mbd, beanName, args);      // Guarantee initialization of beans that the current bean depends on.      String[] dependsOn = mbd.getDependsOn();      // 如果存在依赖的话要递归实例化依赖的bean      if (dependsOn != null) {        for (String dependsOnBean : dependsOn) {          if (isDependent(beanName, dependsOnBean)) {            throw new BeanCreationException(mbd.getResourceDescription(), beanName,                "Circular depends-on relationship between '" + beanName + "' and '" + dependsOnBean + "'");          }          registerDependentBean(dependsOnBean, beanName);          getBean(dependsOnBean);        }      }      // Create bean instance.      // 依赖的bean实例化完后就可以实例化mbd了      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);      }      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 {        // 在对应的scope上实例化bean        String scopeName = mbd.getScope();        final Scope scope = this.scopes.get(scopeName);        if (scope == null) {          throw new IllegalStateException("No Scope registered for scope '" + 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;    }  }  // 检查需要的类型是否符合实例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;}

@Overridepublic Object getSingleton(String beanName) {  return getSingleton(beanName, true); // true表示允许早期依赖}protected Object getSingleton(String beanName, boolean allowEarlyReference) {  // 尝试从缓存获取实例  Object singletonObject = this.singletonObjects.get(beanName);  if (singletonObject == null && isSingletonCurrentlyInCreation(beanName)) {    synchronized (this.singletonObjects) {      // 若该bean正在加载则不处理      singletonObject = this.earlySingletonObjects.get(beanName);      if (singletonObject == null && allowEarlyReference) {        ObjectFactory<?> singletonFactory = this.singletonFactories.get(beanName);        if (singletonFactory != null) {          singletonObject = singletonFactory.getObject();          // 存入到缓存中          this.earlySingletonObjects.put(beanName, singletonObject);          this.singletonFactories.remove(beanName);        }      }    }  }  return (singletonObject != NULL_OBJECT ? singletonObject : null);}/* 这两个方法在DefaultSingletonBeanRegistry类中 */

public Object getSingleton(String beanName, ObjectFactory<?> singletonFactory) {  Assert.notNull(beanName, "'beanName' must not be null");  synchronized (this.singletonObjects) {    // 先检查bean是否已经加载    Object singletonObject = this.singletonObjects.get(beanName);    // 如果空才进行singleton的bean的初始化    if (singletonObject == null) {      if (this.singletonsCurrentlyInDestruction) {        throw new BeanCreationNotAllowedException(beanName,            "Singleton bean creation not allowed while the 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 + "'");      }      beforeSingletonCreation(beanName);      boolean newSingleton = false;      boolean recordSuppressedExceptions = (this.suppressedExceptions == null);      if (recordSuppressedExceptions) {        this.suppressedExceptions = new LinkedHashSet<Exception>();      }      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) {        if (recordSuppressedExceptions) {          for (Exception suppressedException : this.suppressedExceptions) {            ex.addRelatedCause(suppressedException);          }        }        throw ex;      }      finally {        if (recordSuppressedExceptions) {          this.suppressedExceptions = null;        }        afterSingletonCreation(beanName);      }      if (newSingleton) {        // 存入缓存        addSingleton(beanName, singletonObject);      }    }    return (singletonObject != NULL_OBJECT ? singletonObject : null);  }}

protected Object createBean(final String beanName, final RootBeanDefinition mbd, final Object[] args)    throws BeanCreationException {  if (logger.isDebugEnabled()) {    logger.debug("Creating instance of bean '" + beanName + "'");  }  // 锁定class，根据设置的class属性或根据className来解析Class  resolveBeanClass(mbd, beanName);  // 验证和准备覆盖的方法  try {    mbd.prepareMethodOverrides();  }  catch (BeanDefinitionValidationException ex) {    throw new BeanDefinitionStoreException(mbd.getResourceDescription(),        beanName, "Validation of method overrides failed", ex);  }  try {    // 用BeanPostProcessors返回代理来替代真正的实例    Object bean = resolveBeforeInstantiation(beanName, mbd);    if (bean != null) {      return bean;    }  }  catch (Throwable ex) {    throw new BeanCreationException(mbd.getResourceDescription(), beanName,        "BeanPostProcessor before instantiation of bean failed", ex);  }  Object beanInstance = doCreateBean(beanName, mbd, args);  if (logger.isDebugEnabled()) {    logger.debug("Finished creating instance of bean '" + beanName + "'");  }  return beanInstance;}

protected Object doCreateBean(final String beanName, final RootBeanDefinition mbd, final Object[] args) {  // Instantiate the bean.  BeanWrapper instanceWrapper = null;  if (mbd.isSingleton()) {    instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);  }  if (instanceWrapper == null) {    // 根据指定bean使用相应策略创建实例    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;    }  }  // 检测循环依赖，是否需要提早曝光  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");    }    // 避免循环依赖，可以在bean初始化完成前将创建实例的ObjectFactory加入工厂    addSingletonFactory(beanName, new ObjectFactory<Object>() {      @Override      public Object getObject() throws BeansException {        // 对bean再次依赖引用        // AOP也是在这里将advice动态织入bean中，若没有则直接返回bean，不做处理        return getEarlyBeanReference(beanName, mbd, bean);      }    });  }  // Initialize the bean instance.  Object exposedObject = bean;  try {    // 填充bean，注入属性值，如果存在依赖于其他bean的属性，会递归初始化    populateBean(beanName, mbd, instanceWrapper);    if (exposedObject != null) {      // 调用初始化方法      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只有在检测到有循环依赖的情况下才会不为空    if (earlySingletonReference != null) {      if (exposedObject == bean) {        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);          }        }        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 {    // 依据scopse注册bean    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, Object[] args) {  // 解析class  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());  }  // 若工厂方法不为空则使用工厂方法初始化  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);    }  }  // 根据参数解析构造方法  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.  return instantiateBean(beanName, mbd);}

protected void populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw) {  PropertyValues pvs = mbd.getPropertyValues();  if (bw == null) {    if (!pvs.isEmpty()) {      throw new BeanCreationException(          mbd.getResourceDescription(), beanName, "Cannot apply property values to null instance");    }    else {      // Skip property population phase for null instance.      return;    }  }  // Give any InstantiationAwareBeanPostProcessors the opportunity to modify the  // state of the bean before properties are set. This can be used, for example,  // to support styles of field injection.  boolean continueWithPropertyPopulation = true;  if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {    for (BeanPostProcessor bp : getBeanPostProcessors()) {      if (bp instanceof InstantiationAwareBeanPostProcessor) {        InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;        if (!ibp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {          continueWithPropertyPopulation = false;          break;        }      }    }  }  if (!continueWithPropertyPopulation) {    return;  }  if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME ||      mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {    MutablePropertyValues newPvs = new MutablePropertyValues(pvs);    // Add property values based on autowire by name if applicable.    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_NAME) {      autowireByName(beanName, mbd, bw, newPvs);    }    // Add property values based on autowire by type if applicable.    if (mbd.getResolvedAutowireMode() == RootBeanDefinition.AUTOWIRE_BY_TYPE) {      autowireByType(beanName, mbd, bw, newPvs);    }    pvs = newPvs;  }  boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();  boolean needsDepCheck = (mbd.getDependencyCheck() != RootBeanDefinition.DEPENDENCY_CHECK_NONE);  if (hasInstAwareBpps || needsDepCheck) {    PropertyDescriptor[] filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);    if (hasInstAwareBpps) {      for (BeanPostProcessor bp : getBeanPostProcessors()) {        if (bp instanceof InstantiationAwareBeanPostProcessor) {          InstantiationAwareBeanPostProcessor ibp = (InstantiationAwareBeanPostProcessor) bp;          pvs = ibp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);          if (pvs == null) {            return;          }        }      }    }    if (needsDepCheck) {      checkDependencies(beanName, mbd, filteredPds, pvs);    }  }  applyPropertyValues(beanName, mbd, bw, pvs);}

protected Object initializeBean(final String beanName, final Object bean, RootBeanDefinition mbd) {  if (System.getSecurityManager() != null) {    AccessController.doPrivileged(new PrivilegedAction<Object>() {      @Override      public Object run() {        invokeAwareMethods(beanName, bean);        return null;      }    }, getAccessControlContext());  }  else {    // 特殊bean处理    invokeAwareMethods(beanName, bean);  }  Object wrappedBean = bean;  if (mbd == null || !mbd.isSynthetic()) {    wrappedBean = applyBeanPostProcessorsBeforeInitialization(wrappedBean, beanName);  }  try {    invokeInitMethods(beanName, wrappedBean, mbd);  }  catch (Throwable ex) {    throw new BeanCreationException(        (mbd != null ? mbd.getResourceDescription() : null),        beanName, "Invocation of init method failed", ex);  }  if (mbd == null || !mbd.isSynthetic()) {    wrappedBean = applyBeanPostProcessorsAfterInitialization(wrappedBean, beanName);  }  return wrappedBean;}