org.springframework.beans.factory.config.AutowireCapableBeanFactory |
Known Indirect Subclasses |
Extension of the BeanFactory
interface to be implemented by bean factories that are capable of
autowiring, provided that they want to expose this functionality for
existing bean instances.
This subinterface of BeanFactory is not meant to be used in normal
application code: stick to BeanFactory
or ListableBeanFactory
for
typical use cases.
Integration code for other frameworks can leverage this interface to wire and populate existing bean instances that Spring does not control the lifecycle of. This is particularly useful for WebWork Actions and Tapestry Page objects, for example.
Note that this interface is not implemented by
ApplicationContext
facades,
as it is hardly ever used by application code. That said, it is available
from an application context too, accessible through ApplicationContext's
getAutowireCapableBeanFactory()
method.
You may also implement the BeanFactoryAware
interface, which exposes the internal BeanFactory even when running in an
ApplicationContext, to get access to an AutowireCapableBeanFactory:
simply cast the passed-in BeanFactory to AutowireCapableBeanFactory.
Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
int | AUTOWIRE_AUTODETECT | This constant is deprecated. as of Spring 3.0: If you are using mixed autowiring strategies, prefer annotation-based autowiring for clearer demarcation of autowiring needs. | |||||||||
int | AUTOWIRE_BY_NAME | Constant that indicates autowiring bean properties by name (applying to all bean property setters). | |||||||||
int | AUTOWIRE_BY_TYPE | Constant that indicates autowiring bean properties by type (applying to all bean property setters). | |||||||||
int | AUTOWIRE_CONSTRUCTOR | Constant that indicates autowiring the greediest constructor that can be satisfied (involves resolving the appropriate constructor). | |||||||||
int | AUTOWIRE_NO | Constant that indicates no externally defined autowiring. |
[Expand]
Inherited Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From interface
org.springframework.beans.factory.BeanFactory
|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Apply
BeanPostProcessors to the given existing bean
instance, invoking their postProcessAfterInitialization methods. | |||||||||||
Apply
BeanPostProcessors to the given existing bean
instance, invoking their postProcessBeforeInitialization methods. | |||||||||||
Apply the property values of the bean definition with the given name to
the given bean instance.
| |||||||||||
Instantiate a new bean instance of the given class with the specified autowire
strategy.
| |||||||||||
Populate the given bean instance through applying after-instantiation callbacks
and bean property post-processing (e.g.
| |||||||||||
Autowire the bean properties of the given bean instance by name or type.
| |||||||||||
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). | |||||||||||
Fully create a new bean instance of the given class with the specified
autowire strategy.
| |||||||||||
Fully create a new bean instance of the given class.
| |||||||||||
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). | |||||||||||
Resolve the specified dependency against the beans defined in this factory.
| |||||||||||
Resolve the specified dependency against the beans defined in this factory.
|
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From interface
org.springframework.beans.factory.BeanFactory
|
This constant is deprecated.
as of Spring 3.0: If you are using mixed autowiring strategies,
prefer annotation-based autowiring for clearer demarcation of autowiring needs.
Constant that indicates determining an appropriate autowire strategy through introspection of the bean class.
Constant that indicates autowiring bean properties by name (applying to all bean property setters).
Constant that indicates autowiring bean properties by type (applying to all bean property setters).
Constant that indicates autowiring the greediest constructor that can be satisfied (involves resolving the appropriate constructor).
Constant that indicates no externally defined autowiring. Note that BeanFactoryAware etc and annotation-driven injection will still be applied.
Apply BeanPostProcessors
to the given existing bean
instance, invoking their postProcessAfterInitialization
methods.
The returned bean instance may be a wrapper around the original.
existingBean | the new bean instance |
---|---|
beanName | the name of the bean |
BeansException | if any post-processing failed |
---|
Apply BeanPostProcessors
to the given existing bean
instance, invoking their postProcessBeforeInitialization
methods.
The returned bean instance may be a wrapper around the original.
existingBean | the new bean instance |
---|---|
beanName | the name of the bean |
BeansException | if any post-processing failed |
---|
Apply the property values of the bean definition with the given name to the given bean instance. The bean definition can either define a fully self-contained bean, reusing its property values, or just property values meant to be used for existing bean instances.
This method does not autowire bean properties; it just applies
explicitly defined property values. Use the autowireBeanProperties(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
initializeBean(Object, String)
. However, InstantiationAwareBeanPostProcessor
callbacks are applied, if applicable to the configuration of the instance.
existingBean | the existing bean instance |
---|---|
beanName | the name of the bean definition in the bean factory (a bean definition of that name has to be available) |
NoSuchBeanDefinitionException | if there is no bean definition with the given name |
---|---|
BeansException | if applying the property values failed |
Instantiate a new bean instance of the given class with the specified autowire
strategy. All constants defined in this interface are supported here.
Can also be invoked with AUTOWIRE_NO
in order to just apply
before-instantiation callbacks (e.g. for annotation-driven injection).
Does not apply standard BeanPostProcessors
callbacks or perform any further initialization of the bean. This interface
offers distinct, fine-grained operations for those purposes, for example
initializeBean(Object, String)
. However, InstantiationAwareBeanPostProcessor
callbacks are applied, if applicable to the construction of the instance.
beanClass | the class of the bean to instantiate |
---|---|
autowireMode | by name or type, using the constants in this interface |
dependencyCheck | whether to perform a dependency check for object references in the bean instance (not applicable to autowiring a constructor, thus ignored there) |
BeansException | if instantiation or wiring failed |
---|
Populate the given bean instance through applying after-instantiation callbacks and bean property post-processing (e.g. for annotation-driven injection).
Note: This is essentially intended for (re-)populating annotated fields and
methods, either for new instances or for deserialized instances. It does
not imply traditional by-name or by-type autowiring of properties;
use autowireBeanProperties(Object, int, boolean)
for that purposes.
existingBean | the existing bean instance |
---|
BeansException | if wiring failed |
---|
Autowire the bean properties of the given bean instance by name or type.
Can also be invoked with AUTOWIRE_NO
in order to just apply
after-instantiation callbacks (e.g. for annotation-driven injection).
Does not apply standard BeanPostProcessors
callbacks or perform any further initialization of the bean. This interface
offers distinct, fine-grained operations for those purposes, for example
initializeBean(Object, String)
. However, InstantiationAwareBeanPostProcessor
callbacks are applied, if applicable to the configuration of the instance.
existingBean | the existing bean instance |
---|---|
autowireMode | by name or type, using the constants in this interface |
dependencyCheck | whether to perform a dependency check for object references in the bean instance |
BeansException | if wiring failed |
---|
Configure the given raw bean: autowiring bean properties, applying
bean property values, applying factory callbacks such as setBeanName
and setBeanFactory
, and also applying all bean post processors
(including ones which might wrap the given raw bean).
This is effectively a superset of what initializeBean(Object, String)
provides,
fully applying the configuration specified by the corresponding bean definition.
Note: This method requires a bean definition for the given name!
existingBean | the existing bean instance |
---|---|
beanName | the name of the bean, to be passed to it if necessary (a bean definition of that name has to be available) |
NoSuchBeanDefinitionException | if there is no bean definition with the given name |
---|---|
BeansException | if the initialization failed |
Fully create a new bean instance of the given class with the specified autowire strategy. All constants defined in this interface are supported here.
Performs full initialization of the bean, including all applicable
BeanPostProcessors
. This is effectively a superset
of what autowire(Class, int, boolean)
provides, adding initializeBean(Object, String)
behavior.
beanClass | the class of the bean to create |
---|---|
autowireMode | by name or type, using the constants in this interface |
dependencyCheck | whether to perform a dependency check for objects (not applicable to autowiring a constructor, thus ignored there) |
BeansException | if instantiation or wiring failed |
---|
Fully create a new bean instance of the given class.
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 initialiation callbacks.
It does not> imply traditional by-name or by-type autowiring of properties;
use createBean(Class, int, boolean)
for that purposes.
beanClass | the class of the bean to create |
---|
BeansException | if instantiation or wiring failed |
---|
Initialize the given raw bean, applying factory callbacks
such as setBeanName
and setBeanFactory
,
also applying all bean post processors (including ones which
might wrap the given raw bean).
Note that no bean definition of the given name has to exist in the bean factory. The passed-in bean name will simply be used for callbacks but not checked against the registered bean definitions.
existingBean | the existing bean instance |
---|---|
beanName | the name of the bean, to be passed to it if necessary
(only passed to BeanPostProcessors ) |
BeansException | if the initialization failed |
---|
Resolve the specified dependency against the beans defined in this factory.
descriptor | the descriptor for the dependency |
---|---|
beanName | the name of the bean which declares the present dependency |
null
if none foundBeansException | in dependency resolution failed |
---|
Resolve the specified dependency against the beans defined in this factory.
descriptor | the descriptor for the dependency |
---|---|
beanName | the name of the bean which declares the present dependency |
autowiredBeanNames | a Set that all names of autowired beans (used for resolving the present dependency) are supposed to be added to |
typeConverter | the TypeConverter to use for populating arrays and collections |
null
if none foundBeansException | in dependency resolution failed |
---|