public abstract class AbstractBeanFactory extends FactoryBeanRegistrySupport implements ConfigurableBeanFactory
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
.
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)
logger
SCOPE_PROTOTYPE, SCOPE_SINGLETON
FACTORY_BEAN_PREFIX
Constructor and Description |
---|
AbstractBeanFactory()
Create a new AbstractBeanFactory.
|
AbstractBeanFactory(BeanFactory parentBeanFactory)
Create a new AbstractBeanFactory with the given parent.
|
Modifier and Type | Method and Description |
---|---|
void |
addBeanPostProcessor(BeanPostProcessor beanPostProcessor)
Add a new BeanPostProcessor that will get applied to beans created
by this factory.
|
void |
addEmbeddedValueResolver(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 |
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.
|
AccessControlContext |
getAccessControlContext()
Delegate the creation of the access control context to the
SecurityContextProvider . |
String[] |
getAliases(String name)
Return the aliases for the given name, if defined.
|
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.
|
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 Class<?> |
getTypeForFactoryBean(String beanName,
RootBeanDefinition mbd)
Deprecated.
since 5.2 in favor of
getTypeForFactoryBean(String, RootBeanDefinition, boolean) |
protected 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 shutdown.
|
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,
ResolvableType typeToMatch)
Check whether the bean with the given name matches the specified type.
|
protected boolean |
isTypeMatch(String name,
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, e.g.
|
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(ConversionService conversionService)
Specify a Spring 3.0 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 |
setSecurityContextProvider(SecurityContextProvider securityProvider)
Set the security context provider for 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.
|
clearSingletonCache, getCachedObjectForFactoryBean, getFactoryBean, getObjectFromFactoryBean, getTypeForFactoryBean, postProcessObjectFromFactoryBean, removeSingleton
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
destroySingletons, getDependenciesForBean, getDependentBeans, isCurrentlyInCreation, registerAlias, registerDependentBean, resolveAliases, setCurrentlyInCreation
getBean, getBean, getBeanProvider, getBeanProvider
containsSingleton, getSingleton, getSingletonCount, getSingletonMutex, getSingletonNames, registerSingleton
public AbstractBeanFactory()
public AbstractBeanFactory(@Nullable BeanFactory parentBeanFactory)
parentBeanFactory
- parent bean factory, or null
if nonegetBean(java.lang.String)
public Object getBean(String name) throws BeansException
BeanFactory
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.
getBean
in interface BeanFactory
name
- the name of the bean to retrieveNoSuchBeanDefinitionException
- if there is no bean with the specified nameBeansException
- if the bean could not be obtainedpublic <T> T getBean(String name, Class<T> requiredType) throws BeansException
BeanFactory
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.
getBean
in interface BeanFactory
name
- the name of the bean to retrieverequiredType
- type the bean must match; can be an interface or superclassNoSuchBeanDefinitionException
- if there is no such bean definitionBeanNotOfRequiredTypeException
- if the bean is not of the required typeBeansException
- if the bean could not be createdpublic Object getBean(String name, Object... args) throws BeansException
BeanFactory
Allows for specifying explicit constructor arguments / factory method arguments, overriding the specified default arguments (if any) in the bean definition.
getBean
in interface BeanFactory
name
- the name of the bean to retrieveargs
- 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)NoSuchBeanDefinitionException
- if there is no such bean definitionBeanDefinitionStoreException
- if arguments have been given but
the affected bean isn't a prototypeBeansException
- if the bean could not be createdpublic <T> T getBean(String name, @Nullable Class<T> requiredType, @Nullable Object... args) throws BeansException
name
- the name of the bean to retrieverequiredType
- the required type of the bean to retrieveargs
- 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)BeansException
- if the bean could not be createdprotected <T> T doGetBean(String name, @Nullable Class<T> requiredType, @Nullable Object[] args, boolean typeCheckOnly) throws BeansException
name
- the name of the bean to retrieverequiredType
- the required type of the bean to retrieveargs
- 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 useBeansException
- if the bean could not be createdpublic boolean containsBean(String name)
BeanFactory
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.
containsBean
in interface BeanFactory
name
- the name of the bean to querypublic boolean isSingleton(String name) throws NoSuchBeanDefinitionException
BeanFactory
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.
isSingleton
in interface BeanFactory
name
- the name of the bean to queryNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanFactory.getBean(java.lang.String)
,
BeanFactory.isPrototype(java.lang.String)
public boolean isPrototype(String name) throws NoSuchBeanDefinitionException
BeanFactory
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.
isPrototype
in interface BeanFactory
name
- the name of the bean to queryNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanFactory.getBean(java.lang.String)
,
BeanFactory.isSingleton(java.lang.String)
public boolean isTypeMatch(String name, ResolvableType typeToMatch) throws NoSuchBeanDefinitionException
BeanFactory
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.
isTypeMatch
in interface BeanFactory
name
- the name of the bean to querytypeToMatch
- the type to match against (as a ResolvableType
)true
if the bean type matches,
false
if it doesn't match or cannot be determined yetNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanFactory.getBean(java.lang.String)
,
BeanFactory.getType(java.lang.String)
protected boolean isTypeMatch(String name, ResolvableType typeToMatch, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException
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.name
- the name of the bean to querytypeToMatch
- the type to match against (as a
ResolvableType
)true
if the bean type matches, false
if it
doesn't match or cannot be determined yetNoSuchBeanDefinitionException
- if there is no bean with the given namegetBean(java.lang.String)
,
getType(java.lang.String)
public boolean isTypeMatch(String name, Class<?> typeToMatch) throws NoSuchBeanDefinitionException
BeanFactory
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.
isTypeMatch
in interface BeanFactory
name
- the name of the bean to querytypeToMatch
- the type to match against (as a Class
)true
if the bean type matches,
false
if it doesn't match or cannot be determined yetNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanFactory.getBean(java.lang.String)
,
BeanFactory.getType(java.lang.String)
@Nullable public Class<?> getType(String name) throws NoSuchBeanDefinitionException
BeanFactory
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.
getType
in interface BeanFactory
name
- the name of the bean to querynull
if not determinableNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanFactory.getBean(java.lang.String)
,
BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)
@Nullable public Class<?> getType(String name, boolean allowFactoryBeanInit) throws NoSuchBeanDefinitionException
BeanFactory
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.
getType
in interface BeanFactory
name
- the name of the bean to queryallowFactoryBeanInit
- whether a FactoryBean
may get initialized
just for the purpose of determining its object typenull
if not determinableNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanFactory.getBean(java.lang.String)
,
BeanFactory.isTypeMatch(java.lang.String, org.springframework.core.ResolvableType)
public String[] getAliases(String name)
AliasRegistry
getAliases
in interface BeanFactory
getAliases
in interface AliasRegistry
getAliases
in class SimpleAliasRegistry
name
- the name to check for aliasesBeanFactory.getBean(java.lang.String)
@Nullable public BeanFactory getParentBeanFactory()
HierarchicalBeanFactory
null
if there is none.getParentBeanFactory
in interface HierarchicalBeanFactory
public boolean containsLocalBean(String name)
HierarchicalBeanFactory
This is an alternative to containsBean
, ignoring a bean
of the given name from an ancestor bean factory.
containsLocalBean
in interface HierarchicalBeanFactory
name
- the name of the bean to queryBeanFactory.containsBean(java.lang.String)
public void setParentBeanFactory(@Nullable BeanFactory parentBeanFactory)
ConfigurableBeanFactory
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.
setParentBeanFactory
in interface ConfigurableBeanFactory
parentBeanFactory
- the parent BeanFactoryHierarchicalBeanFactory.getParentBeanFactory()
public void setBeanClassLoader(@Nullable ClassLoader beanClassLoader)
ConfigurableBeanFactory
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.
setBeanClassLoader
in interface ConfigurableBeanFactory
beanClassLoader
- the class loader to use,
or null
to suggest the default class loader@Nullable public ClassLoader getBeanClassLoader()
ConfigurableBeanFactory
null
if even the system ClassLoader isn't accessible).getBeanClassLoader
in interface ConfigurableBeanFactory
ClassUtils.forName(String, ClassLoader)
public void setTempClassLoader(@Nullable ClassLoader tempClassLoader)
ConfigurableBeanFactory
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.
setTempClassLoader
in interface ConfigurableBeanFactory
@Nullable public ClassLoader getTempClassLoader()
ConfigurableBeanFactory
getTempClassLoader
in interface ConfigurableBeanFactory
public void setCacheBeanMetadata(boolean cacheBeanMetadata)
ConfigurableBeanFactory
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.
setCacheBeanMetadata
in interface ConfigurableBeanFactory
public boolean isCacheBeanMetadata()
ConfigurableBeanFactory
isCacheBeanMetadata
in interface ConfigurableBeanFactory
public void setBeanExpressionResolver(@Nullable BeanExpressionResolver resolver)
ConfigurableBeanFactory
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.
setBeanExpressionResolver
in interface ConfigurableBeanFactory
@Nullable public BeanExpressionResolver getBeanExpressionResolver()
ConfigurableBeanFactory
getBeanExpressionResolver
in interface ConfigurableBeanFactory
public void setConversionService(@Nullable ConversionService conversionService)
ConfigurableBeanFactory
setConversionService
in interface ConfigurableBeanFactory
@Nullable public ConversionService getConversionService()
ConfigurableBeanFactory
getConversionService
in interface ConfigurableBeanFactory
public void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)
ConfigurableBeanFactory
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>)
.
addPropertyEditorRegistrar
in interface ConfigurableBeanFactory
registrar
- the PropertyEditorRegistrar to registerpublic Set<PropertyEditorRegistrar> getPropertyEditorRegistrars()
public void registerCustomEditor(Class<?> requiredType, Class<? extends PropertyEditor> propertyEditorClass)
ConfigurableBeanFactory
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.
registerCustomEditor
in interface ConfigurableBeanFactory
requiredType
- type of the propertypropertyEditorClass
- the PropertyEditor
class to registerpublic void copyRegisteredEditorsTo(PropertyEditorRegistry registry)
ConfigurableBeanFactory
copyRegisteredEditorsTo
in interface ConfigurableBeanFactory
registry
- the PropertyEditorRegistry to initializepublic Map<Class<?>,Class<? extends PropertyEditor>> getCustomEditors()
public void setTypeConverter(TypeConverter typeConverter)
ConfigurableBeanFactory
This will override the default PropertyEditor mechanism and hence make any custom editors or custom editor registrars irrelevant.
@Nullable protected TypeConverter getCustomTypeConverter()
null
if none specifiedpublic TypeConverter getTypeConverter()
ConfigurableBeanFactory
If the default PropertyEditor mechanism is active, the returned TypeConverter will be aware of all custom editors that have been registered.
getTypeConverter
in interface ConfigurableBeanFactory
public void addEmbeddedValueResolver(StringValueResolver valueResolver)
ConfigurableBeanFactory
addEmbeddedValueResolver
in interface ConfigurableBeanFactory
valueResolver
- the String resolver to apply to embedded valuespublic boolean hasEmbeddedValueResolver()
ConfigurableBeanFactory
ConfigurableBeanFactory.resolveEmbeddedValue(String)
.hasEmbeddedValueResolver
in interface ConfigurableBeanFactory
@Nullable public String resolveEmbeddedValue(@Nullable String value)
ConfigurableBeanFactory
resolveEmbeddedValue
in interface ConfigurableBeanFactory
value
- the value to resolvepublic void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)
ConfigurableBeanFactory
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 (e.g. as beans in an ApplicationContext)
will always be applied after programmatically registered ones.
addBeanPostProcessor
in interface ConfigurableBeanFactory
beanPostProcessor
- the post-processor to registerpublic int getBeanPostProcessorCount()
ConfigurableBeanFactory
getBeanPostProcessorCount
in interface ConfigurableBeanFactory
public List<BeanPostProcessor> getBeanPostProcessors()
protected boolean hasInstantiationAwareBeanPostProcessors()
protected boolean hasDestructionAwareBeanPostProcessors()
public void registerScope(String scopeName, Scope scope)
ConfigurableBeanFactory
registerScope
in interface ConfigurableBeanFactory
scopeName
- the scope identifierscope
- the backing Scope implementationpublic String[] getRegisteredScopeNames()
ConfigurableBeanFactory
This will only return the names of explicitly registered scopes. Built-in scopes such as "singleton" and "prototype" won't be exposed.
getRegisteredScopeNames
in interface ConfigurableBeanFactory
ConfigurableBeanFactory.registerScope(java.lang.String, org.springframework.beans.factory.config.Scope)
@Nullable public Scope getRegisteredScope(String scopeName)
ConfigurableBeanFactory
This will only return explicitly registered scopes. Built-in scopes such as "singleton" and "prototype" won't be exposed.
getRegisteredScope
in interface ConfigurableBeanFactory
scopeName
- the name of the scopenull
if noneConfigurableBeanFactory.registerScope(java.lang.String, org.springframework.beans.factory.config.Scope)
public void setSecurityContextProvider(SecurityContextProvider securityProvider)
public AccessControlContext getAccessControlContext()
SecurityContextProvider
.getAccessControlContext
in interface ConfigurableBeanFactory
getAccessControlContext
in class FactoryBeanRegistrySupport
null
)AccessController.getContext()
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
otherFactory
- the other BeanFactory to copy frompublic BeanDefinition getMergedBeanDefinition(String name) throws BeansException
This getMergedBeanDefinition
considers bean definition
in ancestors as well.
getMergedBeanDefinition
in interface ConfigurableBeanFactory
name
- the name of the bean to retrieve the merged definition for
(may be an alias)NoSuchBeanDefinitionException
- if there is no bean with the given nameBeanDefinitionStoreException
- in case of an invalid bean definitionBeansException
public boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException
ConfigurableBeanFactory
isFactoryBean
in interface ConfigurableBeanFactory
name
- the name of the bean to checkfalse
means the bean exists but is not a FactoryBean)NoSuchBeanDefinitionException
- if there is no bean with the given namepublic boolean isActuallyInCreation(String beanName)
isActuallyInCreation
in class DefaultSingletonBeanRegistry
protected boolean isPrototypeCurrentlyInCreation(String beanName)
beanName
- the name of the beanprotected void beforePrototypeCreation(String beanName)
The default implementation register the prototype as currently in creation.
beanName
- the name of the prototype about to be createdisPrototypeCurrentlyInCreation(java.lang.String)
protected void afterPrototypeCreation(String beanName)
The default implementation marks the prototype as not in creation anymore.
beanName
- the name of the prototype that has been createdisPrototypeCurrentlyInCreation(java.lang.String)
public void destroyBean(String beanName, Object beanInstance)
ConfigurableBeanFactory
Any exception that arises during destruction should be caught and logged instead of propagated to the caller of this method.
destroyBean
in interface ConfigurableBeanFactory
beanName
- the name of the bean definitionbeanInstance
- the bean instance to destroyprotected void destroyBean(String beanName, Object bean, RootBeanDefinition mbd)
beanName
- the name of the bean definitionbean
- the bean instance to destroymbd
- the merged bean definitionpublic void destroyScopedBean(String beanName)
ConfigurableBeanFactory
Any exception that arises during destruction should be caught and logged instead of propagated to the caller of this method.
destroyScopedBean
in interface ConfigurableBeanFactory
beanName
- the name of the scoped beanprotected String transformedBeanName(String name)
name
- the user-specified nameprotected String originalBeanName(String name)
name
- the user-specified nameprotected void initBeanWrapper(BeanWrapper bw)
The default implementation delegates to registerCustomEditors(org.springframework.beans.PropertyEditorRegistry)
.
Can be overridden in subclasses.
bw
- the BeanWrapper to initializeprotected void registerCustomEditors(PropertyEditorRegistry registry)
To be called for BeanWrappers that will create and populate bean instances, and for SimpleTypeConverter used for constructor argument and factory method type conversion.
registry
- the PropertyEditorRegistry to initializeprotected RootBeanDefinition getMergedLocalBeanDefinition(String beanName) throws BeansException
beanName
- the name of the bean to retrieve the merged definition forNoSuchBeanDefinitionException
- if there is no bean with the given nameBeanDefinitionStoreException
- in case of an invalid bean definitionBeansException
protected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd) throws BeanDefinitionStoreException
beanName
- the name of the bean definitionbd
- the original bean definition (Root/ChildBeanDefinition)BeanDefinitionStoreException
- in case of an invalid bean definitionprotected RootBeanDefinition getMergedBeanDefinition(String beanName, BeanDefinition bd, @Nullable BeanDefinition containingBd) throws BeanDefinitionStoreException
beanName
- the name of the bean definitionbd
- the original bean definition (Root/ChildBeanDefinition)containingBd
- the containing bean definition in case of inner bean,
or null
in case of a top-level beanBeanDefinitionStoreException
- in case of an invalid bean definitionprotected void checkMergedBeanDefinition(RootBeanDefinition mbd, String beanName, @Nullable Object[] args) throws BeanDefinitionStoreException
mbd
- the merged bean definition to checkbeanName
- the name of the beanargs
- the arguments for bean creation, if anyBeanDefinitionStoreException
- in case of validation failureprotected void clearMergedBeanDefinition(String beanName)
beanName
- the bean name to clear the merged definition forpublic void clearMetadataCache()
Typically triggered after changes to the original bean definitions,
e.g. after applying a BeanFactoryPostProcessor
. Note that metadata
for beans which have already been created at this point will be kept around.
@Nullable protected Class<?> resolveBeanClass(RootBeanDefinition mbd, String beanName, Class<?>... typesToMatch) throws CannotLoadBeanClassException
mbd
- the merged bean definition to determine the class forbeanName
- 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)null
if none)CannotLoadBeanClassException
- if we failed to load the class@Nullable protected Object evaluateBeanDefinitionString(@Nullable String value, @Nullable BeanDefinition beanDefinition)
value
- the value to checkbeanDefinition
- the bean definition that the value comes fromsetBeanExpressionResolver(org.springframework.beans.factory.config.BeanExpressionResolver)
@Nullable protected Class<?> predictBeanType(String beanName, RootBeanDefinition mbd, Class<?>... typesToMatch)
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.
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 predictableprotected boolean isFactoryBean(String beanName, RootBeanDefinition mbd)
FactoryBean
.beanName
- the name of the beanmbd
- the corresponding bean definitionprotected ResolvableType getTypeForFactoryBean(String beanName, RootBeanDefinition mbd, boolean allowInit)
allowInit
is true
, otherwise they should try to determine the
result through other means.
If no FactoryBean.OBJECT_TYPE_ATTRIBUTE
if 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.
beanName
- the name of the beanmbd
- the merged bean definition for the beanallowInit
- if initialization of the FactoryBean is permittedResolvableType.NONE
FactoryBean.getObjectType()
,
getBean(String)
@Nullable @Deprecated protected Class<?> getTypeForFactoryBean(String beanName, RootBeanDefinition mbd)
getTypeForFactoryBean(String, RootBeanDefinition, boolean)
The default implementation creates the FactoryBean via getBean
to call its getObjectType
method. Subclasses are encouraged to optimize
this, typically by just instantiating the FactoryBean but not populating it yet,
trying whether its getObjectType
method already returns a type.
If no type found, a full FactoryBean creation as performed by this implementation
should be used as fallback.
beanName
- the name of the beanmbd
- the merged bean definition for the beannull
otherwiseFactoryBean.getObjectType()
,
getBean(String)
protected void markBeanAsCreated(String beanName)
This allows the bean factory to optimize its caching for repeated creation of the specified bean.
beanName
- the name of the beanprotected void cleanupAfterBeanCreationFailure(String beanName)
beanName
- the name of the beanprotected boolean isBeanEligibleForMetadataCaching(String beanName)
beanName
- the name of the beantrue
if the bean's metadata may be cached
at this point alreadyprotected boolean removeSingletonIfCreatedForTypeCheckOnly(String beanName)
beanName
- the name of the beantrue
if actually removed, false
otherwiseprotected boolean hasBeanCreationStarted()
markBeanAsCreated(java.lang.String)
protected Object getObjectForBeanInstance(Object beanInstance, String name, String beanName, @Nullable RootBeanDefinition mbd)
beanInstance
- the shared bean instancename
- name that may include factory dereference prefixbeanName
- the canonical bean namembd
- the merged bean definitionpublic boolean isBeanNameInUse(String beanName)
beanName
- the name to checkprotected boolean requiresDestruction(Object bean, RootBeanDefinition mbd)
The default implementation checks the DisposableBean interface as well as a specified destroy method and registered DestructionAwareBeanPostProcessors.
bean
- the bean instance to checkmbd
- the corresponding bean definitionDisposableBean
,
AbstractBeanDefinition.getDestroyMethodName()
,
DestructionAwareBeanPostProcessor
protected void registerDisposableBeanIfNecessary(String beanName, Object bean, RootBeanDefinition mbd)
beanName
- the name of the beanbean
- the bean instancembd
- the bean definition for the beanAbstractBeanDefinition.isSingleton()
,
AbstractBeanDefinition.getDependsOn()
,
DefaultSingletonBeanRegistry.registerDisposableBean(java.lang.String, org.springframework.beans.factory.DisposableBean)
,
DefaultSingletonBeanRegistry.registerDependentBean(java.lang.String, java.lang.String)
protected abstract boolean containsBeanDefinition(String beanName)
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.
beanName
- the name of the bean to look forcontainsBean(java.lang.String)
,
ListableBeanFactory.containsBeanDefinition(java.lang.String)
protected abstract BeanDefinition getBeanDefinition(String beanName) throws BeansException
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.
beanName
- the name of the bean to find a definition fornull
)NoSuchBeanDefinitionException
- if the bean definition cannot be resolvedBeansException
- in case of errorsRootBeanDefinition
,
ChildBeanDefinition
,
ConfigurableListableBeanFactory.getBeanDefinition(java.lang.String)
protected abstract Object createBean(String beanName, RootBeanDefinition mbd, @Nullable Object[] args) throws BeanCreationException
All bean retrieval methods delegate to this method for actual bean creation.
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 created