Package org.springframework.beans.factory.support

# Class AbstractBeanFactory

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

All Implemented Interfaces:
  `BeanFactory`, `ConfigurableBeanFactory`, `SingletonBeanRegistry`, `HierarchicalBeanFactory`, `org.springframework.core.AliasRegistry`

Direct Known Subclasses:
  `AbstractAutowireCapableBeanFactory`

public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory
Abstract base class for `BeanFactory` implementations, providing the full capabilities of the `ConfigurableBeanFactory` SPI. Does not assume a listable bean factory: can therefore also be used as base class for bean factory implementations which obtain bean definitions from some backend resource (where bean definition access is an expensive operation).

This class provides a singleton cache (through its base class `DefaultSingletonBeanRegistry`, singleton/prototype determination, `FactoryBean` handling, aliases, bean definition merging for child bean definitions, and bean destruction (`DisposableBean` interface, custom destroy methods). Furthermore, it can manage a bean factory hierarchy (delegating to the parent in case of an unknown bean), through implementing the `HierarchicalBeanFactory` interface.

The main template methods to be implemented by subclasses are `getBeanDefinition(java.lang.String)` and `createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])`, retrieving a bean definition for a given bean name and creating a bean instance for a given bean definition, respectively. Default implementations of those operations can be found in `DefaultListableBeanFactory` and `AbstractAutowireCapableBeanFactory`.

Since:
  15 April 2001
Author:
  Rod Johnson, Juergen Hoeller, Costin Leau, Chris Beams, Phillip Webb, Sam Brannen
See Also:
  - `getBeanDefinition(java.lang.String)`
  - `createBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])`
  - `AbstractAutowireCapableBeanFactory.createBean(java.lang.Class<T>)`
  - `DefaultListableBeanFactory.getBeanDefinition(java.lang.String)`

## Field Summary

### Fields inherited from class org.springframework.core.SimpleAliasRegistry

`logger`

### Fields inherited from interface org.springframework.beans.factory.BeanFactory

`FACTORY_BEAN_PREFIX, FACTORY_BEAN_PREFIX_CHAR`

### Fields inherited from interface org.springframework.beans.factory.config.ConfigurableBeanFactory

`SCOPE_PROTOTYPE, SCOPE_SINGLETON`

## Constructor Summary

Constructors
Constructor
Description
`AbstractBeanFactory()`
Create a new AbstractBeanFactory.
`AbstractBeanFactory(BeanFactory parentBeanFactory)`
Create a new AbstractBeanFactory with the given parent.

## Method Summary

Modifier and Type
Method
Description
`void`
`addBeanPostProcessor(BeanPostProcessor beanPostProcessor)`
Add a new BeanPostProcessor that will get applied to beans created by this factory.
`void`
`addBeanPostProcessors(Collection<? extends BeanPostProcessor> beanPostProcessors)`
Add new BeanPostProcessors that will get applied to beans created by this factory.
`void`
`addEmbeddedValueResolver(org.springframework.util.StringValueResolver valueResolver)`
Add a String resolver for embedded values such as annotation attributes.
`void`
`addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)`
Add a PropertyEditorRegistrar to be applied to all bean creation processes.
`protected void`
`afterPrototypeCreation(String beanName)`
Callback after prototype creation.
`protected void`
`beforePrototypeCreation(String beanName)`
Callback before prototype creation.
`protected void`
`cacheMergedBeanDefinition(RootBeanDefinition mbd, String beanName)`
Cache the given merged bean definition.
`protected void`
`checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, Object[] args)`
Check the given merged bean definition, potentially throwing validation exceptions.
`protected void`
`cleanupAfterBeanCreationFailure(String beanName)`
Perform appropriate cleanup of cached metadata after bean creation failed.
`protected void`
`clearMergedBeanDefinition(String beanName)`
Remove the merged bean definition for the specified bean, recreating it on next access.
`void`
`clearMetadataCache()`
Clear the merged bean definition cache, removing entries for beans which are not considered eligible for full metadata caching yet.
`boolean`
`containsBean(String name)`
Does this bean factory contain a bean definition or externally registered singleton instance with the given name?
`protected abstract boolean`
`containsBeanDefinition(String beanName)`
Check if this bean factory contains a bean definition with the given name.
`boolean`
`containsLocalBean(String name)`
Return whether the local bean factory contains a bean of the given name, ignoring beans defined in ancestor contexts.
`void`
`copyConfigurationFrom(ConfigurableBeanFactory otherFactory)`
Copy all relevant configuration from the given other factory.
`void`
`copyRegisteredEditorsTo(PropertyEditorRegistry registry)`
Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory.
`protected abstract Object`
`createBean(String beanName, RootBeanDefinition mbd, Object[] args)`
Create a bean instance for the given merged bean definition (and arguments).
`void`
`destroyBean(String beanName, Object beanInstance)`
Destroy the given bean instance (usually a prototype instance obtained from this factory) according to its bean definition.
`protected void`
`destroyBean(String beanName, Object bean, RootBeanDefinition mbd)`
Destroy the given bean instance (usually a prototype instance obtained from this factory) according to the given bean definition.
`void`
`destroyScopedBean(String beanName)`
Destroy the specified scoped bean in the current target scope, if any.
`protected <T> T`
`doGetBean(String name, Class<T> requiredType, Object[] args, boolean typeCheckOnly)`
Return an instance, which may be shared or independent, of the specified bean.
`protected Object`
`evaluateBeanDefinitionString(String value, BeanDefinition beanDefinition)`
Evaluate the given String as contained in a bean definition, potentially resolving it as an expression.
`String[]`
`getAliases(String name)`
Return the aliases for the given bean name, if any.
`org.springframework.core.metrics.ApplicationStartup`
`getApplicationStartup()`
Return the `ApplicationStartup` for this bean factory.
`Object`
`getBean(String name)`
Return an instance, which may be shared or independent, of the specified bean.
`<T> T`
`getBean(String name, Class<T> requiredType)`
Return an instance, which may be shared or independent, of the specified bean.
`<T> T`
`getBean(String name, Class<T> requiredType, Object... args)`
Return an instance, which may be shared or independent, of the specified bean.
`Object`
`getBean(String name, Object... args)`
Return an instance, which may be shared or independent, of the specified bean.
`ClassLoader`
`getBeanClassLoader()`
Return this factory's class loader for loading bean classes (only `null` if even the system ClassLoader isn't accessible).
`protected abstract BeanDefinition`
`getBeanDefinition(String beanName)`
Return the bean definition for the given bean name.
`BeanExpressionResolver`
`getBeanExpressionResolver()`
Return the resolution strategy for expressions in bean definition values.
`int`
`getBeanPostProcessorCount()`
Return the current number of registered BeanPostProcessors, if any.
`List<BeanPostProcessor>`
`getBeanPostProcessors()`
Return the list of BeanPostProcessors that will get applied to beans created with this factory.
`org.springframework.core.convert.ConversionService`
`getConversionService()`
Return the associated ConversionService, if any.
`Map<Class<?>,Class<? extends PropertyEditor>>`
`getCustomEditors()`
Return the map of custom editors, with Classes as keys and PropertyEditor classes as values.
`protected TypeConverter`
`getCustomTypeConverter()`
Return the custom TypeConverter to use, if any.
`BeanDefinition`
`getMergedBeanDefinition(String name)`
Return a 'merged' BeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.
`protected RootBeanDefinition`
`getMergedBeanDefinition(String beanName, BeanDefinition bd)`
Return a RootBeanDefinition for the given top-level bean, by merging with the parent if the given bean's definition is a child bean definition.
`protected RootBeanDefinition`
`getMergedBeanDefinition(String beanName, BeanDefinition bd, BeanDefinition containingBd)`
Return a RootBeanDefinition for the given bean, by merging with the parent if the given bean's definition is a child bean definition.
`protected RootBeanDefinition`
`getMergedLocalBeanDefinition(String beanName)`
Return a merged RootBeanDefinition, traversing the parent bean definition if the specified bean corresponds to a child bean definition.
`protected Object`
`getObjectForBeanInstance(Object beanInstance, String name, String beanName, RootBeanDefinition mbd)`
Get the object for the given bean instance, either the bean instance itself or its created object in case of a FactoryBean.
`BeanFactory`
`getParentBeanFactory()`
Return the parent bean factory, or `null` if there is none.
`Set<PropertyEditorRegistrar>`
`getPropertyEditorRegistrars()`
Return the set of PropertyEditorRegistrars.
`Scope`
`getRegisteredScope(String scopeName)`
Return the Scope implementation for the given scope name, if any.
`String[]`
`getRegisteredScopeNames()`
Return the names of all currently registered scopes.
`ClassLoader`
`getTempClassLoader()`
Return the temporary ClassLoader to use for type matching purposes, if any.
`Class<?>`
`getType(String name)`
Determine the type of the bean with the given name.
`Class<?>`
`getType(String name, boolean allowFactoryBeanInit)`
Determine the type of the bean with the given name.
`TypeConverter`
`getTypeConverter()`
Obtain a type converter as used by this BeanFactory.
`protected org.springframework.core.ResolvableType`
`getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit)`
Determine the bean type for the given FactoryBean definition, as far as possible.
`protected boolean`
`hasBeanCreationStarted()`
Check whether this factory's bean creation phase already started, i.e.
`protected boolean`
`hasDestructionAwareBeanPostProcessors()`
Return whether this factory holds a DestructionAwareBeanPostProcessor that will get applied to singleton beans on shutdown.
`boolean`
`hasEmbeddedValueResolver()`
Determine whether an embedded value resolver has been registered with this bean factory, to be applied through `ConfigurableBeanFactory.resolveEmbeddedValue(String)`.
`protected boolean`
`hasInstantiationAwareBeanPostProcessors()`
Return whether this factory holds a InstantiationAwareBeanPostProcessor that will get applied to singleton beans on creation.
`protected void`
`initBeanWrapper(BeanWrapper bw)`
Initialize the given BeanWrapper with the custom editors registered with this factory.
`boolean`
`isActuallyInCreation(String beanName)`
`protected boolean`
`isBeanEligibleForMetadataCaching(String beanName)`
Determine whether the specified bean is eligible for having its bean definition metadata cached.
`boolean`
`isBeanNameInUse(String beanName)`
Determine whether the given bean name is already in use within this factory, i.e.
`boolean`
`isCacheBeanMetadata()`
Return whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes.
`boolean`
`isFactoryBean(String name)`
Determine whether the bean with the given name is a FactoryBean.
`protected boolean`
`isFactoryBean(String beanName, RootBeanDefinition mbd)`
Check whether the given bean is defined as a `FactoryBean`.
`boolean`
`isPrototype(String name)`
Is this bean a prototype? That is, will `BeanFactory.getBean(java.lang.String)` always return independent instances?
`protected boolean`
`isPrototypeCurrentlyInCreation(String beanName)`
Return whether the specified prototype bean is currently in creation (within the current thread).
`boolean`
`isSingleton(String name)`
Is this bean a shared singleton? That is, will `BeanFactory.getBean(java.lang.String)` always return the same instance?
`boolean`
`isTypeMatch(String name, Class<?> typeToMatch)`
Check whether the bean with the given name matches the specified type.
`boolean`
`isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch)`
Check whether the bean with the given name matches the specified type.
`protected boolean`
`isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch, boolean allowFactoryBeanInit)`
Internal extended variant of `isTypeMatch(String, ResolvableType)` to check whether the bean with the given name matches the specified type.
`protected void`
`markBeanAsCreated(String beanName)`
Mark the specified bean as already created (or about to be created).
`protected String`
`originalBeanName(String name)`
Determine the original bean name, resolving locally defined aliases to canonical names.
`protected Class<?>`
`predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)`
Predict the eventual bean type (of the processed bean instance) for the specified bean.
`void`
`registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass)`
Register the given custom property editor for all properties of the given type.
`protected void`
`registerCustomEditors(PropertyEditorRegistry registry)`
Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory.
`protected void`
`registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd)`
Add the given bean to the list of disposable beans in this factory, registering its DisposableBean interface and/or the given destroy method to be called on factory shutdown (if applicable).
`void`
`registerScope(String scopeName, Scope scope)`
Register the given scope, backed by the given Scope implementation.
`protected boolean`
`removeSingletonIfCreatedForTypeCheckOnly(String beanName)`
Remove the singleton instance (if any) for the given bean name, but only if it hasn't been used for other purposes than type checking.
`protected boolean`
`requiresDestruction(Object bean, RootBeanDefinition mbd)`
Determine whether the given bean requires destruction on shutdown.
`protected Class<?>`
`resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch)`
Resolve the bean class for the specified bean definition, resolving a bean class name into a Class reference (if necessary) and storing the resolved Class in the bean definition for further use.
`String`
`resolveEmbeddedValue(String value)`
Resolve the given embedded value, for example, an annotation attribute.
`void`
`setApplicationStartup(org.springframework.core.metrics.ApplicationStartup applicationStartup)`
Set the `ApplicationStartup` for this bean factory.
`void`
`setBeanClassLoader(ClassLoader beanClassLoader)`
Set the class loader to use for loading bean classes.
`void`
`setBeanExpressionResolver(BeanExpressionResolver resolver)`
Specify the resolution strategy for expressions in bean definition values.
`void`
`setCacheBeanMetadata(boolean cacheBeanMetadata)`
Set whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes.
`void`
`setConversionService(org.springframework.core.convert.ConversionService conversionService)`
Specify a `ConversionService` to use for converting property values, as an alternative to JavaBeans PropertyEditors.
`void`
`setParentBeanFactory(BeanFactory parentBeanFactory)`
Set the parent of this bean factory.
`void`
`setTempClassLoader(ClassLoader tempClassLoader)`
Specify a temporary ClassLoader to use for type matching purposes.
`void`
`setTypeConverter(TypeConverter typeConverter)`
Set a custom type converter that this BeanFactory should use for converting bean property values, constructor argument values, etc.
`protected String`
`transformedBeanName(String name)`
Return the bean name, stripping out the factory dereference prefix if necessary, and resolving aliases to canonical names.

### Methods inherited from class org.springframework.beans.factory.support.FactoryBeanRegistrySupport

`clearSingletonCache, getCachedObjectForFactoryBean, getFactoryBean, getObjectFromFactoryBean, getTypeForFactoryBean, postProcessObjectFromFactoryBean, removeSingleton`

### Methods inherited from class org.springframework.beans.factory.support.DefaultSingletonBeanRegistry

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

### Methods inherited from class org.springframework.core.SimpleAliasRegistry

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

### Methods inherited from class java.lang.Object

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

### Methods inherited from interface org.springframework.beans.factory.BeanFactory

`getBean, getBean, getBeanProvider, getBeanProvider`

### Methods inherited from interface org.springframework.beans.factory.config.ConfigurableBeanFactory

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

### Methods inherited from interface org.springframework.beans.factory.config.SingletonBeanRegistry

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

## Constructor Details

### AbstractBeanFactory

public AbstractBeanFactory()
Create a new AbstractBeanFactory.

### AbstractBeanFactory

public AbstractBeanFactory(@Nullable BeanFactory parentBeanFactory)
Create a new AbstractBeanFactory with the given parent.

Parameters:
  `parentBeanFactory` - parent bean factory, or `null` if none
See Also:
  - `getBean(java.lang.String)`

## Method Details

### getBean

public Object getBean(String name) throws BeansException
Description copied from interface: `BeanFactory`
Return an instance, which may be shared or independent, of the specified bean.

This method allows a Spring BeanFactory to be used as a replacement for the Singleton or Prototype design pattern. Callers may retain references to returned objects in the case of Singleton beans.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `getBean` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to retrieve
Returns:
  an instance of the bean. Note that the return value will never be `null` but possibly a stub for `null` returned from a factory method, to be checked via `equals(null)`. Consider using `BeanFactory.getBeanProvider(Class)` for resolving optional dependencies.
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the specified name
  `BeansException` - if the bean could not be obtained

### getBean

public <T> T getBean(String name, Class<T> requiredType) throws BeansException
Description copied from interface: `BeanFactory`
Return an instance, which may be shared or independent, of the specified bean.

Behaves the same as `BeanFactory.getBean(String)`, but provides a measure of type safety by throwing a BeanNotOfRequiredTypeException if the bean is not of the required type. This means that ClassCastException can't be thrown on casting the result correctly, as can happen with `BeanFactory.getBean(String)`.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `getBean` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to retrieve
  `requiredType` - type the bean must match; can be an interface or superclass
Returns:
  an instance of the bean. Note that the return value will never be `null`. In case of a stub for `null` from a factory method having been resolved for the requested bean, a `BeanNotOfRequiredTypeException` against the NullBean stub will be raised. Consider using `BeanFactory.getBeanProvider(Class)` for resolving optional dependencies.
Throws:
  `NoSuchBeanDefinitionException` - if there is no such bean definition
  `BeanNotOfRequiredTypeException` - if the bean is not of the required type
  `BeansException` - if the bean could not be created

### getBean

public Object getBean(String name, Object... args) throws BeansException
Description copied from interface: `BeanFactory`
Return an instance, which may be shared or independent, of the specified bean.

Allows for specifying explicit constructor arguments / factory method arguments, overriding the specified default arguments (if any) in the bean definition. Note that the provided arguments need to match a specific candidate constructor / factory method in the order of declared parameters.

Specified by:
  `getBean` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to retrieve
  `args` - arguments to use when creating a bean instance using explicit arguments (only applied when creating a new instance as opposed to retrieving an existing one)
Returns:
  an instance of the bean
Throws:
  `NoSuchBeanDefinitionException` - if there is no such bean definition
  `BeanDefinitionStoreException` - if arguments have been given but the affected bean isn't a prototype
  `BeansException` - if the bean could not be created

### getBean

public <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args) throws BeansException
Return an instance, which may be shared or independent, of the specified bean.

Parameters:
  `name` - the name of the bean to retrieve
  `requiredType` - the required type of the bean to retrieve
  `args` - arguments to use when creating a bean instance using explicit arguments (only applied when creating a new instance as opposed to retrieving an existing one)
Returns:
  an instance of the bean
Throws:
  `BeansException` - if the bean could not be created

### doGetBean

protected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException
Return an instance, which may be shared or independent, of the specified bean.

Parameters:
  `name` - the name of the bean to retrieve
  `requiredType` - the required type of the bean to retrieve
  `args` - arguments to use when creating a bean instance using explicit arguments (only applied when creating a new instance as opposed to retrieving an existing one)
  `typeCheckOnly` - whether the instance is obtained for a type check, not for actual use
Returns:
  an instance of the bean
Throws:
  `BeansException` - if the bean could not be created

### containsBean

public boolean containsBean(String name)
Description copied from interface: `BeanFactory`
Does this bean factory contain a bean definition or externally registered singleton instance with the given name?

If the given name is an alias, it will be translated back to the corresponding canonical bean name.

If this factory is hierarchical, will ask any parent factory if the bean cannot be found in this factory instance.

If a bean definition or singleton instance matching the given name is found, this method will return `true` whether the named bean definition is concrete or abstract, lazy or eager, in scope or not. Therefore, note that a `true` return value from this method does not necessarily indicate that `BeanFactory.getBean(java.lang.String)` will be able to obtain an instance for the same name.

Specified by:
  `containsBean` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
Returns:
  whether a bean with the given name is present

### isSingleton

public boolean isSingleton(String name) throws NoSuchBeanDefinitionException
Description copied from interface: `BeanFactory`
Is this bean a shared singleton? That is, will `BeanFactory.getBean(java.lang.String)` always return the same instance?

Note: This method returning `false` does not clearly indicate independent instances. It indicates non-singleton instances, which may correspond to a scoped bean as well. Use the `BeanFactory.isPrototype(java.lang.String)` operation to explicitly check for independent instances.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `isSingleton` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
Returns:
  whether this bean corresponds to a singleton instance
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
See Also:
  - `BeanFactory.getBean(java.lang.String)`
  - `BeanFactory.isPrototype(java.lang.String)`

### isPrototype

public boolean isPrototype(String name) throws NoSuchBeanDefinitionException
Description copied from interface: `BeanFactory`
Is this bean a prototype? That is, will `BeanFactory.getBean(java.lang.String)` always return independent instances?

Note: This method returning `false` does not clearly indicate a singleton object. It indicates non-independent instances, which may correspond to a scoped bean as well. Use the `BeanFactory.isSingleton(java.lang.String)` operation to explicitly check for a shared singleton instance.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `isPrototype` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
Returns:
  whether this bean will always deliver independent instances
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
See Also:
  - `BeanFactory.getBean(java.lang.String)`
  - `BeanFactory.isSingleton(java.lang.String)`

### isTypeMatch

public boolean isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch) throws NoSuchBeanDefinitionException
Description copied from interface: `BeanFactory`
Check whether the bean with the given name matches the specified type. More specifically, check whether a `BeanFactory.getBean(java.lang.String)` call for the given name would return an object that is assignable to the specified target type.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `isTypeMatch` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
  `typeToMatch` - the type to match against (as a `ResolvableType`)
Returns:
  `true` if the bean type matches, `false` if it doesn't match or cannot be determined yet
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
See Also:
  - `BeanFactory.getBean(java.lang.String)`
  - `BeanFactory.getType(java.lang.String)`

### isTypeMatch

protected boolean isTypeMatch(String name, org.springframework.core.ResolvableType typeToMatch, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException
Internal extended variant of `isTypeMatch(String, ResolvableType)` to check whether the bean with the given name matches the specified type. Allow additional constraints to be applied to ensure that beans are not created early.

Parameters:
  `name` - the name of the bean to query
  `typeToMatch` - the type to match against (as a `ResolvableType`)
Returns:
  `true` if the bean type matches, `false` if it doesn't match or cannot be determined yet
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
Since:
  5.2
See Also:
  - `getBean(java.lang.String)`
  - `getType(java.lang.String)`

### isTypeMatch

public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException
Description copied from interface: `BeanFactory`
Check whether the bean with the given name matches the specified type. More specifically, check whether a `BeanFactory.getBean(java.lang.String)` call for the given name would return an object that is assignable to the specified target type.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `isTypeMatch` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
  `typeToMatch` - the type to match against (as a `Class`)
Returns:
  `true` if the bean type matches, `false` if it doesn't match or cannot be determined yet
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
See Also:
  - `BeanFactory.getBean(java.lang.String)`
  - `BeanFactory.getType(java.lang.String)`

### getType

@Nullable public Class<?> getType(String name) throws NoSuchBeanDefinitionException
Description copied from interface: `BeanFactory`
Determine the type of the bean with the given name. More specifically, determine the type of object that `BeanFactory.getBean(java.lang.String)` would return for the given name.

For a `FactoryBean`, return the type of object that the FactoryBean creates, as exposed by `FactoryBean.getObjectType()`. This may lead to the initialization of a previously uninitialized `FactoryBean` (see `BeanFactory.getType(String, boolean)`).

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `getType` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
Returns:
  the type of the bean, or `null` if not determinable
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
See Also:
  - `BeanFactory.getBean(java.lang.String)`
  - `BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)`

### getType

@Nullable public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException
Description copied from interface: `BeanFactory`
Determine the type of the bean with the given name. More specifically, determine the type of object that `BeanFactory.getBean(java.lang.String)` would return for the given name.

For a `FactoryBean`, return the type of object that the FactoryBean creates, as exposed by `FactoryBean.getObjectType()`. Depending on the `allowFactoryBeanInit` flag, this may lead to the initialization of a previously uninitialized `FactoryBean` if no early type information is available.

Translates aliases back to the corresponding canonical bean name.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `getType` in interface `BeanFactory`
Parameters:
  `name` - the name of the bean to query
  `allowFactoryBeanInit` - whether a `FactoryBean` may get initialized just for the purpose of determining its object type
Returns:
  the type of the bean, or `null` if not determinable
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
See Also:
  - `BeanFactory.getBean(java.lang.String)`
  - `BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)`

### getAliases

public String[] getAliases(String name)
Description copied from interface: `BeanFactory`
Return the aliases for the given bean name, if any.

All of those aliases point to the same bean when used in a `BeanFactory.getBean(java.lang.String)` call.

If the given name is an alias, the corresponding original bean name and other aliases (if any) will be returned, with the original bean name being the first element in the array.

Will ask the parent factory if the bean cannot be found in this factory instance.

Specified by:
  `getAliases` in interface `org.springframework.core.AliasRegistry`
Specified by:
  `getAliases` in interface `BeanFactory`
Overrides:
  `getAliases` in class `org.springframework.core.SimpleAliasRegistry`
Parameters:
  `name` - the bean name to check for aliases
Returns:
  the aliases, or an empty array if none
See Also:
  - `BeanFactory.getBean(java.lang.String)`

### getParentBeanFactory

@Nullable public BeanFactory getParentBeanFactory()
Description copied from interface: `HierarchicalBeanFactory`
Return the parent bean factory, or `null` if there is none.

Specified by:
  `getParentBeanFactory` in interface `HierarchicalBeanFactory`

### containsLocalBean

public boolean containsLocalBean(String name)
Description copied from interface: `HierarchicalBeanFactory`
Return whether the local bean factory contains a bean of the given name, ignoring beans defined in ancestor contexts.

This is an alternative to `containsBean`, ignoring a bean of the given name from an ancestor bean factory.

Specified by:
  `containsLocalBean` in interface `HierarchicalBeanFactory`
Parameters:
  `name` - the name of the bean to query
Returns:
  whether a bean with the given name is defined in the local factory
See Also:
  - `BeanFactory.containsBean(java.lang.String)`

### setParentBeanFactory

public void setParentBeanFactory(@Nullable BeanFactory parentBeanFactory)
Description copied from interface: `ConfigurableBeanFactory`
Set the parent of this bean factory.

Note that the parent cannot be changed: It should only be set outside a constructor if it isn't available at the time of factory instantiation.

Specified by:
  `setParentBeanFactory` in interface `ConfigurableBeanFactory`
Parameters:
  `parentBeanFactory` - the parent BeanFactory
See Also:
  - `HierarchicalBeanFactory.getParentBeanFactory()`

### setBeanClassLoader

public void setBeanClassLoader(@Nullable ClassLoader beanClassLoader)
Description copied from interface: `ConfigurableBeanFactory`
Set the class loader to use for loading bean classes. Default is the thread context class loader.

Note that this class loader will only apply to bean definitions that do not carry a resolved bean class yet. This is the case as of Spring 2.0 by default: Bean definitions only carry bean class names, to be resolved once the factory processes the bean definition.

Specified by:
  `setBeanClassLoader` in interface `ConfigurableBeanFactory`
Parameters:
  `beanClassLoader` - the class loader to use, or `null` to suggest the default class loader

### getBeanClassLoader

@Nullable public ClassLoader getBeanClassLoader()
Description copied from interface: `ConfigurableBeanFactory`
Return this factory's class loader for loading bean classes (only `null` if even the system ClassLoader isn't accessible).

Specified by:
  `getBeanClassLoader` in interface `ConfigurableBeanFactory`
See Also:
  - `ClassUtils.forName(String, ClassLoader)`

### setTempClassLoader

public void setTempClassLoader(@Nullable ClassLoader tempClassLoader)
Description copied from interface: `ConfigurableBeanFactory`
Specify a temporary ClassLoader to use for type matching purposes. Default is none, simply using the standard bean ClassLoader.

A temporary ClassLoader is usually just specified if load-time weaving is involved, to make sure that actual bean classes are loaded as lazily as possible. The temporary loader is then removed once the BeanFactory completes its bootstrap phase.

Specified by:
  `setTempClassLoader` in interface `ConfigurableBeanFactory`

### getTempClassLoader

@Nullable public ClassLoader getTempClassLoader()
Description copied from interface: `ConfigurableBeanFactory`
Return the temporary ClassLoader to use for type matching purposes, if any.

Specified by:
  `getTempClassLoader` in interface `ConfigurableBeanFactory`

### setCacheBeanMetadata

public void setCacheBeanMetadata(boolean cacheBeanMetadata)
Description copied from interface: `ConfigurableBeanFactory`
Set whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes. Default is on.

Turn this flag off to enable hot-refreshing of bean definition objects and in particular bean classes. If this flag is off, any creation of a bean instance will re-query the bean class loader for newly resolved classes.

Specified by:
  `setCacheBeanMetadata` in interface `ConfigurableBeanFactory`

### isCacheBeanMetadata

public boolean isCacheBeanMetadata()
Description copied from interface: `ConfigurableBeanFactory`
Return whether to cache bean metadata such as given bean definitions (in merged fashion) and resolved bean classes.

Specified by:
  `isCacheBeanMetadata` in interface `ConfigurableBeanFactory`

### setBeanExpressionResolver

public void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver)
Description copied from interface: `ConfigurableBeanFactory`
Specify the resolution strategy for expressions in bean definition values.

There is no expression support active in a BeanFactory by default. An ApplicationContext will typically set a standard expression strategy here, supporting "#{...}" expressions in a Unified EL compatible style.

Specified by:
  `setBeanExpressionResolver` in interface `ConfigurableBeanFactory`

### getBeanExpressionResolver

@Nullable public BeanExpressionResolver getBeanExpressionResolver()
Description copied from interface: `ConfigurableBeanFactory`
Return the resolution strategy for expressions in bean definition values.

Specified by:
  `getBeanExpressionResolver` in interface `ConfigurableBeanFactory`

### setConversionService

public void setConversionService(@Nullable org.springframework.core.convert.ConversionService conversionService)
Description copied from interface: `ConfigurableBeanFactory`
Specify a `ConversionService` to use for converting property values, as an alternative to JavaBeans PropertyEditors.

Specified by:
  `setConversionService` in interface `ConfigurableBeanFactory`

### getConversionService

@Nullable public org.springframework.core.convert.ConversionService getConversionService()
Description copied from interface: `ConfigurableBeanFactory`
Return the associated ConversionService, if any.

Specified by:
  `getConversionService` in interface `ConfigurableBeanFactory`

### addPropertyEditorRegistrar

public void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)
Description copied from interface: `ConfigurableBeanFactory`
Add a PropertyEditorRegistrar to be applied to all bean creation processes.

Such a registrar creates new PropertyEditor instances and registers them on the given registry, fresh for each bean creation attempt. This avoids the need for synchronization on custom editors; hence, it is generally preferable to use this method instead of `ConfigurableBeanFactory.registerCustomEditor(java.lang.Class<?>, java.lang.Class<? extends java.beans.PropertyEditor>)`.

If the given registrar implements `PropertyEditorRegistrar.overridesDefaultEditors()` to return `true`, it will be applied lazily (only when default editors are actually needed).

Specified by:
  `addPropertyEditorRegistrar` in interface `ConfigurableBeanFactory`
Parameters:
  `registrar` - the PropertyEditorRegistrar to register
See Also:
  - `PropertyEditorRegistrar.overridesDefaultEditors()`

### getPropertyEditorRegistrars

public Set<PropertyEditorRegistrar> getPropertyEditorRegistrars()
Return the set of PropertyEditorRegistrars.

### registerCustomEditor

public void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass)
Description copied from interface: `ConfigurableBeanFactory`
Register the given custom property editor for all properties of the given type. To be invoked during factory configuration.

Note that this method will register a shared custom editor instance; access to that instance will be synchronized for thread-safety. It is generally preferable to use `ConfigurableBeanFactory.addPropertyEditorRegistrar(org.springframework.beans.PropertyEditorRegistrar)` instead of this method, to avoid for the need for synchronization on custom editors.

Specified by:
  `registerCustomEditor` in interface `ConfigurableBeanFactory`
Parameters:
  `requiredType` - type of the property
  `propertyEditorClass` - the `PropertyEditor` class to register

### copyRegisteredEditorsTo

public void copyRegisteredEditorsTo(PropertyEditorRegistry registry)
Description copied from interface: `ConfigurableBeanFactory`
Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory.

Specified by:
  `copyRegisteredEditorsTo` in interface `ConfigurableBeanFactory`
Parameters:
  `registry` - the PropertyEditorRegistry to initialize

### getCustomEditors

public Map<Class<?>,Class<? extends PropertyEditor>> getCustomEditors()
Return the map of custom editors, with Classes as keys and PropertyEditor classes as values.

### setTypeConverter

public void setTypeConverter(TypeConverter typeConverter)
Description copied from interface: `ConfigurableBeanFactory`
Set a custom type converter that this BeanFactory should use for converting bean property values, constructor argument values, etc.

This will override the default PropertyEditor mechanism and hence make any custom editors or custom editor registrars irrelevant.

Specified by:
  `setTypeConverter` in interface `ConfigurableBeanFactory`
See Also:
  - `ConfigurableBeanFactory.addPropertyEditorRegistrar(org.springframework.beans.PropertyEditorRegistrar)`
  - `ConfigurableBeanFactory.registerCustomEditor(java.lang.Class<?>, java.lang.Class<? extends java.beans.PropertyEditor>)`

### getCustomTypeConverter

@Nullable protected TypeConverter getCustomTypeConverter()
Return the custom TypeConverter to use, if any.

Returns:
  the custom TypeConverter, or `null` if none specified

### getTypeConverter

public TypeConverter getTypeConverter()
Description copied from interface: `ConfigurableBeanFactory`
Obtain a type converter as used by this BeanFactory. This may be a fresh instance for each call, since TypeConverters are usually not thread-safe.

If the default PropertyEditor mechanism is active, the returned TypeConverter will be aware of all custom editors that have been registered.

Specified by:
  `getTypeConverter` in interface `ConfigurableBeanFactory`

### addEmbeddedValueResolver

public void addEmbeddedValueResolver(org.springframework.util.StringValueResolver valueResolver)
Description copied from interface: `ConfigurableBeanFactory`
Add a String resolver for embedded values such as annotation attributes.

Specified by:
  `addEmbeddedValueResolver` in interface `ConfigurableBeanFactory`
Parameters:
  `valueResolver` - the String resolver to apply to embedded values

### hasEmbeddedValueResolver

public boolean hasEmbeddedValueResolver()
Description copied from interface: `ConfigurableBeanFactory`
Determine whether an embedded value resolver has been registered with this bean factory, to be applied through `ConfigurableBeanFactory.resolveEmbeddedValue(String)`.

Specified by:
  `hasEmbeddedValueResolver` in interface `ConfigurableBeanFactory`

### resolveEmbeddedValue

@Nullable public String resolveEmbeddedValue(@Nullable String value)
Description copied from interface: `ConfigurableBeanFactory`
Resolve the given embedded value, for example, an annotation attribute.

Specified by:
  `resolveEmbeddedValue` in interface `ConfigurableBeanFactory`
Parameters:
  `value` - the value to resolve
Returns:
  the resolved value (may be the original value as-is)

### addBeanPostProcessor

public void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)
Description copied from interface: `ConfigurableBeanFactory`
Add a new BeanPostProcessor that will get applied to beans created by this factory. To be invoked during factory configuration.

Note: Post-processors submitted here will be applied in the order of registration; any ordering semantics expressed through implementing the `Ordered` interface will be ignored. Note that autodetected post-processors (for example, as beans in an ApplicationContext) will always be applied after programmatically registered ones.

Specified by:
  `addBeanPostProcessor` in interface `ConfigurableBeanFactory`
Parameters:
  `beanPostProcessor` - the post-processor to register

### addBeanPostProcessors

public void addBeanPostProcessors(Collection<? extends BeanPostProcessor> beanPostProcessors)
Add new BeanPostProcessors that will get applied to beans created by this factory. To be invoked during factory configuration.

Since:
  5.3
See Also:
  - `addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor)`

### getBeanPostProcessorCount

public int getBeanPostProcessorCount()
Description copied from interface: `ConfigurableBeanFactory`
Return the current number of registered BeanPostProcessors, if any.

Specified by:
  `getBeanPostProcessorCount` in interface `ConfigurableBeanFactory`

### getBeanPostProcessors

public List<BeanPostProcessor> getBeanPostProcessors()
Return the list of BeanPostProcessors that will get applied to beans created with this factory.

### hasInstantiationAwareBeanPostProcessors

protected boolean hasInstantiationAwareBeanPostProcessors()
Return whether this factory holds a InstantiationAwareBeanPostProcessor that will get applied to singleton beans on creation.

See Also:
  - `addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor)`
  - `InstantiationAwareBeanPostProcessor`

### hasDestructionAwareBeanPostProcessors

protected boolean hasDestructionAwareBeanPostProcessors()
Return whether this factory holds a DestructionAwareBeanPostProcessor that will get applied to singleton beans on shutdown.

See Also:
  - `addBeanPostProcessor(org.springframework.beans.factory.config.BeanPostProcessor)`
  - `DestructionAwareBeanPostProcessor`

### registerScope

public void registerScope(String scopeName, Scope scope)
Description copied from interface: `ConfigurableBeanFactory`
Register the given scope, backed by the given Scope implementation.

Specified by:
  `registerScope` in interface `ConfigurableBeanFactory`
Parameters:
  `scopeName` - the scope identifier
  `scope` - the backing Scope implementation

### getRegisteredScopeNames

public String[] getRegisteredScopeNames()
Description copied from interface: `ConfigurableBeanFactory`
Return the names of all currently registered scopes.

This will only return the names of explicitly registered scopes. Built-in scopes such as "singleton" and "prototype" won't be exposed.

Specified by:
  `getRegisteredScopeNames` in interface `ConfigurableBeanFactory`
Returns:
  the array of scope names, or an empty array if none
See Also:
  - `ConfigurableBeanFactory.registerScope(java.lang.String, org.springframework.beans.factory.config.Scope)`

### getRegisteredScope

@Nullable public Scope getRegisteredScope(String scopeName)
Description copied from interface: `ConfigurableBeanFactory`
Return the Scope implementation for the given scope name, if any.

This will only return explicitly registered scopes. Built-in scopes such as "singleton" and "prototype" won't be exposed.

Specified by:
  `getRegisteredScope` in interface `ConfigurableBeanFactory`
Parameters:
  `scopeName` - the name of the scope
Returns:
  the registered Scope implementation, or `null` if none
See Also:
  - `ConfigurableBeanFactory.registerScope(java.lang.String, org.springframework.beans.factory.config.Scope)`

### setApplicationStartup

public void setApplicationStartup(org.springframework.core.metrics.ApplicationStartup applicationStartup)
Description copied from interface: `ConfigurableBeanFactory`
Set the `ApplicationStartup` for this bean factory.

This allows the application context to record metrics during application startup.

Specified by:
  `setApplicationStartup` in interface `ConfigurableBeanFactory`
Parameters:
  `applicationStartup` - the new application startup

### getApplicationStartup

public org.springframework.core.metrics.ApplicationStartup getApplicationStartup()
Description copied from interface: `ConfigurableBeanFactory`
Return the `ApplicationStartup` for this bean factory.

Specified by:
  `getApplicationStartup` in interface `ConfigurableBeanFactory`

### copyConfigurationFrom

public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory)
Description copied from interface: `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.

Specified by:
  `copyConfigurationFrom` in interface `ConfigurableBeanFactory`
Parameters:
  `otherFactory` - the other BeanFactory to copy from

### getMergedBeanDefinition

public BeanDefinition getMergedBeanDefinition(String name) throws BeansException
Return a 'merged' BeanDefinition for the given bean name, merging a child bean definition with its parent if necessary.

This `getMergedBeanDefinition` considers bean definition in ancestors as well.

Specified by:
  `getMergedBeanDefinition` in interface `ConfigurableBeanFactory`
Parameters:
  `name` - the name of the bean to retrieve the merged definition for (may be an alias)
Returns:
  a (potentially merged) RootBeanDefinition for the given bean
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
  `BeanDefinitionStoreException` - in case of an invalid bean definition
  `NoSuchBeanDefinitionException` - if there is no bean definition with the given name
  `BeansException`

### isFactoryBean

public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException
Description copied from interface: `ConfigurableBeanFactory`
Determine whether the bean with the given name is a FactoryBean.

Specified by:
  `isFactoryBean` in interface `ConfigurableBeanFactory`
Parameters:
  `name` - the name of the bean to check
Returns:
  whether the bean is a FactoryBean (`false` means the bean exists but is not a FactoryBean)
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name

### isActuallyInCreation

public boolean isActuallyInCreation(String beanName)

Overrides:
  `isActuallyInCreation` in class `DefaultSingletonBeanRegistry`

### isPrototypeCurrentlyInCreation

protected boolean isPrototypeCurrentlyInCreation(String beanName)
Return whether the specified prototype bean is currently in creation (within the current thread).

Parameters:
  `beanName` - the name of the bean

### beforePrototypeCreation

protected void beforePrototypeCreation(String beanName)
Callback before prototype creation.

The default implementation registers the prototype as currently in creation.

Parameters:
  `beanName` - the name of the prototype about to be created
See Also:
  - `isPrototypeCurrentlyInCreation(java.lang.String)`

### afterPrototypeCreation

protected void afterPrototypeCreation(String beanName)
Callback after prototype creation.

The default implementation marks the prototype as not in creation anymore.

Parameters:
  `beanName` - the name of the prototype that has been created
See Also:
  - `isPrototypeCurrentlyInCreation(java.lang.String)`

### destroyBean

public void destroyBean(String beanName, Object beanInstance)
Description copied from interface: `ConfigurableBeanFactory`
Destroy the given bean instance (usually a prototype instance obtained from this factory) according to its bean definition.

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

Specified by:
  `destroyBean` in interface `ConfigurableBeanFactory`
Parameters:
  `beanName` - the name of the bean definition
  `beanInstance` - the bean instance to destroy

### destroyBean

protected void destroyBean(String beanName, Object bean, RootBeanDefinition mbd)
Destroy the given bean instance (usually a prototype instance obtained from this factory) according to the given bean definition.

Parameters:
  `beanName` - the name of the bean definition
  `bean` - the bean instance to destroy
  `mbd` - the merged bean definition

### destroyScopedBean

public void destroyScopedBean(String beanName)
Description copied from interface: `ConfigurableBeanFactory`
Destroy the specified scoped bean in the current target scope, if any.

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

Specified by:
  `destroyScopedBean` in interface `ConfigurableBeanFactory`
Parameters:
  `beanName` - the name of the scoped bean

### transformedBeanName

protected String transformedBeanName(String name)
Return the bean name, stripping out the factory dereference prefix if necessary, and resolving aliases to canonical names.

Parameters:
  `name` - the user-specified name
Returns:
  the transformed bean name

### originalBeanName

protected String originalBeanName(String name)
Determine the original bean name, resolving locally defined aliases to canonical names.

Parameters:
  `name` - the user-specified name
Returns:
  the original bean name

### initBeanWrapper

protected void initBeanWrapper(BeanWrapper bw)
Initialize the given BeanWrapper with the custom editors registered with this factory. To be called for BeanWrappers that will create and populate bean instances.

The default implementation delegates to `registerCustomEditors(org.springframework.beans.PropertyEditorRegistry)`. Can be overridden in subclasses.

Parameters:
  `bw` - the BeanWrapper to initialize

### registerCustomEditors

protected void registerCustomEditors(PropertyEditorRegistry registry)
Initialize the given PropertyEditorRegistry with the custom editors that have been registered with this BeanFactory.

To be called for BeanWrappers that will create and populate bean instances, and for SimpleTypeConverter used for constructor argument and factory method type conversion.

Parameters:
  `registry` - the PropertyEditorRegistry to initialize

### getMergedLocalBeanDefinition

protected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException
Return a merged RootBeanDefinition, traversing the parent bean definition if the specified bean corresponds to a child bean definition.

Parameters:
  `beanName` - the name of the bean to retrieve the merged definition for
Returns:
  a (potentially merged) RootBeanDefinition for the given bean
Throws:
  `NoSuchBeanDefinitionException` - if there is no bean with the given name
  `BeanDefinitionStoreException` - in case of an invalid bean definition
  `BeansException`

### getMergedBeanDefinition

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException
Return a RootBeanDefinition for the given top-level bean, by merging with the parent if the given bean's definition is a child bean definition.

Parameters:
  `beanName` - the name of the bean definition
  `bd` - the original bean definition (Root/ChildBeanDefinition)
Returns:
  a (potentially merged) RootBeanDefinition for the given bean
Throws:
  `BeanDefinitionStoreException` - in case of an invalid bean definition

### getMergedBeanDefinition

protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException
Return a RootBeanDefinition for the given bean, by merging with the parent if the given bean's definition is a child bean definition.

Parameters:
  `beanName` - the name of the bean definition
  `bd` - the original bean definition (Root/ChildBeanDefinition)
  `containingBd` - the containing bean definition in case of inner bean, or `null` in case of a top-level bean
Returns:
  a (potentially merged) RootBeanDefinition for the given bean
Throws:
  `BeanDefinitionStoreException` - in case of an invalid bean definition

### cacheMergedBeanDefinition

protected void cacheMergedBeanDefinition(RootBeanDefinition mbd, String beanName)
Cache the given merged bean definition.

Subclasses can override this to derive additional cached state from the final post-processed bean definition.

Parameters:
  `mbd` - the merged bean definition to cache
  `beanName` - the name of the bean
Since:
  6.2.6

### checkMergedBeanDefinition

protected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args)
Check the given merged bean definition, potentially throwing validation exceptions.

Parameters:
  `mbd` - the merged bean definition to check
  `beanName` - the name of the bean
  `args` - the arguments for bean creation, if any

### clearMergedBeanDefinition

protected void clearMergedBeanDefinition(String beanName)
Remove the merged bean definition for the specified bean, recreating it on next access.

Parameters:
  `beanName` - the bean name to clear the merged definition for

### clearMetadataCache

public void clearMetadataCache()
Clear the merged bean definition cache, removing entries for beans which are not considered eligible for full metadata caching yet.

Typically triggered after changes to the original bean definitions, for example, after applying a `BeanFactoryPostProcessor`. Note that metadata for beans which have already been created at this point will be kept around.

Since:
  4.2

### resolveBeanClass

@Nullable protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch) throws CannotLoadBeanClassException
Resolve the bean class for the specified bean definition, resolving a bean class name into a Class reference (if necessary) and storing the resolved Class in the bean definition for further use.

Parameters:
  `mbd` - the merged bean definition to determine the class for
  `beanName` - the name of the bean (for error handling purposes)
  `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)
Returns:
  the resolved bean class (or `null` if none)
Throws:
  `CannotLoadBeanClassException` - if we failed to load the class

### evaluateBeanDefinitionString

@Nullable protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition)
Evaluate the given String as contained in a bean definition, potentially resolving it as an expression.

Parameters:
  `value` - the value to check
  `beanDefinition` - the bean definition that the value comes from
Returns:
  the resolved value
See Also:
  - `setBeanExpressionResolver(org.springframework.beans.factory.config.BeanExpressionResolver)`

### predictBeanType

@Nullable protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)
Predict the eventual bean type (of the processed bean instance) for the specified bean. Called by `getType(java.lang.String)` and `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.

Parameters:
  `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)
Returns:
  the type of the bean, or `null` if not predictable

### isFactoryBean

protected boolean isFactoryBean(String beanName, RootBeanDefinition mbd)
Check whether the given bean is defined as a `FactoryBean`.

Parameters:
  `beanName` - the name of the bean
  `mbd` - the corresponding bean definition

### getTypeForFactoryBean

protected org.springframework.core.ResolvableType getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit)
Determine the bean type for the given FactoryBean definition, as far as possible. Only called if there is no singleton instance registered for the target bean already. The implementation is allowed to instantiate the target factory bean if `allowInit` is `true` and the type cannot be determined another way; otherwise it is restricted to introspecting signatures and related metadata.

If no `FactoryBean.OBJECT_TYPE_ATTRIBUTE` is set on the bean definition and `allowInit` is `true`, the default implementation will create the FactoryBean via `getBean` to call its `getObjectType` method. Subclasses are encouraged to optimize this, typically by inspecting the generic signature of the factory bean class or the factory method that creates it. If subclasses do instantiate the FactoryBean, they should consider trying the `getObjectType` method without fully populating the bean. If this fails, a full FactoryBean creation as performed by this implementation should be used as fallback.

Parameters:
  `beanName` - the name of the bean
  `mbd` - the merged bean definition for the bean
  `allowInit` - if initialization of the FactoryBean is permitted if the type cannot be determined another way
Returns:
  the type for the bean if determinable, otherwise `ResolvableType.NONE`
Since:
  5.2
See Also:
  - `FactoryBean.getObjectType()`
  - `getBean(String)`

### markBeanAsCreated

protected void markBeanAsCreated(String beanName)
Mark the specified bean as already created (or about to be created).

This allows the bean factory to optimize its caching for repeated creation of the specified bean.

Parameters:
  `beanName` - the name of the bean

### cleanupAfterBeanCreationFailure

protected void cleanupAfterBeanCreationFailure(String beanName)
Perform appropriate cleanup of cached metadata after bean creation failed.

Parameters:
  `beanName` - the name of the bean

### isBeanEligibleForMetadataCaching

protected boolean isBeanEligibleForMetadataCaching(String beanName)
Determine whether the specified bean is eligible for having its bean definition metadata cached.

Parameters:
  `beanName` - the name of the bean
Returns:
  `true` if the bean's metadata may be cached at this point already

### removeSingletonIfCreatedForTypeCheckOnly

protected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName)
Remove the singleton instance (if any) for the given bean name, but only if it hasn't been used for other purposes than type checking.

Parameters:
  `beanName` - the name of the bean
Returns:
  `true` if actually removed, `false` otherwise

### hasBeanCreationStarted

protected boolean hasBeanCreationStarted()
Check whether this factory's bean creation phase already started, i.e. whether any bean has been marked as created in the meantime.

Since:
  4.2.2
See Also:
  - `markBeanAsCreated(java.lang.String)`

### getObjectForBeanInstance

protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd)
Get the object for the given bean instance, either the bean instance itself or its created object in case of a FactoryBean.

Parameters:
  `beanInstance` - the shared bean instance
  `name` - the name that may include factory dereference prefix
  `beanName` - the canonical bean name
  `mbd` - the merged bean definition
Returns:
  the object to expose for the bean

### isBeanNameInUse

public boolean isBeanNameInUse(String beanName)
Determine whether the given bean name is already in use within this factory, i.e. whether there is a local bean or alias registered under this name or an inner bean created with this name.

Parameters:
  `beanName` - the name to check

### requiresDestruction

protected boolean requiresDestruction(Object bean, RootBeanDefinition mbd)
Determine whether the given bean requires destruction on shutdown.

The default implementation checks the DisposableBean interface as well as a specified destroy method and registered DestructionAwareBeanPostProcessors.

Parameters:
  `bean` - the bean instance to check
  `mbd` - the corresponding bean definition
See Also:
  - `DisposableBean`
  - `AbstractBeanDefinition.getDestroyMethodName()`
  - `DestructionAwareBeanPostProcessor`

### registerDisposableBeanIfNecessary

protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd)
Add the given bean to the list of disposable beans in this factory, registering its DisposableBean interface and/or the given destroy method to be called on factory shutdown (if applicable). Only applies to singletons.

Parameters:
  `beanName` - the name of the bean
  `bean` - the bean instance
  `mbd` - the bean definition for the bean
See Also:
  - `AbstractBeanDefinition.isSingleton()`
  - `AbstractBeanDefinition.getDependsOn()`
  - `DefaultSingletonBeanRegistry.registerDisposableBean(java.lang.String, org.springframework.beans.factory.DisposableBean)`
  - `DefaultSingletonBeanRegistry.registerDependentBean(java.lang.String, java.lang.String)`

### containsBeanDefinition

protected abstract boolean containsBeanDefinition(String beanName)
Check if this bean factory contains a bean definition with the given name. Does not consider any hierarchy this factory may participate in. Invoked by `containsBean` when no cached singleton instance is found.

Depending on the nature of the concrete bean factory implementation, this operation might be expensive (for example, because of directory lookups in external registries). However, for listable bean factories, this usually just amounts to a local hash lookup: The operation is therefore part of the public interface there. The same implementation can serve for both this template method and the public interface method in that case.

Parameters:
  `beanName` - the name of the bean to look for
Returns:
  if this bean factory contains a bean definition with the given name
See Also:
  - `containsBean(java.lang.String)`
  - `ListableBeanFactory.containsBeanDefinition(java.lang.String)`

### getBeanDefinition

protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException
Return the bean definition for the given bean name. Subclasses should normally implement caching, as this method is invoked by this class every time bean definition metadata is needed.

Depending on the nature of the concrete bean factory implementation, this operation might be expensive (for example, because of directory lookups in external registries). However, for listable bean factories, this usually just amounts to a local hash lookup: The operation is therefore part of the public interface there. The same implementation can serve for both this template method and the public interface method in that case.

Parameters:
  `beanName` - the name of the bean to find a definition for
Returns:
  the BeanDefinition for this prototype name (never `null`)
Throws:
  `NoSuchBeanDefinitionException` - if the bean definition cannot be resolved
  `BeansException` - in case of errors
See Also:
  - `RootBeanDefinition`
  - `ChildBeanDefinition`
  - `ConfigurableListableBeanFactory.getBeanDefinition(java.lang.String)`

### createBean

protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException
Create a bean instance for the given merged bean definition (and arguments). The bean definition will already have been merged with the parent definition in case of a child definition.

All bean retrieval methods delegate to this method for actual bean creation.

Parameters:
  `beanName` - the name of the bean
  `mbd` - the merged bean definition for the bean
  `args` - explicit arguments to use for constructor or factory method invocation
Returns:
  a new instance of the bean
Throws:
  `BeanCreationException` - if the bean could not be created