## org.springframework.scheduling.annotation
Class AsyncAnnotationBeanPostProcessor

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

All Implemented Interfaces:
  Serializable, BeanClassLoaderAware, BeanPostProcessor, InitializingBean, Ordered

    public class AsyncAnnotationBeanPostProcessor

extends ProxyConfig
implements BeanPostProcessor, BeanClassLoaderAware, InitializingBean, Ordered

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.

Since:
  3.0
Author:
  Mark Fisher, Juergen Hoeller
See Also:
  `Async`, `AsyncAnnotationAdvisor`, Serialized Form

Field Summary

Fields inherited from interface org.springframework.core.Ordered
`HIGHEST_PRECEDENCE, LOWEST_PRECEDENCE`

Constructor Summary
`AsyncAnnotationBeanPostProcessor()`

Method Summary
`void` `afterPropertiesSet()` Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).
`int` `getOrder()` Return the order value of this object, with a higher value meaning greater in terms of sorting.
`Object` `postProcessAfterInitialization(Object bean, String beanName)` Apply this BeanPostProcessor to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
`Object` `postProcessBeforeInitialization(Object bean, String beanName)` Apply this BeanPostProcessor to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method).
`void` `setAsyncAnnotationType(Class<? extends Annotation> asyncAnnotationType)` Set the 'async' annotation type to be detected at either class or method level.
`void` `setBeanClassLoader(ClassLoader classLoader)` Callback that supplies the bean `class loader` 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.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.

### setBeanClassLoader

    public void setBeanClassLoader(ClassLoader classLoader)

  Description copied from interface: `BeanClassLoaderAware`
  Callback that supplies the bean `class loader` to a bean instance.

  Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean's` `InitializingBean.afterPropertiesSet()` method or a custom init-method.

  Specified by:
    `setBeanClassLoader` in interface `BeanClassLoaderAware`
  Parameters:
    `classLoader` - the owning class loader; may be `null` in which case a default `ClassLoader` must be used, for example the `ClassLoader` obtained via `ClassUtils.getDefaultClassLoader()`

### afterPropertiesSet

    public void afterPropertiesSet()

  Description copied from interface: `InitializingBean`
  Invoked by a BeanFactory after it has set all bean properties supplied (and satisfied BeanFactoryAware and ApplicationContextAware).

  This method allows the bean instance to perform initialization only possible when all bean properties have been set and to throw an exception in the event of misconfiguration.

  Specified by:
    `afterPropertiesSet` in interface `InitializingBean`

### getOrder

    public int getOrder()

  Description copied from interface: `Ordered`
  Return the order value of this object, with a higher value meaning greater in terms of sorting.

  Normally starting with 0, with `Integer.MAX_VALUE` indicating the greatest value. Same order values will result in arbitrary positions for the affected objects.

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

  Specified by:
    `getOrder` in interface `Ordered`
  Returns:
    the order value

### postProcessBeforeInitialization

    public Object postProcessBeforeInitialization(Object bean,
                                                  String beanName)

  Description copied from interface: `BeanPostProcessor`
  Apply this BeanPostProcessor to the given new bean instance before any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

  Specified by:
    `postProcessBeforeInitialization` in interface `BeanPostProcessor`
  Parameters:
    `bean` - the new bean instance
    `beanName` - the name of the bean
  Returns:
    the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
  See Also:
    `InitializingBean.afterPropertiesSet()`

### postProcessAfterInitialization

    public Object postProcessAfterInitialization(Object bean,
                                                 String beanName)

  Description copied from interface: `BeanPostProcessor`
  Apply this BeanPostProcessor to the given new bean instance after any bean initialization callbacks (like InitializingBean's `afterPropertiesSet` or a custom init-method). The bean will already be populated with property values. The returned bean instance may be a wrapper around the original.

  In case of a FactoryBean, this callback will be invoked for both the FactoryBean instance and the objects created by the FactoryBean (as of Spring 2.0). The post-processor can decide whether to apply to either the FactoryBean or created objects or both through corresponding `bean instanceof FactoryBean` checks.

  This callback will also be invoked after a short-circuiting triggered by a `InstantiationAwareBeanPostProcessor.postProcessBeforeInstantiation(java.lang.Class<?>, java.lang.String)` method, in contrast to all other BeanPostProcessor callbacks.

  Specified by:
    `postProcessAfterInitialization` in interface `BeanPostProcessor`
  Parameters:
    `bean` - the new bean instance
    `beanName` - the name of the bean
  Returns:
    the bean instance to use, either the original or a wrapped one; if `null`, no subsequent BeanPostProcessors will be invoked
  See Also:
    `InitializingBean.afterPropertiesSet()`, `FactoryBean`