org.springframework.scheduling.annotation

## Class AsyncAnnotationAdvisor

- java.lang.Object
- - org.springframework.aop.support.AbstractPointcutAdvisor
  - - org.springframework.scheduling.annotation.AsyncAnnotationAdvisor

- All Implemented Interfaces:
    Serializable, Advisor, PointcutAdvisor, Aware, BeanFactoryAware, Ordered

      public class AsyncAnnotationAdvisor
      extends AbstractPointcutAdvisor
      implements BeanFactoryAware

  Advisor that activates asynchronous method execution through the `Async` annotation. This annotation can be used at the method and type level in implementation classes as well as in service interfaces.

  This advisor detects the EJB 3.1 `javax.ejb.Asynchronous` annotation as well, treating it exactly like Spring's own `Async`. Furthermore, a custom async annotation type may get specified through the `"asyncAnnotationType"` property.

  Since:
    3.0
  Author:
    Juergen Hoeller
  See Also:
    `PersistenceExceptionTranslationAdvisor`, `Repository`, `DataAccessException`, `PersistenceExceptionTranslator`, Serialized Form

- - ### Field Summary

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

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AsyncAnnotationAdvisor()` Create a new `AsyncAnnotationAdvisor` for bean-style configuration.
    `AsyncAnnotationAdvisor(Executor executor)` Create a new `AsyncAnnotationAdvisor` for the given task executor.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Advice` | `buildAdvice(Executor executor)`
    `protected Pointcut` | `buildPointcut(Set<Class<? extends Annotation>> asyncAnnotationTypes)` Calculate a pointcut for the given async annotation types, if any.
    `void` | `delegateBeanFactory(BeanFactory beanFactory)`
    `Advice` | `getAdvice()` Return the advice part of this aspect.
    `Pointcut` | `getPointcut()` Get the Pointcut that drives this advisor.
    `void` | `setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType)` Set the 'async' annotation type.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Set the `BeanFactory` to be used when looking up executors by qualifier.
    `void` | `setTaskExecutor(Executor executor)` Specify the task executor to use for asynchronous methods.

    - ### Methods inherited from class org.springframework.aop.support.AbstractPointcutAdvisor

      `equals, getOrder, hashCode, isPerInstance, setOrder`

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

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

- - ### Constructor Detail

    - #### AsyncAnnotationAdvisor

          public AsyncAnnotationAdvisor()

      Create a new `AsyncAnnotationAdvisor` for bean-style configuration.

    - #### AsyncAnnotationAdvisor

          public AsyncAnnotationAdvisor(Executor executor)

      Create a new `AsyncAnnotationAdvisor` for the given task executor.
      Parameters:
        `executor` - the task executor to use for asynchronous methods

  - ### Method Detail

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)
                              throws BeansException

      Set the `BeanFactory` to be used when looking up executors by qualifier.
      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      Throws:
        `BeansException` - in case of initialization errors
      See Also:
        `BeanInitializationException`

    - #### delegateBeanFactory

          public void delegateBeanFactory(BeanFactory beanFactory)

    - #### setTaskExecutor

          public void setTaskExecutor(Executor executor)

      Specify the task executor to use for asynchronous methods.

    - #### setAsyncAnnotationType

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

      Set the 'async' annotation type.

      The default async annotation type is the `Async` annotation, as well as the EJB 3.1 `javax.ejb.Asynchronous` annotation (if present).

      This setter property exists so that developers can provide their own (non-Spring-specific) annotation type to indicate that a method is to be executed asynchronously.

      Parameters:
        `asyncAnnotationType` - the desired annotation type

    - #### getAdvice

          public Advice getAdvice()

      Description copied from interface: `Advisor`
      Return the advice part of this aspect. An advice may be an interceptor, a before advice, a throws advice, etc.
      Specified by:
        `getAdvice` in interface `Advisor`
      Returns:
        the advice that should apply if the pointcut matches
      See Also:
        `MethodInterceptor`, `BeforeAdvice`, `ThrowsAdvice`, `AfterReturningAdvice`

    - #### getPointcut

          public Pointcut getPointcut()

      Description copied from interface: `PointcutAdvisor`
      Get the Pointcut that drives this advisor.
      Specified by:
        `getPointcut` in interface `PointcutAdvisor`

    - #### buildAdvice

          protected Advice buildAdvice(Executor executor)

    - #### buildPointcut

          protected Pointcut buildPointcut(Set<Class<? extends Annotation>> asyncAnnotationTypes)

      Calculate a pointcut for the given async annotation types, if any.
      Parameters:
        `asyncAnnotationTypes` - the async annotation types to introspect
      Returns:
        the applicable Pointcut object, or `null` if none