org.springframework.beans.factory.support

## 类 AbstractAutowireCapableBeanFactory

- java.lang.Object
- - org.springframework.core.SimpleAliasRegistry
  - - org.springframework.beans.factory.support.DefaultSingletonBeanRegistry
    - - org.springframework.beans.factory.support.FactoryBeanRegistrySupport
      - - org.springframework.beans.factory.support.AbstractBeanFactory
        - - org.springframework.beans.factory.support.AbstractAutowireCapableBeanFactory

- 所有已实现的接口:
    BeanFactory, AutowireCapableBeanFactory, ConfigurableBeanFactory, SingletonBeanRegistry, HierarchicalBeanFactory, org.springframework.core.AliasRegistry
  直接已知子类:
    DefaultListableBeanFactory

      public abstract class AbstractAutowireCapableBeanFactory
      extends AbstractBeanFactory
      implements AutowireCapableBeanFactory

  Abstract bean factory superclass that implements default bean creation, with the full capabilities specified by the `RootBeanDefinition` class. Implements the `AutowireCapableBeanFactory` interface in addition to AbstractBeanFactory's `createBean(java.lang.Class<T>)` method.

  Provides bean creation (with constructor resolution), property population, wiring (including autowiring), and initialization. Handles runtime bean references, resolves managed collections, calls initialization methods, etc. Supports autowiring constructors, properties by name, and properties by type.

  The main template method to be implemented by subclasses is `AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor, String, Set, TypeConverter)`, used for autowiring by type. In case of a factory which is capable of searching its bean definitions, matching beans will typically be implemented through such a search. For other factory styles, simplified matching algorithms can be implemented.

  Note that this class does not assume or implement bean definition registry capabilities. See `DefaultListableBeanFactory` for an implementation of the `ListableBeanFactory` and `BeanDefinitionRegistry` interfaces, which represent the API and SPI view of such a factory, respectively.

  从以下版本开始:
    13.02.2004
  作者:
    Rod Johnson, Juergen Hoeller, Rob Harrop, Mark Fisher, Costin Leau, Chris Beams, Sam Brannen
  另请参阅:
    `RootBeanDefinition`, `DefaultListableBeanFactory`, `BeanDefinitionRegistry`

- - ### 字段概要

    - ### 从类继承的字段 org.springframework.core.SimpleAliasRegistry

      `logger`

    - ### 从接口继承的字段 org.springframework.beans.factory.config.AutowireCapableBeanFactory

      `AUTOWIRE_AUTODETECT, AUTOWIRE_BY_NAME, AUTOWIRE_BY_TYPE, AUTOWIRE_CONSTRUCTOR, AUTOWIRE_NO`

    - ### 从接口继承的字段 org.springframework.beans.factory.BeanFactory

      `FACTORY_BEAN_PREFIX`

    - ### 从接口继承的字段 org.springframework.beans.factory.config.ConfigurableBeanFactory

      `SCOPE_PROTOTYPE, SCOPE_SINGLETON`

  - ### 构造器概要

    构造器
    构造器和说明
    `AbstractAutowireCapableBeanFactory()` Create a new AbstractAutowireCapableBeanFactory.
    `AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory)` Create a new AbstractAutowireCapableBeanFactory with the given parent.

  - ### 方法概要

    所有方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `Object` | `applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName)` Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessAfterInitialization` methods.
    `Object` | `applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName)` Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessBeforeInitialization` methods.
    `protected Object` | `applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)` Apply InstantiationAwareBeanPostProcessors to the specified bean definition (by class and name), invoking their `postProcessBeforeInstantiation` methods.
    `void` | `applyBeanPropertyValues(Object existingBean, String beanName)` Apply the property values of the bean definition with the given name to the given bean instance.
    `protected void` | `applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName)` Apply MergedBeanDefinitionPostProcessors to the specified bean definition, invoking their `postProcessMergedBeanDefinition` methods.
    `protected void` | `applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)` Apply the given property values, resolving any runtime references to other beans in this bean factory.
    `Object` | `autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck)` Instantiate a new bean instance of the given class with the specified autowire strategy.
    `void` | `autowireBean(Object existingBean)` Populate the given bean instance through applying after-instantiation callbacks and bean property post-processing (e.g. for annotation-driven injection).
    `void` | `autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck)` Autowire the bean properties of the given bean instance by name or type.
    `protected void` | `autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)` Fill in any missing property values with references to other beans in this factory if autowire is set to "byName".
    `protected void` | `autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)` Abstract method defining "autowire by type" (bean properties by type) behavior.
    `protected BeanWrapper` | `autowireConstructor(String beanName, RootBeanDefinition mbd, Constructor<?>[] ctors, Object[] explicitArgs)` "autowire constructor" (with constructor arguments by type) behavior.
    `protected void` | `checkDependencies(String beanName, AbstractBeanDefinition mbd, PropertyDescriptor[] pds, PropertyValues pvs)` Perform a dependency check that all properties exposed have been set, if desired.
    `protected void` | `clearSingletonCache()` Overridden to clear FactoryBean instance cache as well.
    `Object` | `configureBean(Object existingBean, String beanName)` Configure the given raw bean: autowiring bean properties, applying bean property values, applying factory callbacks such as `setBeanName` and `setBeanFactory`, and also applying all bean post processors (including ones which might wrap the given raw bean).
    `void` | `copyConfigurationFrom(ConfigurableBeanFactory otherFactory)` Copy all relevant configuration from the given other factory.
    `Object` | `createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck)` Fully create a new bean instance of the given class with the specified autowire strategy.
    `<T> T` | `createBean(Class<T> beanClass)` 根据class对象创建bean Performs full initialization of the bean, including all applicable `BeanPostProcessors`.
    `protected Object` | `createBean(String beanName, RootBeanDefinition mbd, Object[] args)` Central method of this class: creates a bean instance, populates the bean instance, applies post-processors, etc.
    `protected BeanWrapper` | `createBeanInstance(String beanName, RootBeanDefinition mbd, Object[] args)` Create a new instance for the specified bean, using an appropriate instantiation strategy: factory method, constructor autowiring, or simple instantiation.
    `void` | `destroyBean(Object existingBean)` Destroy the given bean instance (typically coming from `AutowireCapableBeanFactory.createBean(java.lang.Class<T>)`), applying the `DisposableBean` contract as well as registered `DestructionAwareBeanPostProcessors`.
    `protected Constructor<?>[]` | `determineConstructorsFromBeanPostProcessors(Class<?> beanClass, String beanName)` 通过SmartInstantiationAwareBeanPostProcessor的后置处理器的determineCandidateConstructors来查找出对应的构造函数 `SmartInstantiationAwareBeanPostProcessors`
    `protected Class<?>` | `determineTargetType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)` Determine the target type for the given bean definition.
    `protected Object` | `doCreateBean(String beanName, RootBeanDefinition mbd, Object[] args)` 真的创建bean的逻辑,该方法是最复杂的包含了调用构造函数,给bean的属性赋值 调用bean的初始化操作以及 生成代理对象 都是在这里
    `protected PropertyDescriptor[]` | `filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw)` Extract a filtered set of PropertyDescriptors from the given BeanWrapper, excluding ignored dependency types or properties defined on ignored dependency interfaces.
    `protected PropertyDescriptor[]` | `filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw, boolean cache)` Extract a filtered set of PropertyDescriptors from the given BeanWrapper, excluding ignored dependency types or properties defined on ignored dependency interfaces.
    `protected Object` | `getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean)` 三级缓存通过函数接口回调方式（即不会立即缓存单例对象，而是等待调用时再返回） 这样做有什么好处呢？
    `protected InstantiationStrategy` | `getInstantiationStrategy()` Return the instantiation strategy to use for creating bean instances.
    `protected Object` | `getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd)` Overridden in order to implicitly register the currently created bean as dependent on further beans getting programmatically retrieved during a `Supplier` callback.
    `protected org.springframework.core.ParameterNameDiscoverer` | `getParameterNameDiscoverer()` Return the ParameterNameDiscoverer to use for resolving method parameter names if needed.
    `protected Class<?>` | `getTypeForFactoryBean(String beanName, RootBeanDefinition mbd)` This implementation attempts to query the FactoryBean's generic parameter metadata if present to determine the object type.
    `protected Class<?>` | `getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)` Determine the target type for the given bean definition which is based on a factory method.
    `void` | `ignoreDependencyInterface(Class<?> ifc)` Ignore the given dependency interface for autowiring.
    `void` | `ignoreDependencyType(Class<?> type)` Ignore the given dependency type for autowiring: for example, String.
    `Object` | `initializeBean(Object existingBean, String beanName)` Initialize the given raw bean, applying factory callbacks such as `setBeanName` and `setBeanFactory`, also applying all bean post processors (including ones which might wrap the given raw bean).
    `protected Object` | `initializeBean(String beanName, Object bean, RootBeanDefinition mbd)` Initialize the given bean instance, applying factory callbacks as well as init methods and bean post processors.
    `protected BeanWrapper` | `instantiateBean(String beanName, RootBeanDefinition mbd)` Instantiate the given bean using its default constructor.
    `protected BeanWrapper` | `instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, Object[] explicitArgs)` Instantiate the bean using a named factory method.
    `protected void` | `invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd)` Invoke the specified custom init method on the given bean.
    `protected void` | `invokeInitMethods(String beanName, Object bean, RootBeanDefinition mbd)` Give a bean a chance to react now all its properties are set, and a chance to know about its owning bean factory (this object).
    `protected boolean` | `isExcludedFromDependencyCheck(PropertyDescriptor pd)` Determine whether the given bean property is excluded from dependency checks.
    `protected BeanWrapper` | `obtainFromSupplier(Supplier<?> instanceSupplier, String beanName)` Obtain a bean instance from the given supplier.
    `protected void` | `populateBean(String beanName, RootBeanDefinition mbd, BeanWrapper bw)` 给我们的对象BeanWrapper赋值
    `protected Object` | `postProcessObjectFromFactoryBean(Object object, String beanName)` Applies the `postProcessAfterInitialization` callback of all registered BeanPostProcessors, giving them a chance to post-process the object obtained from FactoryBeans (for example, to auto-proxy them).
    `protected Class<?>` | `predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)` Predict the eventual bean type (of the processed bean instance) for the specified bean.
    `protected void` | `removeSingleton(String beanName)` Overridden to clear FactoryBean instance cache as well.
    `protected Object` | `resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)` Apply before-instantiation post-processors, resolving whether there is a before-instantiation shortcut for the specified bean.
    `Object` | `resolveDependency(DependencyDescriptor descriptor, String requestingBeanName)` Resolve the specified dependency against the beans defined in this factory.
    `void` | `setAllowCircularReferences(boolean allowCircularReferences)` Set whether to allow circular references between beans - and automatically try to resolve them.
    `void` | `setAllowRawInjectionDespiteWrapping(boolean allowRawInjectionDespiteWrapping)` Set whether to allow the raw injection of a bean instance into some other bean's property, despite the injected bean eventually getting wrapped (for example, through AOP auto-proxying).
    `void` | `setInstantiationStrategy(InstantiationStrategy instantiationStrategy)` Set the instantiation strategy to use for creating bean instances.
    `void` | `setParameterNameDiscoverer(org.springframework.core.ParameterNameDiscoverer parameterNameDiscoverer)` Set the ParameterNameDiscoverer to use for resolving method parameter names if needed (e.g. for constructor names).
    `protected String[]` | `unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw)` spring认为的简单属性 1.

    - ### 从类继承的方法 org.springframework.beans.factory.support.AbstractBeanFactory

      `addBeanPostProcessor, addEmbeddedValueResolver, addPropertyEditorRegistrar, afterPrototypeCreation, beforePrototypeCreation, checkMergedBeanDefinition, cleanupAfterBeanCreationFailure, clearMergedBeanDefinition, clearMetadataCache, containsBean, containsBeanDefinition, containsLocalBean, copyRegisteredEditorsTo, destroyBean, destroyBean, destroyScopedBean, doGetBean, evaluateBeanDefinitionString, getAccessControlContext, getAliases, getBean, getBean, getBean, getBean, getBeanClassLoader, getBeanDefinition, getBeanExpressionResolver, getBeanPostProcessorCount, getBeanPostProcessors, getConversionService, getCustomEditors, getCustomTypeConverter, getMergedBeanDefinition, getMergedBeanDefinition, getMergedBeanDefinition, getMergedLocalBeanDefinition, getParentBeanFactory, getPropertyEditorRegistrars, getRegisteredScope, getRegisteredScopeNames, getTempClassLoader, getType, getTypeConverter, hasBeanCreationStarted, hasDestructionAwareBeanPostProcessors, hasEmbeddedValueResolver, hasInstantiationAwareBeanPostProcessors, initBeanWrapper, isActuallyInCreation, isBeanEligibleForMetadataCaching, isBeanNameInUse, isCacheBeanMetadata, isFactoryBean, isFactoryBean, isPrototype, isPrototypeCurrentlyInCreation, isSingleton, isTypeMatch, isTypeMatch, markBeanAsCreated, originalBeanName, registerCustomEditor, registerCustomEditors, registerDisposableBeanIfNecessary, registerScope, removeSingletonIfCreatedForTypeCheckOnly, requiresDestruction, resolveBeanClass, resolveEmbeddedValue, setBeanClassLoader, setBeanExpressionResolver, setCacheBeanMetadata, setConversionService, setParentBeanFactory, setSecurityContextProvider, setTempClassLoader, setTypeConverter, transformedBeanName`

    - ### 从类继承的方法 org.springframework.beans.factory.support.FactoryBeanRegistrySupport

      `getCachedObjectForFactoryBean, getFactoryBean, getObjectFromFactoryBean, getTypeForFactoryBean`

    - ### 从类继承的方法 org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

      `addSingleton, addSingletonFactory, afterSingletonCreation, beforeSingletonCreation, containsSingleton, destroyBean, destroySingleton, destroySingletons, getDependenciesForBean, getDependentBeans, getSingleton, getSingleton, getSingleton, getSingletonCount, getSingletonMutex, getSingletonNames, hasDependentBean, isCurrentlyInCreation, isDependent, isSingletonCurrentlyInCreation, onSuppressedException, registerContainedBean, registerDependentBean, registerDisposableBean, registerSingleton, setCurrentlyInCreation`

    - ### 从类继承的方法 org.springframework.core.SimpleAliasRegistry

      `allowAliasOverriding, canonicalName, checkForAliasCircle, hasAlias, isAlias, registerAlias, removeAlias, resolveAliases`

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### 从接口继承的方法 org.springframework.beans.factory.config.AutowireCapableBeanFactory

      `resolveDependency, resolveNamedBean`

    - ### 从接口继承的方法 org.springframework.beans.factory.BeanFactory

      `containsBean, getAliases, getBean, getBean, getBean, getBean, getBean, getType, isPrototype, isSingleton, isTypeMatch, isTypeMatch`

    - ### 从接口继承的方法 org.springframework.beans.factory.config.ConfigurableBeanFactory

      `destroySingletons, getDependenciesForBean, getDependentBeans, isCurrentlyInCreation, registerAlias, registerDependentBean, resolveAliases, setCurrentlyInCreation`

    - ### 从接口继承的方法 org.springframework.beans.factory.config.SingletonBeanRegistry

      `containsSingleton, getSingleton, getSingletonCount, getSingletonMutex, getSingletonNames, registerSingleton`

- - ### 构造器详细资料

    - #### AbstractAutowireCapableBeanFactory

          public AbstractAutowireCapableBeanFactory()

      Create a new AbstractAutowireCapableBeanFactory.

    - #### AbstractAutowireCapableBeanFactory

          public AbstractAutowireCapableBeanFactory(@Nullable
                                                    BeanFactory parentBeanFactory)

      Create a new AbstractAutowireCapableBeanFactory with the given parent.
      参数:
        `parentBeanFactory` - parent bean factory, or `null` if none

  - ### 方法详细资料

    - #### setInstantiationStrategy

          public void setInstantiationStrategy(InstantiationStrategy instantiationStrategy)

      Set the instantiation strategy to use for creating bean instances. Default is CglibSubclassingInstantiationStrategy.
      另请参阅:
        `CglibSubclassingInstantiationStrategy`

    - #### getInstantiationStrategy

          protected InstantiationStrategy getInstantiationStrategy()

      Return the instantiation strategy to use for creating bean instances.

    - #### setParameterNameDiscoverer

          public void setParameterNameDiscoverer(@Nullable
                                                 org.springframework.core.ParameterNameDiscoverer parameterNameDiscoverer)

      Set the ParameterNameDiscoverer to use for resolving method parameter names if needed (e.g. for constructor names).

      Default is a `DefaultParameterNameDiscoverer`.

    - #### getParameterNameDiscoverer

          @Nullable
          protected org.springframework.core.ParameterNameDiscoverer getParameterNameDiscoverer()

      Return the ParameterNameDiscoverer to use for resolving method parameter names if needed.

    - #### setAllowCircularReferences

          public void setAllowCircularReferences(boolean allowCircularReferences)

      Set whether to allow circular references between beans - and automatically try to resolve them.

      Note that circular reference resolution means that one of the involved beans will receive a reference to another bean that is not fully initialized yet. This can lead to subtle and not-so-subtle side effects on initialization; it does work fine for many scenarios, though.

      Default is "true". Turn this off to throw an exception when encountering a circular reference, disallowing them completely.

      NOTE: It is generally recommended to not rely on circular references between your beans. Refactor your application logic to have the two beans involved delegate to a third bean that encapsulates their common logic.

    - #### setAllowRawInjectionDespiteWrapping

          public void setAllowRawInjectionDespiteWrapping(boolean allowRawInjectionDespiteWrapping)

      Set whether to allow the raw injection of a bean instance into some other bean's property, despite the injected bean eventually getting wrapped (for example, through AOP auto-proxying).

      This will only be used as a last resort in case of a circular reference that cannot be resolved otherwise: essentially, preferring a raw instance getting injected over a failure of the entire bean wiring process.

      Default is "false", as of Spring 2.0. Turn this on to allow for non-wrapped raw beans injected into some of your references, which was Spring 1.2's (arguably unclean) default behavior.

      NOTE: It is generally recommended to not rely on circular references between your beans, in particular with auto-proxying involved.

      另请参阅:
        `setAllowCircularReferences(boolean)`

    - #### ignoreDependencyType

          public void ignoreDependencyType(Class<?> type)

      Ignore the given dependency type for autowiring: for example, String. Default is none.

    - #### ignoreDependencyInterface

          public void ignoreDependencyInterface(Class<?> ifc)

      Ignore the given dependency interface for autowiring.

      This will typically be used by application contexts to register dependencies that are resolved in other ways, like BeanFactory through BeanFactoryAware or ApplicationContext through ApplicationContextAware.

      By default, only the BeanFactoryAware interface is ignored. For further types to ignore, invoke this method for each type.

      另请参阅:
        `BeanFactoryAware`

    - #### copyConfigurationFrom

          public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory)

      从接口复制的说明: `ConfigurableBeanFactory`
      Copy all relevant configuration from the given other factory.

      Should include all standard configuration settings as well as BeanPostProcessors, Scopes, and factory-specific internal settings. Should not include any metadata of actual bean definitions, such as BeanDefinition objects and bean name aliases.

      指定者:
        `copyConfigurationFrom` 在接口中 `ConfigurableBeanFactory`
      覆盖:
        `copyConfigurationFrom` 在类中 `AbstractBeanFactory`
      参数:
        `otherFactory` - the other BeanFactory to copy from

    - #### createBean

          public <T> T createBean(Class<T> beanClass)
                           throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      根据class对象创建bean

      Performs full initialization of the bean, including all applicable `BeanPostProcessors`.

      Note: This is intended for creating a fresh instance, populating annotated fields and methods as well as applying all standard bean initialization callbacks. It does not imply traditional by-name or by-type autowiring of properties; use `AutowireCapableBeanFactory.createBean(Class, int, boolean)` for those purposes.

      指定者:
        `createBean` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `beanClass` - the class of the bean to create
      返回:
        the new bean instance
      抛出:
        `BeansException` - if instantiation or wiring failed

    - #### autowireBean

          public void autowireBean(Object existingBean)

      从接口复制的说明: `AutowireCapableBeanFactory`
      Populate the given bean instance through applying after-instantiation callbacks and bean property post-processing (e.g. for annotation-driven injection).

      Note: This is essentially intended for (re-)populating annotated fields and methods, either for new instances or for deserialized instances. It does not imply traditional by-name or by-type autowiring of properties; use `AutowireCapableBeanFactory.autowireBeanProperties(java.lang.Object, int, boolean)` for those purposes.

      指定者:
        `autowireBean` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance

    - #### configureBean

          public Object configureBean(Object existingBean,
                                      String beanName)
                               throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Configure the given raw bean: autowiring bean properties, applying bean property values, applying factory callbacks such as `setBeanName` and `setBeanFactory`, and also applying all bean post processors (including ones which might wrap the given raw bean).

      This is effectively a superset of what `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)` provides, fully applying the configuration specified by the corresponding bean definition. Note: This method requires a bean definition for the given name!

      指定者:
        `configureBean` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance
        `beanName` - the name of the bean, to be passed to it if necessary (a bean definition of that name has to be available)
      返回:
        the bean instance to use, either the original or a wrapped one
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean definition with the given name
        `BeansException` - if the initialization failed
      另请参阅:
        `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)`

    - #### resolveDependency

          @Nullable
          public Object resolveDependency(DependencyDescriptor descriptor,
                                                     @Nullable
                                                     String requestingBeanName)
                                              throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Resolve the specified dependency against the beans defined in this factory.
      指定者:
        `resolveDependency` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `descriptor` - the descriptor for the dependency (field/method/constructor)
        `requestingBeanName` - the name of the bean which declares the given dependency
      返回:
        the resolved object, or `null` if none found
      抛出:
        `NoSuchBeanDefinitionException` - if no matching bean was found
        `NoUniqueBeanDefinitionException` - if more than one matching bean was found
        `BeansException` - if dependency resolution failed for any other reason
      另请参阅:
        `AutowireCapableBeanFactory.resolveDependency(DependencyDescriptor, String, Set, TypeConverter)`

    - #### createBean

          public Object createBean(Class<?> beanClass,
                                   int autowireMode,
                                   boolean dependencyCheck)
                            throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Fully create a new bean instance of the given class with the specified autowire strategy. All constants defined in this interface are supported here.

      Performs full initialization of the bean, including all applicable `BeanPostProcessors`. This is effectively a superset of what `AutowireCapableBeanFactory.autowire(java.lang.Class<?>, int, boolean)` provides, adding `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)` behavior.

      指定者:
        `createBean` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `beanClass` - the class of the bean to create
        `autowireMode` - by name or type, using the constants in this interface
        `dependencyCheck` - whether to perform a dependency check for objects (not applicable to autowiring a constructor, thus ignored there)
      返回:
        the new bean instance
      抛出:
        `BeansException` - if instantiation or wiring failed
      另请参阅:
        `AutowireCapableBeanFactory.AUTOWIRE_NO`, `AutowireCapableBeanFactory.AUTOWIRE_BY_NAME`, `AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE`, `AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR`

    - #### autowire

          public Object autowire(Class<?> beanClass,
                                 int autowireMode,
                                 boolean dependencyCheck)
                          throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Instantiate a new bean instance of the given class with the specified autowire strategy. All constants defined in this interface are supported here. Can also be invoked with `AUTOWIRE_NO` in order to just apply before-instantiation callbacks (e.g. for annotation-driven injection).

      Does not apply standard `BeanPostProcessors` callbacks or perform any further initialization of the bean. This interface offers distinct, fine-grained operations for those purposes, for example `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)`. However, `InstantiationAwareBeanPostProcessor` callbacks are applied, if applicable to the construction of the instance.

      指定者:
        `autowire` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `beanClass` - the class of the bean to instantiate
        `autowireMode` - by name or type, using the constants in this interface
        `dependencyCheck` - whether to perform a dependency check for object references in the bean instance (not applicable to autowiring a constructor, thus ignored there)
      返回:
        the new bean instance
      抛出:
        `BeansException` - if instantiation or wiring failed
      另请参阅:
        `AutowireCapableBeanFactory.AUTOWIRE_NO`, `AutowireCapableBeanFactory.AUTOWIRE_BY_NAME`, `AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE`, `AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR`, `AutowireCapableBeanFactory.AUTOWIRE_AUTODETECT`, `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)`, `AutowireCapableBeanFactory.applyBeanPostProcessorsBeforeInitialization(java.lang.Object, java.lang.String)`, `AutowireCapableBeanFactory.applyBeanPostProcessorsAfterInitialization(java.lang.Object, java.lang.String)`

    - #### autowireBeanProperties

          public void autowireBeanProperties(Object existingBean,
                                             int autowireMode,
                                             boolean dependencyCheck)
                                      throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Autowire the bean properties of the given bean instance by name or type. Can also be invoked with `AUTOWIRE_NO` in order to just apply after-instantiation callbacks (e.g. for annotation-driven injection).

      Does not apply standard `BeanPostProcessors` callbacks or perform any further initialization of the bean. This interface offers distinct, fine-grained operations for those purposes, for example `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)`. However, `InstantiationAwareBeanPostProcessor` callbacks are applied, if applicable to the configuration of the instance.

      指定者:
        `autowireBeanProperties` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance
        `autowireMode` - by name or type, using the constants in this interface
        `dependencyCheck` - whether to perform a dependency check for object references in the bean instance
      抛出:
        `BeansException` - if wiring failed
      另请参阅:
        `AutowireCapableBeanFactory.AUTOWIRE_BY_NAME`, `AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE`, `AutowireCapableBeanFactory.AUTOWIRE_NO`

    - #### applyBeanPropertyValues

          public void applyBeanPropertyValues(Object existingBean,
                                              String beanName)
                                       throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Apply the property values of the bean definition with the given name to the given bean instance. The bean definition can either define a fully self-contained bean, reusing its property values, or just property values meant to be used for existing bean instances.

      This method does not autowire bean properties; it just applies explicitly defined property values. Use the `AutowireCapableBeanFactory.autowireBeanProperties(java.lang.Object, int, boolean)` method to autowire an existing bean instance. Note: This method requires a bean definition for the given name!

      Does not apply standard `BeanPostProcessors` callbacks or perform any further initialization of the bean. This interface offers distinct, fine-grained operations for those purposes, for example `AutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)`. However, `InstantiationAwareBeanPostProcessor` callbacks are applied, if applicable to the configuration of the instance.

      指定者:
        `applyBeanPropertyValues` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance
        `beanName` - the name of the bean definition in the bean factory (a bean definition of that name has to be available)
      抛出:
        `NoSuchBeanDefinitionException` - if there is no bean definition with the given name
        `BeansException` - if applying the property values failed
      另请参阅:
        `AutowireCapableBeanFactory.autowireBeanProperties(java.lang.Object, int, boolean)`

    - #### initializeBean

          public Object initializeBean(Object existingBean,
                                       String beanName)

      从接口复制的说明: `AutowireCapableBeanFactory`
      Initialize the given raw bean, applying factory callbacks such as `setBeanName` and `setBeanFactory`, also applying all bean post processors (including ones which might wrap the given raw bean).

      Note that no bean definition of the given name has to exist in the bean factory. The passed-in bean name will simply be used for callbacks but not checked against the registered bean definitions.

      指定者:
        `initializeBean` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance
        `beanName` - the name of the bean, to be passed to it if necessary (only passed to `BeanPostProcessors`)
      返回:
        the bean instance to use, either the original or a wrapped one

    - #### applyBeanPostProcessorsBeforeInitialization

          public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean,
                                                                    String beanName)
                                                             throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessBeforeInitialization` methods. The returned bean instance may be a wrapper around the original.
      指定者:
        `applyBeanPostProcessorsBeforeInitialization` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance
        `beanName` - the name of the bean, to be passed to it if necessary (only passed to `BeanPostProcessors`)
      返回:
        the bean instance to use, either the original or a wrapped one
      抛出:
        `BeansException` - if any post-processing failed
      另请参阅:
        `BeanPostProcessor.postProcessBeforeInitialization(java.lang.Object, java.lang.String)`

    - #### applyBeanPostProcessorsAfterInitialization

          public Object applyBeanPostProcessorsAfterInitialization(Object existingBean,
                                                                   String beanName)
                                                            throws BeansException

      从接口复制的说明: `AutowireCapableBeanFactory`
      Apply `BeanPostProcessors` to the given existing bean instance, invoking their `postProcessAfterInitialization` methods. The returned bean instance may be a wrapper around the original.
      指定者:
        `applyBeanPostProcessorsAfterInitialization` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the existing bean instance
        `beanName` - the name of the bean, to be passed to it if necessary (only passed to `BeanPostProcessors`)
      返回:
        the bean instance to use, either the original or a wrapped one
      抛出:
        `BeansException` - if any post-processing failed
      另请参阅:
        `BeanPostProcessor.postProcessAfterInitialization(java.lang.Object, java.lang.String)`

    - #### destroyBean

          public void destroyBean(Object existingBean)

      从接口复制的说明: `AutowireCapableBeanFactory`
      Destroy the given bean instance (typically coming from `AutowireCapableBeanFactory.createBean(java.lang.Class<T>)`), applying the `DisposableBean` contract as well as registered `DestructionAwareBeanPostProcessors`.

      Any exception that arises during destruction should be caught and logged instead of propagated to the caller of this method.

      指定者:
        `destroyBean` 在接口中 `AutowireCapableBeanFactory`
      参数:
        `existingBean` - the bean instance to destroy

    - #### createBean

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

      Central method of this class: creates a bean instance, populates the bean instance, applies post-processors, etc.
      指定者:
        `createBean` 在类中 `AbstractBeanFactory`
      参数:
        `beanName` - bean的名称
        `mbd` - 已经合并了父类属性的（如果有的话）BeanDefinition 对象。
        `args` - 用于构造函数或者工厂方法创建 Bean 实例对象的参数。
      返回:
        返回一个单实例bean
      抛出:
        `BeanCreationException`
      另请参阅:
        `doCreateBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])`

    - #### doCreateBean

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

      真的创建bean的逻辑,该方法是最复杂的包含了调用构造函数,给bean的属性赋值 调用bean的初始化操作以及 生成代理对象 都是在这里
      参数:
        `beanName` - bean的名称
        `mbd` - bean的定义
        `args` - 传入的参数
      返回:
        bean的实例
      抛出:
        `BeanCreationException` - if the bean could not be created
      另请参阅:
        `instantiateBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition)`, `instantiateUsingFactoryMethod(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])`, `autowireConstructor(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.reflect.Constructor<?>[], java.lang.Object[])`

    - #### predictBeanType

          @Nullable
          protected Class<?> predictBeanType(String beanName,
                                                        RootBeanDefinition mbd,
                                                        Class<?>... typesToMatch)

      从类复制的说明: `AbstractBeanFactory`
      Predict the eventual bean type (of the processed bean instance) for the specified bean. Called by `AbstractBeanFactory.getType(java.lang.String)` and `AbstractBeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)`. Does not need to handle FactoryBeans specifically, since it is only supposed to operate on the raw bean type.

      This implementation is simplistic in that it is not able to handle factory methods and InstantiationAwareBeanPostProcessors. It only predicts the bean type correctly for a standard bean. To be overridden in subclasses, applying more sophisticated type detection.

      覆盖:
        `predictBeanType` 在类中 `AbstractBeanFactory`
      参数:
        `beanName` - the name of the bean
        `mbd` - the merged bean definition to determine the type for
        `typesToMatch` - the types to match in case of internal type matching purposes (also signals that the returned `Class` will never be exposed to application code)
      返回:
        the type of the bean, or `null` if not predictable

    - #### determineTargetType

          @Nullable
          protected Class<?> determineTargetType(String beanName,
                                                            RootBeanDefinition mbd,
                                                            Class<?>... typesToMatch)

      Determine the target type for the given bean definition.
      参数:
        `beanName` - the name of the bean (for error handling purposes)
        `mbd` - the merged bean definition for the bean
        `typesToMatch` - the types to match in case of internal type matching purposes (also signals that the returned `Class` will never be exposed to application code)
      返回:
        the type for the bean if determinable, or `null` otherwise

    - #### getTypeForFactoryMethod

          @Nullable
          protected Class<?> getTypeForFactoryMethod(String beanName,
                                                                RootBeanDefinition mbd,
                                                                Class<?>... typesToMatch)

      Determine the target type for the given bean definition which is based on a factory method. Only called if there is no singleton instance registered for the target bean already.

      This implementation determines the type matching `createBean(java.lang.Class<T>)`'s different creation strategies. As far as possible, we'll perform static type checking to avoid creation of the target bean.

      参数:
        `beanName` - the name of the bean (for error handling purposes)
        `mbd` - the merged bean definition for the bean
        `typesToMatch` - the types to match in case of internal type matching purposes (also signals that the returned `Class` will never be exposed to application code)
      返回:
        the type for the bean if determinable, or `null` otherwise
      另请参阅:
        `createBean(java.lang.Class<T>)`

    - #### getTypeForFactoryBean

          @Nullable
          protected Class<?> getTypeForFactoryBean(String beanName,
                                                              RootBeanDefinition mbd)

      This implementation attempts to query the FactoryBean's generic parameter metadata if present to determine the object type. If not present, i.e. the FactoryBean is declared as a raw type, checks the FactoryBean's `getObjectType` method on a plain instance of the FactoryBean, without bean properties applied yet. If this doesn't return a type yet, a full creation of the FactoryBean is used as fallback (through delegation to the superclass's implementation).

      The shortcut check for a FactoryBean is only applied in case of a singleton FactoryBean. If the FactoryBean instance itself is not kept as singleton, it will be fully created to check the type of its exposed object.

      覆盖:
        `getTypeForFactoryBean` 在类中 `AbstractBeanFactory`
      参数:
        `beanName` - the name of the bean
        `mbd` - the merged bean definition for the bean
      返回:
        the type for the bean if determinable, or `null` otherwise
      另请参阅:
        `FactoryBean.getObjectType()`, `AbstractBeanFactory.getBean(String)`

    - #### getEarlyBeanReference

          protected Object getEarlyBeanReference(String beanName,
                                                 RootBeanDefinition mbd,
                                                 Object bean)

      三级缓存通过函数接口回调方式（即不会立即缓存单例对象，而是等待调用时再返回） 这样做有什么好处呢？ 1：延迟获取，提高性能： 因为并不是所有的Bean都存在循环引用（不需要所有单例都缓存起来等待循环依赖调用）， 所以当真正调用时再缓存该单例到二级缓存。 2：提高扩展性：这是spring一贯作风，采用bean的后置处理器方式可以提高扩展性（如代理操作等..） 3：aop的考虑：如果依赖的bean是代理类，那么将代理创建的方法作为回调方法。
      参数:
        `beanName` - the name of the bean (for error handling purposes)
        `mbd` - the merged bean definition for the bean
        `bean` - the raw bean instance
      返回:
        the object to expose as bean reference

    - #### applyMergedBeanDefinitionPostProcessors

          protected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd,
                                                                 Class<?> beanType,
                                                                 String beanName)

      Apply MergedBeanDefinitionPostProcessors to the specified bean definition, invoking their `postProcessMergedBeanDefinition` methods.
      参数:
        `mbd` - the merged bean definition for the bean
        `beanType` - the actual type of the managed bean instance
        `beanName` - the name of the bean
      另请参阅:
        `MergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Class<?>, java.lang.String)`

    - #### resolveBeforeInstantiation

          @Nullable
          protected Object resolveBeforeInstantiation(String beanName,
                                                                 RootBeanDefinition mbd)

      Apply before-instantiation post-processors, resolving whether there is a before-instantiation shortcut for the specified bean.
      参数:
        `beanName` - the name of the bean
        `mbd` - the bean definition for the bean
      返回:
        the shortcut-determined bean instance, or `null` if none

    - #### applyBeanPostProcessorsBeforeInstantiation

          @Nullable
          protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass,
                                                                                 String beanName)

      Apply InstantiationAwareBeanPostProcessors to the specified bean definition (by class and name), invoking their `postProcessBeforeInstantiation` methods.

      Any returned object will be used as the bean instead of actually instantiating the target bean. A `null` return value from the post-processor will result in the target bean being instantiated.

      参数:
        `beanClass` - the class of the bean to be instantiated
        `beanName` - the name of the bean
      返回:
        the bean object to use instead of a default instance of the target bean, or `null`
      另请参阅:
        `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)`

    - #### createBeanInstance

          protected BeanWrapper createBeanInstance(String beanName,
                                                   RootBeanDefinition mbd,
                                                   @Nullable
                                                   Object[] args)

      Create a new instance for the specified bean, using an appropriate instantiation strategy: factory method, constructor autowiring, or simple instantiation.
      参数:
        `beanName` - the name of the bean
        `mbd` - the bean definition for the bean
        `args` - explicit arguments to use for constructor or factory method invocation
      返回:
        a BeanWrapper for the new instance
      另请参阅:
        `obtainFromSupplier(java.util.function.Supplier<?>, java.lang.String)`, `instantiateUsingFactoryMethod(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])`, `autowireConstructor(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.reflect.Constructor<?>[], java.lang.Object[])`, `instantiateBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition)`

    - #### obtainFromSupplier

          protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier,
                                                   String beanName)

      Obtain a bean instance from the given supplier.
      参数:
        `instanceSupplier` - the configured supplier
        `beanName` - the corresponding bean name
      返回:
        a BeanWrapper for the new instance
      从以下版本开始:
        5.0
      另请参阅:
        `getObjectForBeanInstance(java.lang.Object, java.lang.String, java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition)`

    - #### getObjectForBeanInstance

          protected Object getObjectForBeanInstance(Object beanInstance,
                                                    String name,
                                                    String beanName,
                                                    @Nullable
                                                    RootBeanDefinition mbd)

      Overridden in order to implicitly register the currently created bean as dependent on further beans getting programmatically retrieved during a `Supplier` callback.
      覆盖:
        `getObjectForBeanInstance` 在类中 `AbstractBeanFactory`
      参数:
        `beanInstance` - the shared bean instance
        `name` - name that may include factory dereference prefix
        `beanName` - the canonical bean name
        `mbd` - the merged bean definition
      返回:
        the object to expose for the bean
      从以下版本开始:
        5.0
      另请参阅:
        `obtainFromSupplier(java.util.function.Supplier<?>, java.lang.String)`

    - #### determineConstructorsFromBeanPostProcessors

          @Nullable
          protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable
                                                                                            Class<?> beanClass,
                                                                                            String beanName)
                                                                                     throws BeansException

      通过SmartInstantiationAwareBeanPostProcessor的后置处理器的determineCandidateConstructors来查找出对应的构造函数 `SmartInstantiationAwareBeanPostProcessors`. { ConfigurationCLassPostProcessor$ImportAwareBeanPostProcessor AutoWiredAnnotationBeanPostProceesor(处理@AutoWired规范的后置处理器) }
      参数:
        `beanClass` - 当前bean的class对象
        `beanName` - 当前bean的名称
      返回:
        the candidate constructors,返回一个候选的构造函数或者是null
      抛出:
        `BeansException` - in case of errors
      另请参阅:
        `SmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(java.lang.Class<?>, java.lang.String)`

    - #### instantiateBean

          protected BeanWrapper instantiateBean(String beanName,
                                                RootBeanDefinition mbd)

      Instantiate the given bean using its default constructor.
      参数:
        `beanName` - the name of the bean
        `mbd` - the bean definition for the bean
      返回:
        a BeanWrapper for the new instance

    - #### instantiateUsingFactoryMethod

          protected BeanWrapper instantiateUsingFactoryMethod(String beanName,
                                                              RootBeanDefinition mbd,
                                                              @Nullable
                                                              Object[] explicitArgs)

      Instantiate the bean using a named factory method. The method may be static, if the mbd parameter specifies a class, rather than a factoryBean, or an instance variable on a factory object itself configured using Dependency Injection.
      参数:
        `beanName` - the name of the bean
        `mbd` - the bean definition for the bean
        `explicitArgs` - argument values passed in programmatically via the getBean method, or `null` if none (-> use constructor argument values from bean definition)
      返回:
        a BeanWrapper for the new instance
      另请参阅:
        `AbstractBeanFactory.getBean(String, Object[])`

    - #### autowireConstructor

          protected BeanWrapper autowireConstructor(String beanName,
                                                    RootBeanDefinition mbd,
                                                    @Nullable
                                                    Constructor<?>[] ctors,
                                                    @Nullable
                                                    Object[] explicitArgs)

      "autowire constructor" (with constructor arguments by type) behavior. Also applied if explicit constructor argument values are specified, matching all remaining arguments with beans from the bean factory.

      This corresponds to constructor injection: In this mode, a Spring bean factory is able to host components that expect constructor-based dependency resolution.

      参数:
        `beanName` - the name of the bean
        `mbd` - the bean definition for the bean
        `ctors` - the chosen candidate constructors
        `explicitArgs` - argument values passed in programmatically via the getBean method, or `null` if none (-> use constructor argument values from bean definition)
      返回:
        a BeanWrapper for the new instance

    - #### populateBean

          protected void populateBean(String beanName,
                                      RootBeanDefinition mbd,
                                      @Nullable
                                      BeanWrapper bw)

      给我们的对象BeanWrapper赋值
      参数:
        `beanName` - bean的名称
        `mbd` - bean的定义
        `bw` - bean实例包装对象

    - #### autowireByName

          protected void autowireByName(String beanName,
                                        AbstractBeanDefinition mbd,
                                        BeanWrapper bw,
                                        MutablePropertyValues pvs)

      Fill in any missing property values with references to other beans in this factory if autowire is set to "byName".
      参数:
        `beanName` - the name of the bean we're wiring up. Useful for debugging messages; not used functionally.
        `mbd` - bean definition to update through autowiring
        `bw` - the BeanWrapper from which we can obtain information about the bean
        `pvs` - the PropertyValues to register wired objects with

    - #### autowireByType

          protected void autowireByType(String beanName,
                                        AbstractBeanDefinition mbd,
                                        BeanWrapper bw,
                                        MutablePropertyValues pvs)

      Abstract method defining "autowire by type" (bean properties by type) behavior.

      This is like PicoContainer default, in which there must be exactly one bean of the property type in the bean factory. This makes bean factories simple to configure for small namespaces, but doesn't work as well as standard Spring behavior for bigger applications.

      参数:
        `beanName` - the name of the bean to autowire by type
        `mbd` - the merged bean definition to update through autowiring
        `bw` - the BeanWrapper from which we can obtain information about the bean
        `pvs` - the PropertyValues to register wired objects with

    - #### unsatisfiedNonSimpleProperties

          protected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd,
                                                            BeanWrapper bw)

      spring认为的简单属性 1. CharSequence 接口的实现类，比如 String 2. Enum 3. Date 4. URI/URL 5. Number 的继承类，比如 Integer/Long 6. byte/short/int... 等基本类型 7. Locale 8. 以上所有类型的数组形式，比如 String[]、Date[]、int[] 等等 不包含在当前bean的配置文件的中属性 !pvs.contains(pd.getName()

    - #### filterPropertyDescriptorsForDependencyCheck

          protected PropertyDescriptor[] filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw,
                                                                                     boolean cache)

      Extract a filtered set of PropertyDescriptors from the given BeanWrapper, excluding ignored dependency types or properties defined on ignored dependency interfaces.
      参数:
        `bw` - the BeanWrapper the bean was created with
        `cache` - whether to cache filtered PropertyDescriptors for the given bean Class
      返回:
        the filtered PropertyDescriptors
      另请参阅:
        `isExcludedFromDependencyCheck(java.beans.PropertyDescriptor)`, `filterPropertyDescriptorsForDependencyCheck(org.springframework.beans.BeanWrapper)`

    - #### filterPropertyDescriptorsForDependencyCheck

          protected PropertyDescriptor[] filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw)

      Extract a filtered set of PropertyDescriptors from the given BeanWrapper, excluding ignored dependency types or properties defined on ignored dependency interfaces.
      参数:
        `bw` - the BeanWrapper the bean was created with
      返回:
        the filtered PropertyDescriptors
      另请参阅:
        `isExcludedFromDependencyCheck(java.beans.PropertyDescriptor)`

    - #### isExcludedFromDependencyCheck

          protected boolean isExcludedFromDependencyCheck(PropertyDescriptor pd)

      Determine whether the given bean property is excluded from dependency checks.

      This implementation excludes properties defined by CGLIB and properties whose type matches an ignored dependency type or which are defined by an ignored dependency interface.

      参数:
        `pd` - the PropertyDescriptor of the bean property
      返回:
        whether the bean property is excluded
      另请参阅:
        `ignoreDependencyType(Class)`, `ignoreDependencyInterface(Class)`

    - #### checkDependencies

          protected void checkDependencies(String beanName,
                                           AbstractBeanDefinition mbd,
                                           PropertyDescriptor[] pds,
                                           PropertyValues pvs)
                                    throws UnsatisfiedDependencyException

      Perform a dependency check that all properties exposed have been set, if desired. Dependency checks can be objects (collaborating beans), simple (primitives and String), or all (both).
      参数:
        `beanName` - the name of the bean
        `mbd` - the merged bean definition the bean was created with
        `pds` - the relevant property descriptors for the target bean
        `pvs` - the property values to be applied to the bean
      抛出:
        `UnsatisfiedDependencyException`
      另请参阅:
        `isExcludedFromDependencyCheck(java.beans.PropertyDescriptor)`

    - #### applyPropertyValues

          protected void applyPropertyValues(String beanName,
                                             BeanDefinition mbd,
                                             BeanWrapper bw,
                                             PropertyValues pvs)

      Apply the given property values, resolving any runtime references to other beans in this bean factory. Must use deep copy, so we don't permanently modify this property.
      参数:
        `beanName` - the bean name passed for better exception information
        `mbd` - the merged bean definition
        `bw` - the BeanWrapper wrapping the target object
        `pvs` - the new property values

    - #### initializeBean

          protected Object initializeBean(String beanName,
                                          Object bean,
                                          @Nullable
                                          RootBeanDefinition mbd)

      Initialize the given bean instance, applying factory callbacks as well as init methods and bean post processors.

      Called from `createBean(java.lang.Class<T>)` for traditionally defined beans, and from `initializeBean(java.lang.Object, java.lang.String)` for existing bean instances.

      参数:
        `beanName` - the bean name in the factory (for debugging purposes)
        `bean` - the new bean instance we may need to initialize
        `mbd` - the bean definition that the bean was created with (can also be `null`, if given an existing bean instance)
      返回:
        the initialized bean instance (potentially wrapped)
      另请参阅:
        `BeanNameAware`, `BeanClassLoaderAware`, `BeanFactoryAware`, `applyBeanPostProcessorsBeforeInitialization(java.lang.Object, java.lang.String)`, `invokeInitMethods(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)`, `applyBeanPostProcessorsAfterInitialization(java.lang.Object, java.lang.String)`

    - #### invokeInitMethods

          protected void invokeInitMethods(String beanName,
                                           Object bean,
                                           @Nullable
                                           RootBeanDefinition mbd)
                                    throws Throwable

      Give a bean a chance to react now all its properties are set, and a chance to know about its owning bean factory (this object). This means checking whether the bean implements InitializingBean or defines a custom init method, and invoking the necessary callback(s) if it does.
      参数:
        `beanName` - the bean name in the factory (for debugging purposes)
        `bean` - the new bean instance we may need to initialize
        `mbd` - the merged bean definition that the bean was created with (can also be `null`, if given an existing bean instance)
      抛出:
        `Throwable` - if thrown by init methods or by the invocation process
      另请参阅:
        `invokeCustomInitMethod(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)`

    - #### invokeCustomInitMethod

          protected void invokeCustomInitMethod(String beanName,
                                                Object bean,
                                                RootBeanDefinition mbd)
                                         throws Throwable

      Invoke the specified custom init method on the given bean. Called by invokeInitMethods.

      Can be overridden in subclasses for custom resolution of init methods with arguments.

      抛出:
        `Throwable`
      另请参阅:
        `invokeInitMethods(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)`

    - #### postProcessObjectFromFactoryBean

          protected Object postProcessObjectFromFactoryBean(Object object,
                                                            String beanName)

      Applies the `postProcessAfterInitialization` callback of all registered BeanPostProcessors, giving them a chance to post-process the object obtained from FactoryBeans (for example, to auto-proxy them).
      覆盖:
        `postProcessObjectFromFactoryBean` 在类中 `FactoryBeanRegistrySupport`
      参数:
        `object` - the object obtained from the FactoryBean.
        `beanName` - the name of the bean
      返回:
        the object to expose
      另请参阅:
        `applyBeanPostProcessorsAfterInitialization(java.lang.Object, java.lang.String)`

    - #### removeSingleton

          protected void removeSingleton(String beanName)

      Overridden to clear FactoryBean instance cache as well.
      覆盖:
        `removeSingleton` 在类中 `FactoryBeanRegistrySupport`
      参数:
        `beanName` - the name of the bean
      另请参阅:
        `DefaultSingletonBeanRegistry.getSingletonMutex()`

    - #### clearSingletonCache

          protected void clearSingletonCache()

      Overridden to clear FactoryBean instance cache as well.
      覆盖:
        `clearSingletonCache` 在类中 `FactoryBeanRegistrySupport`