org.springframework.aop.interceptor

## Class AsyncExecutionInterceptor

- java.lang.Object
- - org.springframework.aop.interceptor.AsyncExecutionAspectSupport
  - - org.springframework.aop.interceptor.AsyncExecutionInterceptor

- All Implemented Interfaces:
    Advice, Interceptor, MethodInterceptor, Aware, BeanFactoryAware, Ordered
  Direct Known Subclasses:
    AnnotationAsyncExecutionInterceptor

      public class AsyncExecutionInterceptor
      extends AsyncExecutionAspectSupport
      implements MethodInterceptor, Ordered

  AOP Alliance `MethodInterceptor` that processes method invocations asynchronously, using a given `AsyncTaskExecutor`. Typically used with the `Async` annotation.

  In terms of target method signatures, any parameter types are supported. However, the return type is constrained to either `void` or `java.util.concurrent.Future`. In the latter case, the Future handle returned from the proxy will be an actual asynchronous Future that can be used to track the result of the asynchronous method execution. However, since the target method needs to implement the same signature, it will have to return a temporary Future handle that just passes the return value through (like Spring's `AsyncResult` or EJB 3.1's `javax.ejb.AsyncResult`).

  When the return type is `java.util.concurrent.Future`, any exception thrown during the execution can be accessed and managed by the caller. With `void` return type however, such exceptions cannot be transmitted back. In that case an `AsyncUncaughtExceptionHandler` can be registered to process such exceptions.

  As of Spring 3.1.2 the `AnnotationAsyncExecutionInterceptor` subclass is preferred for use due to its support for executor qualification in conjunction with Spring's `@Async` annotation.

  Since:
    3.0
  Author:
    Juergen Hoeller, Chris Beams, Stephane Nicoll
  See Also:
    `Async`, `AsyncAnnotationAdvisor`, `AnnotationAsyncExecutionInterceptor`

- - ### Field Summary

    - ### Fields inherited from class org.springframework.aop.interceptor.AsyncExecutionAspectSupport

      `DEFAULT_TASK_EXECUTOR_BEAN_NAME, logger`

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

      `HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AsyncExecutionInterceptor(Executor defaultExecutor)` Create a new instance with a default `AsyncUncaughtExceptionHandler`.
    `AsyncExecutionInterceptor(Executor defaultExecutor, AsyncUncaughtExceptionHandler exceptionHandler)` Create a new `AsyncExecutionInterceptor`.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected Executor` | `getDefaultExecutor(BeanFactory beanFactory)` This implementation searches for a unique `TaskExecutor` bean in the context, or for an `Executor` bean named "taskExecutor" otherwise.
    `protected String` | `getExecutorQualifier(Method method)` This implementation is a no-op for compatibility in Spring 3.1.2.
    `int` | `getOrder()` Get the order value of this object.
    `Object` | `invoke(MethodInvocation invocation)` Intercept the given method invocation, submit the actual calling of the method to the correct task executor and return immediately to the caller.

    - ### Methods inherited from class org.springframework.aop.interceptor.AsyncExecutionAspectSupport

      `configure, determineAsyncExecutor, doSubmit, findQualifiedExecutor, handleError, setBeanFactory, setExceptionHandler, setExecutor`

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

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

- - ### Constructor Detail

    - #### AsyncExecutionInterceptor

          public AsyncExecutionInterceptor(@Nullable
                                           Executor defaultExecutor)

      Create a new instance with a default `AsyncUncaughtExceptionHandler`.
      Parameters:
        `defaultExecutor` - the `Executor` (typically a Spring `AsyncTaskExecutor` or `ExecutorService`) to delegate to; as of 4.2.6, a local executor for this interceptor will be built otherwise

    - #### AsyncExecutionInterceptor

          public AsyncExecutionInterceptor(@Nullable
                                           Executor defaultExecutor,
                                           AsyncUncaughtExceptionHandler exceptionHandler)

      Create a new `AsyncExecutionInterceptor`.
      Parameters:
        `defaultExecutor` - the `Executor` (typically a Spring `AsyncTaskExecutor` or `ExecutorService`) to delegate to; as of 4.2.6, a local executor for this interceptor will be built otherwise
        `exceptionHandler` - the `AsyncUncaughtExceptionHandler` to use

  - ### Method Detail

    - #### invoke

          @Nullable
          public Object invoke(MethodInvocation invocation)
                                  throws Throwable

      Intercept the given method invocation, submit the actual calling of the method to the correct task executor and return immediately to the caller.
      Specified by:
        `invoke` in interface `MethodInterceptor`
      Parameters:
        `invocation` - the method to intercept and make asynchronous
      Returns:
        `Future` if the original method returns `Future`; `null` otherwise.
      Throws:
        `Throwable` - if the interceptors or the target object throws an exception

    - #### getExecutorQualifier

          @Nullable
          protected String getExecutorQualifier(Method method)

      This implementation is a no-op for compatibility in Spring 3.1.2. Subclasses may override to provide support for extracting qualifier information, e.g. via an annotation on the given method.
      Specified by:
        `getExecutorQualifier` in class `AsyncExecutionAspectSupport`
      Parameters:
        `method` - the method to inspect for executor qualifier metadata
      Returns:
        always `null`
      Since:
        3.1.2
      See Also:
        `AsyncExecutionAspectSupport.determineAsyncExecutor(Method)`

    - #### getDefaultExecutor

          @Nullable
          protected Executor getDefaultExecutor(@Nullable
                                                          BeanFactory beanFactory)

      This implementation searches for a unique `TaskExecutor` bean in the context, or for an `Executor` bean named "taskExecutor" otherwise. If neither of the two is resolvable (e.g. if no `BeanFactory` was configured at all), this implementation falls back to a newly created `SimpleAsyncTaskExecutor` instance for local use if no default could be found.
      Overrides:
        `getDefaultExecutor` in class `AsyncExecutionAspectSupport`
      Parameters:
        `beanFactory` - the BeanFactory to use for a default executor lookup
      Returns:
        the default executor, or `null` if none available
      See Also:
        `AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME`

    - #### getOrder

          public int getOrder()

      Description copied from interface: `Ordered`
      Get the order value of this object.

      Higher values are interpreted as lower priority. As a consequence, the object with the lowest value has the highest priority (somewhat analogous to Servlet `load-on-startup` values).

      Same order values will result in arbitrary sort positions for the affected objects.

      Specified by:
        `getOrder` in interface `Ordered`
      Returns:
        the order value
      See Also:
        `Ordered.HIGHEST_PRECEDENCE`, `Ordered.LOWEST_PRECEDENCE`