| org.springframework.beans.factory.config.ConfigurableBeanFactory
| Method Summary | |
| void | addBeanPostProcessor(BeanPostProcessor beanPostProcessor)
Add a new BeanPostProcessor that will get applied to beans created
by this factory. | | void | addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)
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. | | void | copyConfigurationFrom(ConfigurableBeanFactory otherFactory)
Copy all relevant configuration from the given other factory. | | void | destroyBean(String beanName, Object beanInstance)
Destroy the given bean instance (usually a prototype instance
obtained from this factory) according to its bean definition. | | void | destroyScopedBean(String beanName)
Destroy the specified scoped bean in the current target scope, if any. | | void | destroySingletons()
Destroy all singleton beans in this factory, including inner beans that have
been registered as disposable. | | ClassLoader | getBeanClassLoader()
Return this factory's class loader for loading bean classes. | | int | getBeanPostProcessorCount()
Return the current number of registered BeanPostProcessors, if any. | | String[] | getDependenciesForBean(String beanName)
Return the names of all beans that the specified bean depends on, if any. | | String[] | getDependentBeans(String beanName)
Return the names of all beans which depend on the specified bean, if any. | | BeanDefinition | getMergedBeanDefinition(String beanName)
Return a merged BeanDefinition for the given bean name,
merging a child bean definition with its parent if necessary. | | 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. | | TypeConverter | getTypeConverter()
Obtain a type converter as used by this BeanFactory. | | boolean | isCacheBeanMetadata()
Return whether to cache bean metadata such as given bean definitions
(in merged fashion) and resolved bean classes. | | boolean | isCurrentlyInCreation(String beanName)
Determine whether the specified bean is currently in creation. | | boolean | isFactoryBean(String name)
Determine whether the bean with the given name is a FactoryBean. | | void | registerAlias(String beanName, String alias)
Given a bean name, create an alias. | | void | registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)
Register the given custom property editor for all properties of the
given type. | | void | registerDependentBean(String beanName, String dependentBeanName)
Register a dependent bean for the given bean,
to be destroyed before the given bean is destroyed. | | void | registerScope(String scopeName, Scope scope)
Register the given scope, backed by the given Scope implementation. | | void | resolveAliases(StringValueResolver valueResolver)
Resolve all alias target names and aliases registered in this
factory, applying the given StringValueResolver to them. | | void | setBeanClassLoader(ClassLoader beanClassLoader)
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. | | void | setCacheBeanMetadata(boolean cacheBeanMetadata)
Set whether to cache bean metadata such as given bean definitions
(in merged fashion) and resolved bean classes. | | 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.
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. | | void | setTypeConverter(TypeConverter typeConverter)
Set a custom type converter that this BeanFactory should use for converting
bean property values, constructor argument values, etc. |
| addBeanPostProcessor | | void addBeanPostProcessor(BeanPostProcessor beanPostProcessor)(Code) | | Add a new BeanPostProcessor that will get applied to beans created
by this factory. To be invoked during factory configuration.
Parameters:
beanPostProcessor - the bean processor to register |
| addPropertyEditorRegistrar | | void addPropertyEditorRegistrar(PropertyEditorRegistrar registrar)(Code) | | 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 .
Parameters:
registrar - the PropertyEditorRegistrar to register |
| copyConfigurationFrom | | void copyConfigurationFrom(ConfigurableBeanFactory otherFactory)(Code) | | 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.
Parameters:
otherFactory - the other BeanFactory to copy from |
| destroyBean | | void destroyBean(String beanName, Object beanInstance)(Code) | | 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.
Parameters:
beanName - the name of the bean definition
Parameters:
beanInstance - the bean instance to destroy |
| destroyScopedBean | | void destroyScopedBean(String beanName)(Code) | | 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.
Parameters:
beanName - the name of the scoped bean |
| destroySingletons | | void destroySingletons()(Code) | | Destroy all singleton beans in this factory, including inner beans that have
been registered as disposable. To be called on shutdown of a factory.
Any exception that arises during destruction should be caught
and logged instead of propagated to the caller of this method.
|
| getBeanClassLoader | | ClassLoader getBeanClassLoader()(Code) | | Return this factory's class loader for loading bean classes.
|
| getBeanPostProcessorCount | | int getBeanPostProcessorCount()(Code) | | Return the current number of registered BeanPostProcessors, if any.
|
| getDependenciesForBean | | String[] getDependenciesForBean(String beanName)(Code) | | Return the names of all beans that the specified bean depends on, if any.
Parameters:
beanName - the name of the bean the array of names of beans which the bean depends on,or an empty array if none |
| getDependentBeans | | String[] getDependentBeans(String beanName)(Code) | | Return the names of all beans which depend on the specified bean, if any.
Parameters:
beanName - the name of the bean the array of dependent bean names, or an empty array if none |
| getMergedBeanDefinition | | BeanDefinition getMergedBeanDefinition(String beanName) throws NoSuchBeanDefinitionException(Code) | | Return a merged BeanDefinition for the given bean name,
merging a child bean definition with its parent if necessary.
Considers bean definitions in ancestor factories as well.
Parameters:
beanName - the name of the bean to retrieve the merged definition for a (potentially merged) BeanDefinition for the given bean
throws:
NoSuchBeanDefinitionException - if there is no bean definition with the given name |
| getRegisteredScope | | Scope getRegisteredScope(String scopeName)(Code) | | 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.
Parameters:
scopeName - the name of the scope the registered Scope implementation, or null if none
See Also: ConfigurableBeanFactory.registerScope |
| getRegisteredScopeNames | | String[] getRegisteredScopeNames()(Code) | | 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.
the array of scope names, or an empty array if none
See Also: ConfigurableBeanFactory.registerScope |
| getTempClassLoader | | ClassLoader getTempClassLoader()(Code) | | Return the temporary ClassLoader to use for type matching purposes,
if any.
|
| getTypeConverter | | TypeConverter getTypeConverter()(Code) | | 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.
|
| isCacheBeanMetadata | | boolean isCacheBeanMetadata()(Code) | | Return whether to cache bean metadata such as given bean definitions
(in merged fashion) and resolved bean classes.
|
| isCurrentlyInCreation | | boolean isCurrentlyInCreation(String beanName)(Code) | | Determine whether the specified bean is currently in creation.
Parameters:
beanName - the name of the bean whether the bean is currently in creation |
| isFactoryBean | | boolean isFactoryBean(String name) throws NoSuchBeanDefinitionException(Code) | | Determine whether the bean with the given name is a FactoryBean.
Parameters:
name - the name of the bean to check 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 |
| registerAlias | | void registerAlias(String beanName, String alias) throws BeanDefinitionStoreException(Code) | | Given a bean name, create an alias. We typically use this method to
support names that are illegal within XML ids (used for bean names).
Typically invoked during factory configuration, but can also be
used for runtime registration of aliases. Therefore, a factory
implementation should synchronize alias access.
Parameters:
beanName - the canonical name of the target bean
Parameters:
alias - the alias to be registered for the bean
throws:
BeanDefinitionStoreException - if the alias is already in use |
| registerCustomEditor | | void registerCustomEditor(Class requiredType, PropertyEditor propertyEditor)(Code) | | 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 prefable to use
ConfigurableBeanFactory.addPropertyEditorRegistrar instead
of this method, to avoid for the need for synchronization on custom editors.
Parameters:
requiredType - type of the property
Parameters:
propertyEditor - editor to registerConfigurableBeanFactory.addPropertyEditorRegistrar |
| registerDependentBean | | void registerDependentBean(String beanName, String dependentBeanName)(Code) | | Register a dependent bean for the given bean,
to be destroyed before the given bean is destroyed.
Parameters:
beanName - the name of the bean
Parameters:
dependentBeanName - the name of the dependent bean |
| registerScope | | void registerScope(String scopeName, Scope scope)(Code) | | Register the given scope, backed by the given Scope implementation.
Parameters:
scopeName - the scope identifier
Parameters:
scope - the backing Scope implementation |
| resolveAliases | | void resolveAliases(StringValueResolver valueResolver)(Code) | | Resolve all alias target names and aliases registered in this
factory, applying the given StringValueResolver to them.
The value resolver may for example resolve placeholders
in target bean names and even in alias names.
Parameters:
valueResolver - the StringValueResolver to apply |
| setBeanClassLoader | | void setBeanClassLoader(ClassLoader beanClassLoader)(Code) | | 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.
Parameters:
beanClassLoader - the class loader to use,or null to suggest the default class loader |
| setCacheBeanMetadata | | void setCacheBeanMetadata(boolean cacheBeanMetadata)(Code) | | 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.
|
| setTempClassLoader | | void setTempClassLoader(ClassLoader tempClassLoader)(Code) | | 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.
|
|
|