Spring Boot getBean()

Spring Boot getBean()

1.概述

getBean()方法是容器获取和实例化Bean的重要方法。

容器中的所有的Bean(不包括SpringApplication启动时从/META-INF/spring.factories中读取并创建的Bean)都要通过该方法实例化。

2.doGetBean()

getBean()最终会调用doGetBean方法。

//部分代码
protected <T> T doGetBean(
      String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly)
      throws BeansException {
     


   // Eagerly check singleton cache for manually registered singletons.
   //判断是否已经实例化了该Bean，是的话直接返回。
   Object sharedInstance = getSingleton(beanName);
   if (sharedInstance != null && args == null) {
     
      if (logger.isTraceEnabled()) {
     
         if (isSingletonCurrentlyInCreation(beanName)) {
     
            logger.trace("Returning eagerly cached instance of singleton bean '" + beanName +
                  "' that is not fully initialized yet - a consequence of a circular reference");
         }
         else {
     
            logger.trace("Returning cached instance of singleton bean '" + beanName + "'");
         }
      }
      beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, null);
   }

   else {
     
      // Fail if we're already creating this bean instance:
      // We're assumably within a circular reference.
      //如果当前线程正在创建该	Bean实例中，证明此次创建之前已经有一个该对象在创建中的，说明出现了循环依赖自己。
      //抛出Requested bean is currently in creation: Is there an unresolvable circular reference?(
     //请求的bean当前正在创建中：是否存在无法解析的循环引用？)异常
      if (isPrototypeCurrentlyInCreation(beanName)) {
     
         throw new BeanCurrentlyInCreationException(beanName);
      }

      // Check if bean definition exists in this factory.
      //判断父工厂中是否有该Bean。
      //有就从父工厂获取该Bean实例。
      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.
            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);
         }
      }

      //获取实例是否是为了进行类型检查，而不是为了实际使用。
      if (!typeCheckOnly) {
     
          //在alreadyCreated缓存中加入该Bean名字。
         markBeanAsCreated(beanName);
      }

      try {
     
         //获取该Bean定义信息
         RootBeanDefinition mbd = getMergedLocalBeanDefinition(beanName);
         //判断还Bean是否合法，如果是抽象类抛出异常。"Bean definition is abstract"
         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) {
     
               //判断依赖的Bean和当前Bean是否存在循环依赖，存在则抛出异常。
               if (isDependent(beanName, dep)) {
     
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "Circular depends-on relationship between '" + beanName + "' and '" + dep + "'");
               }
                //为给定bean注册一个依赖bean。
               registerDependentBean(dep, beanName);
               try {
     
                   //获取依赖的Bean实例
                  getBean(dep);
               }
               catch (NoSuchBeanDefinitionException ex) {
     
                  throw new BeanCreationException(mbd.getResourceDescription(), beanName,
                        "'" + beanName + "' depends on missing bean '" + dep + "'", ex);
               }
            }
         }

         // Create bean instance.--------------------单例Bean创建------------------------------------------
         //真正进行创建单例bean实例。
         if (mbd.isSingleton()) {
     
            sharedInstance = getSingleton(beanName, () -> {
     
               try {
     
                  //见3
                  //创建该Bean实例，并调用post-processors
                  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;
               }
            });
            beanInstance = getObjectForBeanInstance(sharedInstance, name, beanName, mbd);
         }
//------------------------------------------------非单例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);
            }
            beanInstance = getObjectForBeanInstance(prototypeInstance, name, beanName, mbd);
         }

         else {
     
            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);
}

3.createBean()

//Central method of this class: creates a bean instance, populates the bean instance, applies post-processors, etc.
//部分代码
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
     
    
   RootBeanDefinition mbdToUse = mbd;
   //确保该Bean定义包含一个被解析的类。
	...
   // 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.
      //1.调用:InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation()
      //2.如果上面的所有InstantiationAwareBeanPostProcessor执行后，返回的Bean不是null，证明该Bean被实例化了。
      //3.如果2条件成立，调用所有BeanPostProcessor的postProcessAfterInitialization()
      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 {
     
      //调用doCreateBean()，实例化该Bean，见4
      Object beanInstance = doCreateBean(beanName, mbdToUse, args);
      if (logger.isTraceEnabled()) {
     
         logger.trace("Finished creating instance of bean '" + beanName + "'");
      }
      return beanInstance;
   }
   catch (BeanCreationException | ImplicitlyAppearedSingletonException ex) {
     
      // A previously detected exception with proper bean creation context already,
      // or illegal singleton state to be communicated up to DefaultSingletonBeanRegistry.
      throw ex;
   }
   catch (Throwable ex) {
     
      throw new BeanCreationException(
            mbdToUse.getResourceDescription(), beanName, "Unexpected exception during bean creation", ex);
   }
}

4.doCreateBean()

protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
      throws BeanCreationException {
     

   // Instantiate the bean.
   BeanWrapper instanceWrapper = null;
   if (mbd.isSingleton()) {
     
      instanceWrapper = this.factoryBeanInstanceCache.remove(beanName);
   }
   if (instanceWrapper == null) {
     
       //调用createBeanInstance创建Bean实例，见5
      instanceWrapper = createBeanInstance(beanName, mbd, args);
   }
   //获得上述创建好的Bean实例，此时Bean实例属性还是默认值。
   Object bean = instanceWrapper.getWrappedInstance();
   Class<?> beanType = instanceWrapper.getWrappedClass();
   if (beanType != NullBean.class) {
     
      mbd.resolvedTargetType = beanType;
   }

   // Allow post-processors to modify the merged bean definition.
   synchronized (mbd.postProcessingLock) {
     
      if (!mbd.postProcessed) {
     
         try {
     
            //调用MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition()方法。
            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.
   //缓存单例，以便能够解析循环引用。
   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");
      }
      //加入缓存
      /*if (!this.singletonObjects.containsKey(beanName)) {
				this.singletonFactories.put(beanName, singletonFactory);
				this.earlySingletonObjects.remove(beanName);
				//registeredSingletons中注册该名字。
				this.registeredSingletons.add(beanName);
			}*/
      addSingletonFactory(beanName, 
                         //调用SmartInstantiationAwareBeanPostProcessor.getEarlyBeanReference（）
                          () -> getEarlyBeanReference(beanName, mbd, bean)
                         );
   }

   // Initialize the bean instance.
   Object exposedObject = bean;
   try {
     
      //见6
      populateBean(beanName, mbd, instanceWrapper);
      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);
      if (earlySingletonReference != null) {
     
         if (exposedObject == bean) {
     
            exposedObject = earlySingletonReference;
         }
         else if (!this.allowRawInjectionDespiteWrapping && hasDependentBean(beanName)) {
     
            String[] dependentBeans = getDependentBeans(beanName);
            Set<String> actualDependentBeans = new LinkedHashSet<>(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 " +
                     "'getBeanNamesForType' with the 'allowEagerInit' flag turned off, for example.");
            }
         }
      }
   }

   // Register bean as disposable.
   try {
     
      registerDisposableBeanIfNecessary(beanName, bean, mbd);
   }
   catch (BeanDefinitionValidationException ex) {
     
      throw new BeanCreationException(
            mbd.getResourceDescription(), beanName, "Invalid destruction signature", ex);
   }

   return exposedObject;
}

5.createBeanInstance()

protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) {
     
   // Make sure bean class is actually resolved at this point.
   Class<?> beanClass = resolveBeanClass(mbd, beanName);
	//如果该类不是public，则抛出异常
   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定义有工厂方法，则使用工厂方法实例化该Bean
    //@Configtion中的@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方法，返回该Bean的构造器集合。
   Constructor<?>[] ctors = determineConstructorsFromBeanPostProcessors(beanClass, beanName);
   if (ctors != null || mbd.getResolvedAutowireMode() == AUTOWIRE_CONSTRUCTOR ||
         mbd.hasConstructorArgumentValues() || !ObjectUtils.isEmpty(args)) {
     
      return autowireConstructor(beanName, mbd, ctors, args);
   }

   // Preferred constructors for default construction?
   //确定用于默认构造的首选构造函数（如果有）。如果需要，构造函数参数将autowire。
   ctors = mbd.getPreferredConstructors();
   if (ctors != null) {
     
      return autowireConstructor(beanName, mbd, ctors, null);
   }

   // No special handling: simply use no-arg constructor.
   //如果上述条件都不成力，使用无参构造器初始化该实例，见5.1
   return instantiateBean(beanName, mbd);
}

5.1 instantiate()

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) {
     
            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.
      return instantiateWithMethodInjection(bd, beanName, owner);
   }
}

6.populateBean()

protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw) {
     
   if (bw == null) {
     
      if (mbd.hasPropertyValues()) {
     
         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.
   //调用InstantiationAwareBeanPostProcessor.postProcessAfterInstantiation()
   if (!mbd.isSynthetic() && hasInstantiationAwareBeanPostProcessors()) {
     
      for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
     
         if (!bp.postProcessAfterInstantiation(bw.getWrappedInstance(), beanName)) {
     
            return;
         }
      }
   }
   
   PropertyValues pvs = (mbd.hasPropertyValues() ? mbd.getPropertyValues() : null);

   int resolvedAutowireMode = mbd.getResolvedAutowireMode();
   if (resolvedAutowireMode == AUTOWIRE_BY_NAME || resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
     
      MutablePropertyValues newPvs = new MutablePropertyValues(pvs);
      // Add property values based on autowire by name if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_NAME) {
     
         autowireByName(beanName, mbd, bw, newPvs);
      }
      // Add property values based on autowire by type if applicable.
      if (resolvedAutowireMode == AUTOWIRE_BY_TYPE) {
     
         autowireByType(beanName, mbd, bw, newPvs);
      }
      pvs = newPvs;
   }

   boolean hasInstAwareBpps = hasInstantiationAwareBeanPostProcessors();
   boolean needsDepCheck = (mbd.getDependencyCheck() != AbstractBeanDefinition.DEPENDENCY_CHECK_NONE);

   PropertyDescriptor[] filteredPds = null;
   if (hasInstAwareBpps) {
     
      if (pvs == null) {
     
         pvs = mbd.getPropertyValues();
      }
      //1.调用InstantiationAwareBeanPostProcessor.postProcessProperties()方法。
      //2.如果1返回的不是null，调用InstantiationAwareBeanPostProcessor.postProcessPropertyValues()方法。
      //最终调用AutowiredAnnotationBeanPostProcessor这个InstantiationAwareBeanPostProcessor完成@Autowire属性的注入。
       //最终还是会调用doGetBean方法获取@Autowire的Bean实例。--------------------------------------------------
      for (InstantiationAwareBeanPostProcessor bp : getBeanPostProcessorCache().instantiationAware) {
     
         PropertyValues pvsToUse = bp.postProcessProperties(pvs, bw.getWrappedInstance(), beanName);
         if (pvsToUse == null) {
     
            if (filteredPds == null) {
     
               filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
            }
            pvsToUse = bp.postProcessPropertyValues(pvs, filteredPds, bw.getWrappedInstance(), beanName);
            if (pvsToUse == null) {
     
               return;
            }
         }
         pvs = pvsToUse;
      }
   }
   if (needsDepCheck) {
     
      if (filteredPds == null) {
     
         filteredPds = filterPropertyDescriptorsForDependencyCheck(bw, mbd.allowCaching);
      }
      checkDependencies(beanName, mbd, filteredPds, pvs);
   }

   if (pvs != null) {
     
      applyPropertyValues(beanName, mbd, bw, pvs);
   }
}