java.lang.Object | ||
↳ | org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor | |
↳ | org.springframework.context.annotation.CommonAnnotationBeanPostProcessor |
BeanPostProcessor
implementation
that supports common Java annotations out of the box, in particular the JSR-250
annotations in the javax.annotation
package. These common Java
annotations are supported in many Java EE 5 technologies (e.g. JSF 1.2),
as well as in Java 6's JAX-WS.
This post-processor includes support for the javax.annotation.PostConstruct
and javax.annotation.PreDestroy annotations - as init annotation
and destroy annotation, respectively - through inheriting from
InitDestroyAnnotationBeanPostProcessor
with pre-configured annotation types.
The central element is the javax.annotation.Resource annotation
for annotation-driven injection of named beans, by default from the containing
Spring BeanFactory, with only mappedName
references resolved in JNDI.
The "alwaysUseJndiLookup" flag
enforces JNDI lookups
equivalent to standard Java EE 5 resource injection for name
references
and default names as well. The target beans can be simple POJOs, with no special
requirements other than the type having to match.
The JAX-WS javax.xml.ws.WebServiceRef annotation is supported too, analogous to javax.annotation.Resource but with the capability of creating specific JAX-WS service endpoints. This may either point to an explicitly defined resource by name or operate on a locally specified JAX-WS service class. Finally, this post-processor also supports the EJB 3 javax.ejb.EJB annotation, analogous to javax.annotation.Resource as well, with the capability to specify both a local bean name and a global JNDI name for fallback retrieval. The target beans can be plain POJOs as well as EJB 3 Session Beans in this case.
The common annotations supported by this post-processor are available in Java 6 (JDK 1.6) as well as in Java EE 5 (which provides a standalone jar for its common annotations as well, allowing for use in any Java 5 based application). Hence, this post-processor works out of the box on JDK 1.6, and requires the JSR-250 API jar (and optionally the JAX-WS API jar and/or the EJB 3 API jar) to be added to the classpath on JDK 1.5 (when running outside of Java EE 5).
For default usage, resolving resource names as Spring bean names, simply define the following in your application context:
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"/>For direct JNDI access, resolving resource names as JNDI resource references within the Java EE application's "java:comp/env/" namespace, use the following:
<bean class="org.springframework.context.annotation.CommonAnnotationBeanPostProcessor"> <property name="alwaysUseJndiLookup" value="true"/> </bean>
mappedName
references will always be resolved in JNDI,
allowing for global JNDI names (including "java:" prefix) as well. The
"alwaysUseJndiLookup" flag just affects name
references and
default names (inferred from the field name / property name).
NOTE: A default CommonAnnotationBeanPostProcessor will be registered by the "context:annotation-config" and "context:component-scan" XML tags. Remove or turn off the default annotation configuration there if you intend to specify a custom CommonAnnotationBeanPostProcessor bean definition!
NOTE: Annotation injection will be performed before XML injection; thus the latter configuration will override the former for properties wired through both approaches.
Nested Classes | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
CommonAnnotationBeanPostProcessor.LookupElement | Class representing generic injection information about an annotated field or setter method, supporting @Resource and related annotations. |
[Expand]
Inherited Constants | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From interface
org.springframework.core.Ordered
|
[Expand]
Inherited Fields | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor
|
Public Constructors | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Create a new CommonAnnotationBeanPostProcessor,
with the init and destroy annotation types set to
javax.annotation.PostConstruct and javax.annotation.PreDestroy,
respectively.
|
Public Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Ignore the given resource type when resolving
@Resource
annotations. | |||||||||||
Perform operations after the bean has been instantiated, via a constructor or factory method,
but before Spring property population (from explicit properties or autowiring) occurs.
| |||||||||||
Post-process the given property values before the factory applies them
to the given bean.
| |||||||||||
Set whether to always use JNDI lookups equivalent to standard Java EE 5 resource
injection, even for
name attributes and default names. | |||||||||||
Callback that supplies the owning factory to a bean instance.
| |||||||||||
Set whether to allow a fallback to a type match if no explicit name has been
specified.
| |||||||||||
Specify the factory for objects to be injected into
@Resource /
@WebServiceRef / @EJB annotated fields and setter methods,
for mappedName attributes that point directly into JNDI. | |||||||||||
Specify the factory for objects to be injected into
@Resource /
@WebServiceRef / @EJB annotated fields and setter methods,
for name attributes and default names. |
Protected Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
Obtain a resource object for the given name and type through autowiring
based on the given factory.
| |||||||||||
Obtain the resource object for the given name and type.
|
[Expand]
Inherited Methods | |||||||||||
---|---|---|---|---|---|---|---|---|---|---|---|
From class
org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor
| |||||||||||
From class
java.lang.Object
| |||||||||||
From interface
org.springframework.beans.factory.BeanFactoryAware
| |||||||||||
From interface
org.springframework.beans.factory.config.BeanPostProcessor
| |||||||||||
From interface
org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor
| |||||||||||
From interface
org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor
| |||||||||||
From interface
org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor
| |||||||||||
From interface
org.springframework.core.Ordered
|
Create a new CommonAnnotationBeanPostProcessor, with the init and destroy annotation types set to javax.annotation.PostConstruct and javax.annotation.PreDestroy, respectively.
Ignore the given resource type when resolving @Resource
annotations.
By default, the javax.xml.ws.WebServiceContext
interface
will be ignored, since it will be resolved by the JAX-WS runtime.
resourceType | the resource type to ignore |
---|
Perform operations after the bean has been instantiated, via a constructor or factory method, but before Spring property population (from explicit properties or autowiring) occurs.
This is the ideal callback for performing field injection on the given bean instance.
See Spring's own AutowiredAnnotationBeanPostProcessor
for a typical example.
bean | the bean instance created, with properties not having been set yet |
---|---|
beanName | the name of the bean |
true
if properties should be set on the bean; false
if property population should be skipped. Normal implementations should return true
.
Returning false
will also prevent any subsequent InstantiationAwareBeanPostProcessor
instances being invoked on this bean instance.BeansException |
---|
BeansException |
---|
Post-process the given property values before the factory applies them to the given bean. Allows for checking whether all dependencies have been satisfied, for example based on a "Required" annotation on bean property setters.
Also allows for replacing the property values to apply, typically through creating a new MutablePropertyValues instance based on the original PropertyValues, adding or removing specific values.
pvs | the property values that the factory is about to apply (never null ) |
---|---|
pds | the relevant property descriptors for the target bean (with ignored dependency types - which the factory handles specifically - already filtered out) |
bean | the bean instance created, but whose properties have not yet been set |
beanName | the name of the bean |
null
to skip property populationBeansException |
---|
Set whether to always use JNDI lookups equivalent to standard Java EE 5 resource
injection, even for name
attributes and default names.
Default is "false": Resource names are used for Spring bean lookups in the
containing BeanFactory; only mappedName
attributes point directly
into JNDI. Switch this flag to "true" for enforcing Java EE style JNDI lookups
in any case, even for name
attributes and default names.
Callback that supplies the owning factory to a bean instance.
Invoked after the population of normal bean properties
but before an initialization callback such as
afterPropertiesSet()
or a custom init-method.
beanFactory | owning BeanFactory (never null ).
The bean can immediately call methods on the factory. |
---|
BeansException |
---|
Set whether to allow a fallback to a type match if no explicit name has been specified. The default name (i.e. the field name or bean property name) will still be checked first; if a bean of that name exists, it will be taken. However, if no bean of that name exists, a by-type resolution of the dependency will be attempted if this flag is "true".
Default is "true". Switch this flag to "false" in order to enforce a by-name lookup in all cases, throwing an exception in case of no name match.
Specify the factory for objects to be injected into @Resource
/
@WebServiceRef
/ @EJB
annotated fields and setter methods,
for mappedName
attributes that point directly into JNDI.
This factory will also be used if "alwaysUseJndiLookup" is set to "true" in order
to enforce JNDI lookups even for name
attributes and default names.
The default is a SimpleJndiBeanFactory
for JNDI lookup behavior equivalent to standard Java EE 5 resource injection.
Specify the factory for objects to be injected into @Resource
/
@WebServiceRef
/ @EJB
annotated fields and setter methods,
for name
attributes and default names.
The default is the BeanFactory that this post-processor is defined in, if any, looking up resource names as Spring bean names. Specify the resource factory explicitly for programmatic usage of this post-processor.
Specifying Spring's SimpleJndiBeanFactory
leads to JNDI lookup behavior equivalent to standard Java EE 5 resource injection,
even for name
attributes and default names. This is the same behavior
that the "alwaysUseJndiLookup" flag enables.
Obtain a resource object for the given name and type through autowiring based on the given factory.
factory | the factory to autowire against |
---|---|
element | the descriptor for the annotated field/method |
requestingBeanName | the name of the requesting bean |
null
)BeansException | if we failed to obtain the target resource |
---|
Obtain the resource object for the given name and type.
element | the descriptor for the annotated field/method |
---|---|
requestingBeanName | the name of the requesting bean |
null
)BeansException | if we failed to obtain the target resource |
---|