public abstract class AbstractAutowireCapableBeanFactory extends AbstractBeanFactory implements AutowireCapableBeanFactory
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.
RootBeanDefinition
,
DefaultListableBeanFactory
,
BeanDefinitionRegistry
logger
AUTOWIRE_AUTODETECT, AUTOWIRE_BY_NAME, AUTOWIRE_BY_TYPE, AUTOWIRE_CONSTRUCTOR, AUTOWIRE_NO, ORIGINAL_INSTANCE_SUFFIX
FACTORY_BEAN_PREFIX
SCOPE_PROTOTYPE, SCOPE_SINGLETON
Constructor and Description |
---|
AbstractAutowireCapableBeanFactory()
Create a new AbstractAutowireCapableBeanFactory.
|
AbstractAutowireCapableBeanFactory(BeanFactory parentBeanFactory)
Create a new AbstractAutowireCapableBeanFactory with the given parent.
|
Modifier and Type | Method and Description |
---|---|
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.
|
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)
Fully create a new bean instance of the given class.
|
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)
Determine candidate constructors to use for the given bean, checking all registered
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)
Actually create the specified 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)
Obtain a reference for early access to the specified bean,
typically for the purpose of resolving a circular reference.
|
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 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)
Populate the bean instance in the given BeanWrapper with the property values
from the bean definition.
|
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.
|
Object |
resolveBeanByName(String name,
DependencyDescriptor descriptor)
Resolve a bean instance for the given bean name, providing a dependency descriptor
for exposure to target factory methods.
|
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(ParameterNameDiscoverer parameterNameDiscoverer)
Set the ParameterNameDiscoverer to use for resolving method parameter
names if needed (e.g.
|
protected String[] |
unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd,
BeanWrapper bw)
Return an array of non-simple bean properties that are unsatisfied.
|
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
getCachedObjectForFactoryBean, getFactoryBean, getObjectFromFactoryBean, getTypeForFactoryBean
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
allowAliasOverriding, canonicalName, checkForAliasCircle, hasAlias, isAlias, registerAlias, removeAlias, resolveAliases
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
resolveDependency, resolveNamedBean
containsBean, getAliases, getBean, getBean, getBean, getBean, getBean, getBeanProvider, getBeanProvider, getType, isPrototype, isSingleton, isTypeMatch, isTypeMatch
destroySingletons, getDependenciesForBean, getDependentBeans, isCurrentlyInCreation, registerAlias, registerDependentBean, resolveAliases, setCurrentlyInCreation
containsSingleton, getSingleton, getSingletonCount, getSingletonMutex, getSingletonNames, registerSingleton
public AbstractAutowireCapableBeanFactory()
public AbstractAutowireCapableBeanFactory(@Nullable BeanFactory parentBeanFactory)
parentBeanFactory
- parent bean factory, or null
if nonepublic void setInstantiationStrategy(InstantiationStrategy instantiationStrategy)
CglibSubclassingInstantiationStrategy
protected InstantiationStrategy getInstantiationStrategy()
public void setParameterNameDiscoverer(@Nullable ParameterNameDiscoverer parameterNameDiscoverer)
Default is a DefaultParameterNameDiscoverer
.
@Nullable protected ParameterNameDiscoverer getParameterNameDiscoverer()
public void setAllowCircularReferences(boolean allowCircularReferences)
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.
public void setAllowRawInjectionDespiteWrapping(boolean allowRawInjectionDespiteWrapping)
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)
public void ignoreDependencyType(Class<?> type)
public void ignoreDependencyInterface(Class<?> ifc)
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
,
ApplicationContextAware
public void copyConfigurationFrom(ConfigurableBeanFactory otherFactory)
ConfigurableBeanFactory
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
in interface ConfigurableBeanFactory
copyConfigurationFrom
in class AbstractBeanFactory
otherFactory
- the other BeanFactory to copy frompublic <T> T createBean(Class<T> beanClass) throws BeansException
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
beanClass
- the class of the bean to createBeansException
- if instantiation or wiring failedpublic void autowireBean(Object existingBean)
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instancepublic Object configureBean(Object existingBean, String beanName) throws BeansException
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instancebeanName
- the name of the bean, to be passed to it if necessary
(a bean definition of that name has to be available)NoSuchBeanDefinitionException
- if there is no bean definition with the given nameBeansException
- if the initialization failedAutowireCapableBeanFactory.initializeBean(java.lang.Object, java.lang.String)
public Object createBean(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
beanClass
- the class of the bean to createautowireMode
- by name or type, using the constants in this interfacedependencyCheck
- whether to perform a dependency check for objects
(not applicable to autowiring a constructor, thus ignored there)BeansException
- if instantiation or wiring failedAutowireCapableBeanFactory.AUTOWIRE_NO
,
AutowireCapableBeanFactory.AUTOWIRE_BY_NAME
,
AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE
,
AutowireCapableBeanFactory.AUTOWIRE_CONSTRUCTOR
public Object autowire(Class<?> beanClass, int autowireMode, boolean dependencyCheck) throws BeansException
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
beanClass
- the class of the bean to instantiateautowireMode
- by name or type, using the constants in this interfacedependencyCheck
- whether to perform a dependency check for object
references in the bean instance (not applicable to autowiring a constructor,
thus ignored there)BeansException
- if instantiation or wiring failedAutowireCapableBeanFactory.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)
public void autowireBeanProperties(Object existingBean, int autowireMode, boolean dependencyCheck) throws BeansException
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instanceautowireMode
- by name or type, using the constants in this interfacedependencyCheck
- whether to perform a dependency check for object
references in the bean instanceBeansException
- if wiring failedAutowireCapableBeanFactory.AUTOWIRE_BY_NAME
,
AutowireCapableBeanFactory.AUTOWIRE_BY_TYPE
,
AutowireCapableBeanFactory.AUTOWIRE_NO
public void applyBeanPropertyValues(Object existingBean, String beanName) throws BeansException
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instancebeanName
- 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 nameBeansException
- if applying the property values failedAutowireCapableBeanFactory.autowireBeanProperties(java.lang.Object, int, boolean)
public Object initializeBean(Object existingBean, String beanName)
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instancebeanName
- the name of the bean, to be passed to it if necessary
(only passed to BeanPostProcessors
;
can follow the AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX
convention in order to
enforce the given instance to be returned, i.e. no proxies etc)AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX
public Object applyBeanPostProcessorsBeforeInitialization(Object existingBean, String beanName) throws BeansException
AutowireCapableBeanFactory
BeanPostProcessors
to the given existing bean
instance, invoking their postProcessBeforeInitialization
methods.
The returned bean instance may be a wrapper around the original.applyBeanPostProcessorsBeforeInitialization
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instancebeanName
- the name of the bean, to be passed to it if necessary
(only passed to BeanPostProcessors
;
can follow the AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX
convention in order to
enforce the given instance to be returned, i.e. no proxies etc)BeansException
- if any post-processing failedBeanPostProcessor.postProcessBeforeInitialization(java.lang.Object, java.lang.String)
,
AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX
public Object applyBeanPostProcessorsAfterInitialization(Object existingBean, String beanName) throws BeansException
AutowireCapableBeanFactory
BeanPostProcessors
to the given existing bean
instance, invoking their postProcessAfterInitialization
methods.
The returned bean instance may be a wrapper around the original.applyBeanPostProcessorsAfterInitialization
in interface AutowireCapableBeanFactory
existingBean
- the existing bean instancebeanName
- the name of the bean, to be passed to it if necessary
(only passed to BeanPostProcessors
;
can follow the AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX
convention in order to
enforce the given instance to be returned, i.e. no proxies etc)BeansException
- if any post-processing failedBeanPostProcessor.postProcessAfterInitialization(java.lang.Object, java.lang.String)
,
AutowireCapableBeanFactory.ORIGINAL_INSTANCE_SUFFIX
public void destroyBean(Object existingBean)
AutowireCapableBeanFactory
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
in interface AutowireCapableBeanFactory
existingBean
- the bean instance to destroypublic Object resolveBeanByName(String name, DependencyDescriptor descriptor)
AutowireCapableBeanFactory
This is effectively a variant of BeanFactory.getBean(String, Class)
which supports
factory methods with an InjectionPoint
argument.
resolveBeanByName
in interface AutowireCapableBeanFactory
name
- the name of the bean to look updescriptor
- the dependency descriptor for the requesting injection pointBeanFactory.getBean(String, Class)
@Nullable public Object resolveDependency(DependencyDescriptor descriptor, @Nullable String requestingBeanName) throws BeansException
AutowireCapableBeanFactory
resolveDependency
in interface AutowireCapableBeanFactory
descriptor
- the descriptor for the dependency (field/method/constructor)requestingBeanName
- the name of the bean which declares the given dependencynull
if none foundNoSuchBeanDefinitionException
- if no matching bean was foundNoUniqueBeanDefinitionException
- if more than one matching bean was foundBeansException
- if dependency resolution failed for any other reasonAutowireCapableBeanFactory.resolveDependency(DependencyDescriptor, String, Set, TypeConverter)
protected Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException
createBean
in class AbstractBeanFactory
beanName
- the name of the beanmbd
- the merged bean definition for the beanargs
- explicit arguments to use for constructor or factory method invocationBeanCreationException
- if the bean could not be createddoCreateBean(java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Object[])
protected Object doCreateBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException
postProcessBeforeInstantiation
callbacks.
Differentiates between default bean instantiation, use of a factory method, and autowiring a constructor.
beanName
- the name of the beanmbd
- the merged bean definition for the beanargs
- explicit arguments to use for constructor or factory method invocationBeanCreationException
- if the bean could not be createdinstantiateBean(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[])
@Nullable protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)
AbstractBeanFactory
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
in class AbstractBeanFactory
beanName
- the name of the beanmbd
- the merged bean definition to determine the type fortypesToMatch
- the types to match in case of internal type matching purposes
(also signals that the returned Class
will never be exposed to application code)null
if not predictable@Nullable protected Class<?> determineTargetType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)
beanName
- the name of the bean (for error handling purposes)mbd
- the merged bean definition for the beantypesToMatch
- the types to match in case of internal type matching purposes
(also signals that the returned Class
will never be exposed to application code)null
otherwise@Nullable protected Class<?> getTypeForFactoryMethod(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)
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 beantypesToMatch
- the types to match in case of internal type matching purposes
(also signals that the returned Class
will never be exposed to application code)null
otherwisecreateBean(java.lang.Class<T>)
@Nullable protected Class<?> getTypeForFactoryBean(String beanName, RootBeanDefinition mbd)
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
in class AbstractBeanFactory
beanName
- the name of the beanmbd
- the merged bean definition for the beannull
otherwiseFactoryBean.getObjectType()
,
AbstractBeanFactory.getBean(String)
protected Object getEarlyBeanReference(String beanName, RootBeanDefinition mbd, Object bean)
beanName
- the name of the bean (for error handling purposes)mbd
- the merged bean definition for the beanbean
- the raw bean instanceprotected void applyMergedBeanDefinitionPostProcessors(RootBeanDefinition mbd, Class<?> beanType, String beanName)
postProcessMergedBeanDefinition
methods.mbd
- the merged bean definition for the beanbeanType
- the actual type of the managed bean instancebeanName
- the name of the beanMergedBeanDefinitionPostProcessor.postProcessMergedBeanDefinition(org.springframework.beans.factory.support.RootBeanDefinition, java.lang.Class<?>, java.lang.String)
@Nullable protected Object resolveBeforeInstantiation(String beanName, RootBeanDefinition mbd)
beanName
- the name of the beanmbd
- the bean definition for the beannull
if none@Nullable protected Object applyBeanPostProcessorsBeforeInstantiation(Class<?> beanClass, String beanName)
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 instantiatedbeanName
- the name of the beannull
InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)
protected BeanWrapper createBeanInstance(String beanName, RootBeanDefinition mbd, @Nullable Object[] args)
beanName
- the name of the beanmbd
- the bean definition for the beanargs
- explicit arguments to use for constructor or factory method invocationobtainFromSupplier(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)
protected BeanWrapper obtainFromSupplier(Supplier<?> instanceSupplier, String beanName)
instanceSupplier
- the configured supplierbeanName
- the corresponding bean namegetObjectForBeanInstance(java.lang.Object, java.lang.String, java.lang.String, org.springframework.beans.factory.support.RootBeanDefinition)
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd)
Supplier
callback.getObjectForBeanInstance
in class AbstractBeanFactory
beanInstance
- the shared bean instancename
- the name that may include factory dereference prefixbeanName
- the canonical bean namembd
- the merged bean definitionobtainFromSupplier(java.util.function.Supplier<?>, java.lang.String)
@Nullable protected Constructor<?>[] determineConstructorsFromBeanPostProcessors(@Nullable Class<?> beanClass, String beanName) throws BeansException
SmartInstantiationAwareBeanPostProcessors
.beanClass
- the raw class of the beanbeanName
- the name of the beannull
if none specifiedBeansException
- in case of errorsSmartInstantiationAwareBeanPostProcessor.determineCandidateConstructors(java.lang.Class<?>, java.lang.String)
protected BeanWrapper instantiateBean(String beanName, RootBeanDefinition mbd)
beanName
- the name of the beanmbd
- the bean definition for the beanprotected BeanWrapper instantiateUsingFactoryMethod(String beanName, RootBeanDefinition mbd, @Nullable Object[] explicitArgs)
beanName
- the name of the beanmbd
- the bean definition for the beanexplicitArgs
- argument values passed in programmatically via the getBean method,
or null
if none (-> use constructor argument values from bean definition)AbstractBeanFactory.getBean(String, Object[])
protected BeanWrapper autowireConstructor(String beanName, RootBeanDefinition mbd, @Nullable Constructor<?>[] ctors, @Nullable Object[] explicitArgs)
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 beanmbd
- the bean definition for the beanctors
- the chosen candidate constructorsexplicitArgs
- argument values passed in programmatically via the getBean method,
or null
if none (-> use constructor argument values from bean definition)protected void populateBean(String beanName, RootBeanDefinition mbd, @Nullable BeanWrapper bw)
beanName
- the name of the beanmbd
- the bean definition for the beanbw
- the BeanWrapper with bean instanceprotected void autowireByName(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)
beanName
- the name of the bean we're wiring up.
Useful for debugging messages; not used functionally.mbd
- bean definition to update through autowiringbw
- the BeanWrapper from which we can obtain information about the beanpvs
- the PropertyValues to register wired objects withprotected void autowireByType(String beanName, AbstractBeanDefinition mbd, BeanWrapper bw, MutablePropertyValues pvs)
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 typembd
- the merged bean definition to update through autowiringbw
- the BeanWrapper from which we can obtain information about the beanpvs
- the PropertyValues to register wired objects withprotected String[] unsatisfiedNonSimpleProperties(AbstractBeanDefinition mbd, BeanWrapper bw)
mbd
- the merged bean definition the bean was created withbw
- the BeanWrapper the bean was created withBeanUtils.isSimpleProperty(java.lang.Class<?>)
protected PropertyDescriptor[] filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw, boolean cache)
bw
- the BeanWrapper the bean was created withcache
- whether to cache filtered PropertyDescriptors for the given bean ClassisExcludedFromDependencyCheck(java.beans.PropertyDescriptor)
,
filterPropertyDescriptorsForDependencyCheck(org.springframework.beans.BeanWrapper)
protected PropertyDescriptor[] filterPropertyDescriptorsForDependencyCheck(BeanWrapper bw)
bw
- the BeanWrapper the bean was created withisExcludedFromDependencyCheck(java.beans.PropertyDescriptor)
protected boolean isExcludedFromDependencyCheck(PropertyDescriptor pd)
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 propertyignoreDependencyType(Class)
,
ignoreDependencyInterface(Class)
protected void checkDependencies(String beanName, AbstractBeanDefinition mbd, PropertyDescriptor[] pds, @Nullable PropertyValues pvs) throws UnsatisfiedDependencyException
beanName
- the name of the beanmbd
- the merged bean definition the bean was created withpds
- the relevant property descriptors for the target beanpvs
- the property values to be applied to the beanUnsatisfiedDependencyException
isExcludedFromDependencyCheck(java.beans.PropertyDescriptor)
protected void applyPropertyValues(String beanName, BeanDefinition mbd, BeanWrapper bw, PropertyValues pvs)
beanName
- the bean name passed for better exception informationmbd
- the merged bean definitionbw
- the BeanWrapper wrapping the target objectpvs
- the new property valuesprotected Object initializeBean(String beanName, Object bean, @Nullable RootBeanDefinition mbd)
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 initializembd
- the bean definition that the bean was created with
(can also be null
, if given an existing bean instance)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)
protected void invokeInitMethods(String beanName, Object bean, @Nullable RootBeanDefinition mbd) throws Throwable
beanName
- the bean name in the factory (for debugging purposes)bean
- the new bean instance we may need to initializembd
- 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 processinvokeCustomInitMethod(java.lang.String, java.lang.Object, org.springframework.beans.factory.support.RootBeanDefinition)
protected void invokeCustomInitMethod(String beanName, Object bean, RootBeanDefinition mbd) throws Throwable
Can be overridden in subclasses for custom resolution of init methods with arguments.
protected Object postProcessObjectFromFactoryBean(Object object, String beanName)
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
in class FactoryBeanRegistrySupport
object
- the object obtained from the FactoryBean.beanName
- the name of the beanapplyBeanPostProcessorsAfterInitialization(java.lang.Object, java.lang.String)
protected void removeSingleton(String beanName)
removeSingleton
in class FactoryBeanRegistrySupport
beanName
- the name of the beanDefaultSingletonBeanRegistry.getSingletonMutex()
protected void clearSingletonCache()
clearSingletonCache
in class FactoryBeanRegistrySupport