org.springframework.context.annotation

## 类 CommonAnnotationBeanPostProcessor

- java.lang.Object
- - org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor
  - - org.springframework.context.annotation.CommonAnnotationBeanPostProcessor

- 所有已实现的接口:
    Serializable, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanFactoryAware, org.springframework.beans.factory.config.BeanPostProcessor, org.springframework.beans.factory.config.DestructionAwareBeanPostProcessor, org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor, org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor, org.springframework.core.Ordered, org.springframework.core.PriorityOrdered

      public class CommonAnnotationBeanPostProcessor
      extends org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor
      implements org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor, org.springframework.beans.factory.BeanFactoryAware, Serializable

  `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 `PostConstruct` and `PreDestroy` annotations - as init annotation and destroy annotation, respectively - through inheriting from `InitDestroyAnnotationBeanPostProcessor` with pre-configured annotation types.

  The central element is the `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 `WebServiceRef` annotation is supported too, analogous to `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 `EJB` annotation, analogous to `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"/>

  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.

  从以下版本开始:
    2.5
  作者:
    Juergen Hoeller
  另请参阅:
    `setAlwaysUseJndiLookup(boolean)`, `setResourceFactory(org.springframework.beans.factory.BeanFactory)`, `InitDestroyAnnotationBeanPostProcessor`, `AutowiredAnnotationBeanPostProcessor`, 序列化表格

- - ### 嵌套类概要

    嵌套类
    限定符和类型 | 类和说明
    --- | ---
    `protected class` | `CommonAnnotationBeanPostProcessor.LookupElement` Class representing generic injection information about an annotated field or setter method, supporting @Resource and related annotations.

  - ### 字段概要

    - ### 从类继承的字段 org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor

      `logger`

    - ### 从接口继承的字段 org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### 构造器概要

    构造器
    构造器和说明
    `CommonAnnotationBeanPostProcessor()` Create a new CommonAnnotationBeanPostProcessor, with the init and destroy annotation types set to `PostConstruct` and `PreDestroy`, respectively.

  - ### 方法概要

    所有方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `protected Object` | `autowireResource(org.springframework.beans.factory.BeanFactory factory, CommonAnnotationBeanPostProcessor.LookupElement element, String requestingBeanName)` Obtain a resource object for the given name and type through autowiring based on the given factory.
    `protected Object` | `buildLazyResourceProxy(CommonAnnotationBeanPostProcessor.LookupElement element, String requestingBeanName)` Obtain a lazily resolving resource proxy for the given name and type, delegating to `getResource(org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.LookupElement, java.lang.String)` on demand once a method call comes in.
    `protected Object` | `getResource(CommonAnnotationBeanPostProcessor.LookupElement element, String requestingBeanName)` Obtain the resource object for the given name and type.
    `void` | `ignoreResourceType(String resourceType)` Ignore the given resource type when resolving `@Resource` annotations.
    `boolean` | `postProcessAfterInstantiation(Object bean, String beanName)`
    `Object` | `postProcessBeforeInstantiation(Class<?> beanClass, String beanName)`
    `void` | `postProcessMergedBeanDefinition(org.springframework.beans.factory.support.RootBeanDefinition beanDefinition, Class<?> beanType, String beanName)`
    `org.springframework.beans.PropertyValues` | `postProcessPropertyValues(org.springframework.beans.PropertyValues pvs, PropertyDescriptor[] pds, Object bean, String beanName)`
    `void` | `setAlwaysUseJndiLookup(boolean alwaysUseJndiLookup)` Set whether to always use JNDI lookups equivalent to standard Java EE 5 resource injection, even for `name` attributes and default names.
    `void` | `setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)`
    `void` | `setFallbackToDefaultTypeMatch(boolean fallbackToDefaultTypeMatch)` Set whether to allow a fallback to a type match if no explicit name has been specified.
    `void` | `setJndiFactory(org.springframework.beans.factory.BeanFactory jndiFactory)` 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.
    `void` | `setResourceFactory(org.springframework.beans.factory.BeanFactory resourceFactory)` Specify the factory for objects to be injected into `@Resource` / `@WebServiceRef` / `@EJB` annotated fields and setter methods, for `name` attributes and default names.

    - ### 从类继承的方法 org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor

      `getOrder, postProcessAfterInitialization, postProcessBeforeDestruction, postProcessBeforeInitialization, requiresDestruction, setDestroyAnnotationType, setInitAnnotationType, setOrder`

    - ### 从类继承的方法 java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

    - ### 从接口继承的方法 org.springframework.beans.factory.config.BeanPostProcessor

      `postProcessAfterInitialization, postProcessBeforeInitialization`

- - ### 构造器详细资料

    - #### CommonAnnotationBeanPostProcessor

          public CommonAnnotationBeanPostProcessor()

      Create a new CommonAnnotationBeanPostProcessor, with the init and destroy annotation types set to `PostConstruct` and `PreDestroy`, respectively.

  - ### 方法详细资料

    - #### ignoreResourceType

          public void ignoreResourceType(String resourceType)

      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

    - #### setFallbackToDefaultTypeMatch

          public void setFallbackToDefaultTypeMatch(boolean fallbackToDefaultTypeMatch)

      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.

      另请参阅:
        `AutowireCapableBeanFactory.resolveDependency(org.springframework.beans.factory.config.DependencyDescriptor, java.lang.String)`

    - #### setAlwaysUseJndiLookup

          public void setAlwaysUseJndiLookup(boolean alwaysUseJndiLookup)

      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.

      另请参阅:
        `setJndiFactory(org.springframework.beans.factory.BeanFactory)`, `setResourceFactory(org.springframework.beans.factory.BeanFactory)`

    - #### setJndiFactory

          public void setJndiFactory(org.springframework.beans.factory.BeanFactory jndiFactory)

      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.

      另请参阅:
        `setResourceFactory(org.springframework.beans.factory.BeanFactory)`, `setAlwaysUseJndiLookup(boolean)`

    - #### setResourceFactory

          public void setResourceFactory(org.springframework.beans.factory.BeanFactory resourceFactory)

      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.

      另请参阅:
        `setAlwaysUseJndiLookup(boolean)`

    - #### setBeanFactory

          public void setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)

      指定者:
        `setBeanFactory` 在接口中 `org.springframework.beans.factory.BeanFactoryAware`

    - #### postProcessMergedBeanDefinition

          public void postProcessMergedBeanDefinition(org.springframework.beans.factory.support.RootBeanDefinition beanDefinition,
                                                      Class<?> beanType,
                                                      String beanName)

      指定者:
        `postProcessMergedBeanDefinition` 在接口中 `org.springframework.beans.factory.support.MergedBeanDefinitionPostProcessor`
      覆盖:
        `postProcessMergedBeanDefinition` 在类中 `org.springframework.beans.factory.annotation.InitDestroyAnnotationBeanPostProcessor`

    - #### postProcessBeforeInstantiation

          public Object postProcessBeforeInstantiation(Class<?> beanClass,
                                                       String beanName)

      指定者:
        `postProcessBeforeInstantiation` 在接口中 `org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor`

    - #### postProcessAfterInstantiation

          public boolean postProcessAfterInstantiation(Object bean,
                                                       String beanName)

      指定者:
        `postProcessAfterInstantiation` 在接口中 `org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor`

    - #### postProcessPropertyValues

          public org.springframework.beans.PropertyValues postProcessPropertyValues(org.springframework.beans.PropertyValues pvs,
                                                                                    PropertyDescriptor[] pds,
                                                                                    Object bean,
                                                                                    String beanName)

      指定者:
        `postProcessPropertyValues` 在接口中 `org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor`

    - #### buildLazyResourceProxy

          protected Object buildLazyResourceProxy(CommonAnnotationBeanPostProcessor.LookupElement element,
                                                  @Nullable
                                                  String requestingBeanName)

      Obtain a lazily resolving resource proxy for the given name and type, delegating to `getResource(org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.LookupElement, java.lang.String)` on demand once a method call comes in.
      参数:
        `element` - the descriptor for the annotated field/method
        `requestingBeanName` - the name of the requesting bean
      返回:
        the resource object (never `null`)
      从以下版本开始:
        4.2
      另请参阅:
        `getResource(org.springframework.context.annotation.CommonAnnotationBeanPostProcessor.LookupElement, java.lang.String)`, `Lazy`

    - #### getResource

          protected Object getResource(CommonAnnotationBeanPostProcessor.LookupElement element,
                                       @Nullable
                                       String requestingBeanName)
                                throws org.springframework.beans.factory.NoSuchBeanDefinitionException

      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
      返回:
        the resource object (never `null`)
      抛出:
        `org.springframework.beans.factory.NoSuchBeanDefinitionException` - if no corresponding target resource found

    - #### autowireResource

          protected Object autowireResource(org.springframework.beans.factory.BeanFactory factory,
                                            CommonAnnotationBeanPostProcessor.LookupElement element,
                                            @Nullable
                                            String requestingBeanName)
                                     throws org.springframework.beans.factory.NoSuchBeanDefinitionException

      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
      返回:
        the resource object (never `null`)
      抛出:
        `org.springframework.beans.factory.NoSuchBeanDefinitionException` - if no corresponding target resource found