Package org.springframework.scheduling.annotation

# Class AsyncAnnotationBeanPostProcessor

java.lang.Object
org.springframework.aop.framework.ProxyConfig
org.springframework.aop.framework.ProxyProcessorSupport
org.springframework.aop.framework.AbstractAdvisingBeanPostProcessor
org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor
org.springframework.scheduling.annotation.AsyncAnnotationBeanPostProcessor

All Implemented Interfaces:
  `Serializable`, `org.springframework.aop.framework.AopInfrastructureBean`, `org.springframework.beans.factory.Aware`, `org.springframework.beans.factory.BeanClassLoaderAware`, `org.springframework.beans.factory.BeanFactoryAware`, `org.springframework.beans.factory.config.BeanPostProcessor`, `org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor`, `org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor`, `org.springframework.core.Ordered`

public class AsyncAnnotationBeanPostProcessor extends org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor
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 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 `jakarta.ejb.Asynchronous` annotation.

For methods having a `void` return type, any exception thrown during the asynchronous method invocation cannot be accessed by the caller. An `AsyncUncaughtExceptionHandler` can be specified to handle these cases.

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, Stephane Nicoll
See Also:
  - `Async`
  - `AsyncAnnotationAdvisor`
  - `AbstractAdvisingBeanPostProcessor.setBeforeExistingAdvisors(boolean)`
  - `ScheduledAnnotationBeanPostProcessor`
  - Serialized Form

## Field Summary

Fields
Modifier and Type
Field
Description
`static final String`
`DEFAULT_TASK_EXECUTOR_BEAN_NAME`
The default name of the `TaskExecutor` bean to pick up: "taskExecutor".
`protected final org.apache.commons.logging.Log`
`logger`

### 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
Description
`AsyncAnnotationBeanPostProcessor()`

## Method Summary

Modifier and Type
Method
Description
`void`
`configure(Supplier<Executor> executor, Supplier<org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler> exceptionHandler)`
Configure this post-processor with the given executor and exception handler suppliers, applying the corresponding default if a supplier is not resolvable.
`void`
`setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType)`
Set the 'async' annotation type to be detected at either class or method level.
`void`
`setBeanFactory(org.springframework.beans.factory.BeanFactory beanFactory)`
`void`
`setExceptionHandler(org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler exceptionHandler)`
Set the `AsyncUncaughtExceptionHandler` to use to handle uncaught exceptions thrown by asynchronous method executions.
`void`
`setExecutor(Executor executor)`
Set the `Executor` to use when invoking methods asynchronously.

### Methods inherited from class org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor

`isEligible, prepareProxyFactory`

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

`customizeProxyFactory, determineBeanType, isEligible, postProcessAfterInitialization, setBeforeExistingAdvisors`

### Methods inherited from class org.springframework.aop.framework.ProxyProcessorSupport

`evaluateProxyInterfaces, getOrder, getProxyClassLoader, isConfigurationCallbackInterface, isInternalLanguageInterface, setBeanClassLoader, setOrder, setProxyClassLoader`

### 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`

### Methods inherited from interface org.springframework.beans.factory.config.BeanPostProcessor

`postProcessBeforeInitialization`

### Methods inherited from interface org.springframework.beans.factory.config.InstantiationAwareBeanPostProcessor

`postProcessAfterInstantiation, postProcessBeforeInstantiation, postProcessProperties`

### Methods inherited from interface org.springframework.beans.factory.config.SmartInstantiationAwareBeanPostProcessor

`determineCandidateConstructors, getEarlyBeanReference, predictBeanType`

## Field Details

### DEFAULT_TASK_EXECUTOR_BEAN_NAME

public static final String DEFAULT_TASK_EXECUTOR_BEAN_NAME
The default name of the `TaskExecutor` bean to pick up: "taskExecutor".

Note that the initial lookup happens by type; this is just the fallback in case of multiple executor beans found in the context.

Since:
  4.2
See Also:
  - `AsyncExecutionAspectSupport.DEFAULT_TASK_EXECUTOR_BEAN_NAME`
  - Constant Field Values

### logger

protected final org.apache.commons.logging.Log logger

## Constructor Details

### AsyncAnnotationBeanPostProcessor

public AsyncAnnotationBeanPostProcessor()

## Method Details

### configure

public void configure(@Nullable Supplier<Executor> executor, @Nullable Supplier<org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler> exceptionHandler)
Configure this post-processor with the given executor and exception handler suppliers, applying the corresponding default if a supplier is not resolvable.

Since:
  5.1

### setExecutor

public void setExecutor(Executor executor)
Set the `Executor` to use when invoking methods asynchronously.

If not specified, default executor resolution will apply: searching for a unique `TaskExecutor` bean in the context, or for an `Executor` bean named "taskExecutor" otherwise. If neither of the two is resolvable, a local default executor will be created within the interceptor.

See Also:
  - `AsyncExecutionInterceptor.getDefaultExecutor(BeanFactory)`
  - `DEFAULT_TASK_EXECUTOR_BEAN_NAME`

### setExceptionHandler

public void setExceptionHandler(org.springframework.aop.interceptor.AsyncUncaughtExceptionHandler exceptionHandler)
Set the `AsyncUncaughtExceptionHandler` to use to handle uncaught exceptions thrown by asynchronous method executions.

Since:
  4.1

### 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 `jakarta.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

### setBeanFactory

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

Specified by:
  `setBeanFactory` in interface `org.springframework.beans.factory.BeanFactoryAware`
Overrides:
  `setBeanFactory` in class `org.springframework.aop.framework.autoproxy.AbstractBeanFactoryAwareAdvisingPostProcessor`