Package org.springframework.aop.aspectj.annotation

# Interface AspectJAdvisorFactory

All Known Implementing Classes:
  `AbstractAspectJAdvisorFactory`, `ReflectiveAspectJAdvisorFactory`

public interface AspectJAdvisorFactory
Interface for factories that can create Spring AOP Advisors from classes annotated with AspectJ annotation syntax.

Since:
  2.0
Author:
  Rod Johnson, Juergen Hoeller
See Also:
  - `AspectMetadata`
  - `AjTypeSystem`

## Method Summary

Modifier and Type
Method
Description
`Advice`
`getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName)`
Build a Spring AOP Advice for the given AspectJ advice method.
`Advisor`
`getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName)`
Build a Spring AOP Advisor for the given AspectJ advice method.
`List<Advisor>`
`getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory)`
Build Spring AOP Advisors for all annotated At-AspectJ methods on the specified aspect instance.
`boolean`
`isAspect(Class<?> clazz)`
Determine whether the given class is an aspect, as reported by AspectJ's `AjTypeSystem`.
`void`
`validate(Class<?> aspectClass)`
Is the given class a valid AspectJ aspect class?

## Method Details

### isAspect

boolean isAspect(Class<?> clazz)
Determine whether the given class is an aspect, as reported by AspectJ's `AjTypeSystem`.

Will simply return `false` if the supposed aspect is invalid (such as an extension of a concrete aspect class). Will return true for some aspects that Spring AOP cannot process, such as those with unsupported instantiation models. Use the `validate(java.lang.Class<?>)` method to handle these cases if necessary.

Parameters:
  `clazz` - the supposed annotation-style AspectJ class
Returns:
  whether this class is recognized by AspectJ as an aspect class

### validate

void validate(Class<?> aspectClass) throws AopConfigException
Is the given class a valid AspectJ aspect class?

Parameters:
  `aspectClass` - the supposed AspectJ annotation-style class to validate
Throws:
  `AopConfigException` - if the class is an invalid aspect (which can never be legal)
  `NotAnAtAspectException` - if the class is not an aspect at all (which may or may not be legal, depending on the context)

### getAdvisors

List<Advisor> getAdvisors(MetadataAwareAspectInstanceFactory aspectInstanceFactory)
Build Spring AOP Advisors for all annotated At-AspectJ methods on the specified aspect instance.

Parameters:
  `aspectInstanceFactory` - the aspect instance factory (not the aspect instance itself in order to avoid eager instantiation)
Returns:
  a list of advisors for this class

### getAdvisor

@Nullable Advisor getAdvisor(Method candidateAdviceMethod, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName)
Build a Spring AOP Advisor for the given AspectJ advice method.

Parameters:
  `candidateAdviceMethod` - the candidate advice method
  `aspectInstanceFactory` - the aspect instance factory
  `declarationOrder` - the declaration order within the aspect
  `aspectName` - the name of the aspect
Returns:
  `null` if the method is not an AspectJ advice method or if it is a pointcut that will be used by other advice but will not create a Spring advice in its own right

### getAdvice

@Nullable Advice getAdvice(Method candidateAdviceMethod, AspectJExpressionPointcut expressionPointcut, MetadataAwareAspectInstanceFactory aspectInstanceFactory, int declarationOrder, String aspectName)
Build a Spring AOP Advice for the given AspectJ advice method.

Parameters:
  `candidateAdviceMethod` - the candidate advice method
  `expressionPointcut` - the AspectJ expression pointcut
  `aspectInstanceFactory` - the aspect instance factory
  `declarationOrder` - the declaration order within the aspect
  `aspectName` - the name of the aspect
Returns:
  `null` if the method is not an AspectJ advice method or if it is a pointcut that will be used by other advice but will not create a Spring advice in its own right
See Also:
  - `AspectJAroundAdvice`
  - `AspectJMethodBeforeAdvice`
  - `AspectJAfterAdvice`
  - `AspectJAfterReturningAdvice`
  - `AspectJAfterThrowingAdvice`