Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.springframework.scheduling.annotation
Class AsyncAnnotationAdvisor

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

All Implemented Interfaces:
  java.io.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
`AsyncAnnotationAdvisor()` Create a new `AsyncAnnotationAdvisor` for bean-style configuration.
`AsyncAnnotationAdvisor(java.util.concurrent.Executor executor)` Create a new `AsyncAnnotationAdvisor` for the given task executor.

Method Summary
`protected org.aopalliance.aop.Advice` | `buildAdvice(java.util.concurrent.Executor executor)`
`protected Pointcut` | `buildPointcut(java.util.Set<java.lang.Class<? extends java.lang.annotation.Annotation>> asyncAnnotationTypes)` Calculate a pointcut for the given async annotation types, if any.
`void` | `delegateBeanFactory(BeanFactory beanFactory)`
`org.aopalliance.aop.Advice` | `getAdvice()` Return the advice part of this aspect.
`Pointcut` | `getPointcut()` Get the Pointcut that drives this advisor.
`void` | `setAsyncAnnotationType(java.lang.Class<? extends java.lang.annotation.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(java.util.concurrent.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(java.util.concurrent.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(java.util.concurrent.Executor executor)

  Specify the task executor to use for asynchronous methods.

### setAsyncAnnotationType

    public void setAsyncAnnotationType(java.lang.Class<? extends java.lang.annotation.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 org.aopalliance.aop.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 org.aopalliance.aop.Advice buildAdvice(java.util.concurrent.Executor executor)

### buildPointcut

    protected Pointcut buildPointcut(java.util.Set<java.lang.Class<? extends java.lang.annotation.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

Overview | Package | Class | Tree | Deprecated | Index | Help
| Spring Framework
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD