open class CommonAnnotationBeanPostProcessor : InitDestroyAnnotationBeanPostProcessor, InstantiationAwareBeanPostProcessor, BeanFactoryAware, Serializable
org.springframework.beans.factory.config.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/6 (which provides a standalone jar for its common annotations as well, allowing for use in any Java 5 based application).
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"/> <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.
Author
Juergen Hoeller
Since
2.5
See Also
#setAlwaysUseJndiLookup#setResourceFactoryorg.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessororg.springframework.beans.factory.annotation.AutowiredAnnotationBeanPostProcessor
CommonAnnotationBeanPostProcessor()
Create a new CommonAnnotationBeanPostProcessor, with the init and destroy annotation types set to javax.annotation.PostConstruct and javax.annotation.PreDestroy, respectively. |
open fun ignoreResourceType(resourceType: String): Unit
Ignore the given resource type when resolving By default, the |
|
open fun postProcessAfterInstantiation(bean: Any, beanName: String): Boolean |
|
open fun postProcessBeforeInstantiation(beanClass: Class<*>, beanName: String): Any |
|
open fun postProcessMergedBeanDefinition(beanDefinition: RootBeanDefinition, beanType: Class<*>, beanName: String): Unit |
|
open fun postProcessPropertyValues(pvs: PropertyValues, pds: Array<PropertyDescriptor>, bean: Any, beanName: String): PropertyValues |
|
open fun setAlwaysUseJndiLookup(alwaysUseJndiLookup: Boolean): Unit
Set whether to always use JNDI lookups equivalent to standard Java EE 5 resource injection, even for Default is "false": Resource names are used for Spring bean lookups in the containing BeanFactory; only |
|
open fun setBeanFactory(beanFactory: BeanFactory): Unit |
|
open fun setFallbackToDefaultTypeMatch(fallbackToDefaultTypeMatch: Boolean): Unit
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. |
|
open fun setJndiFactory(jndiFactory: BeanFactory): Unit
Specify the factory for objects to be injected into The default is a org.springframework.jndi.support.SimpleJndiBeanFactory for JNDI lookup behavior equivalent to standard Java EE 5 resource injection. |
|
open fun setResourceFactory(resourceFactory: BeanFactory): Unit
Specify the factory for objects to be injected into 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 org.springframework.jndi.support.SimpleJndiBeanFactory leads to JNDI lookup behavior equivalent to standard Java EE 5 resource injection, even for |
open fun getOrder(): Int |
|
open fun postProcessAfterInitialization(bean: Any, beanName: String): Any |
|
open fun postProcessBeforeDestruction(bean: Any, beanName: String): Unit |
|
open fun postProcessBeforeInitialization(bean: Any, beanName: String): Any |
|
open fun requiresDestruction(bean: Any): Boolean |
|
open fun setDestroyAnnotationType(destroyAnnotationType: Class<out Annotation>): Unit
Specify the destroy annotation to check for, indicating destruction methods to call when the context is shutting down. Any custom annotation can be used, since there are no required annotation attributes. There is no default, although a typical choice is the JSR-250 javax.annotation.PreDestroy annotation. |
|
open fun setInitAnnotationType(initAnnotationType: Class<out Annotation>): Unit
Specify the init annotation to check for, indicating initialization methods to call after configuration of a bean. Any custom annotation can be used, since there are no required annotation attributes. There is no default, although a typical choice is the JSR-250 javax.annotation.PostConstruct annotation. |
|
open fun setOrder(order: Int): Unit |