org.springframework.scheduling.annotation

## Class AsyncAnnotationBeanPostProcessor

- java.lang.Object
- - org.springframework.aop.framework.ProxyConfig
  - - org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor
    - - org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor

- All Implemented Interfaces:
    Serializable, Aware, BeanClassLoaderAware, BeanFactoryAware, BeanPostProcessor, Ordered

      public class AsyncAnnotationBeanPostProcessor
      extends AbstractAdvisingBeanPostProcessor
      implements BeanFactoryAware

  Bean post-processor that automatically applies asynchronous invocation behavior to any bean that carries the `Async` annotation at class or method-level by adding a corresponding `AsyncAnnotationAdvisor` to the exposed proxy (either an existing AOP proxy or a newly generated proxy that implements all of the target's interfaces).

  The `TaskExecutor` responsible for the asynchronous execution may be provided as well as the annotation type that indicates a method should be invoked asynchronously. If no annotation type is specified, this post- processor will detect both Spring's `@Async` annotation as well as the EJB 3.1 `javax.ejb.Asynchronous` annotation.

  Note: The underlying async advisor applies before existing advisors by default, in order to switch to async execution as early as possible in the invocation chain.

  Since:
    3.0
  Author:
    Mark Fisher, Juergen Hoeller
  See Also:
    `Async`, `AsyncAnnotationAdvisor`, `AbstractAdvisingBeanPostProcessor.setBeforeExistingAdvisors(boolean)`, Serialized Form

- - ### Field Summary

    - ### Fields inherited from class org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor

      `advisor, beforeExistingAdvisors`

    - ### Fields inherited from interface org.springframework.core.Ordered

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AsyncAnnotationBeanPostProcessor()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType)` Set the 'async' annotation type to be detected at either class or method level.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
    `void` | `setExecutor(Executor executor)` Set the `Executor` to use when invoking methods asynchronously.

    - ### Methods inherited from class org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor

      `getOrder, isEligible, postProcessAfterInitialization, postProcessBeforeInitialization, setBeanClassLoader, setBeforeExistingAdvisors, setOrder`

    - ### Methods inherited from class org.springframework.aop.framework.ProxyConfig

      `copyFrom, isExposeProxy, isFrozen, isOpaque, isOptimize, isProxyTargetClass, setExposeProxy, setFrozen, setOpaque, setOptimize, setProxyTargetClass, toString`

    - ### Methods inherited from class java.lang.Object

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

- - ### Constructor Detail

    - #### AsyncAnnotationBeanPostProcessor

          public AsyncAnnotationBeanPostProcessor()

  - ### Method Detail

    - #### setAsyncAnnotationType

          public void setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType)

      Set the 'async' annotation type to be detected at either class or method level. By default, both the `Async` annotation and the EJB 3.1 `javax.ejb.Asynchronous` annotation will be detected.

      This setter property exists so that developers can provide their own (non-Spring-specific) annotation type to indicate that a method (or all methods of a given class) should be invoked asynchronously.

      Parameters:
        `asyncAnnotationType` - the desired annotation type

    - #### setExecutor

          public void setExecutor(Executor executor)

      Set the `Executor` to use when invoking methods asynchronously.

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Description copied from interface: `BeanFactoryAware`
      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 `InitializingBean.afterPropertiesSet()` or a custom init-method.

      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`