org.springframework.aop.aspectj.annotation

## Class AbstractAspectJAdvisorFactory

- java.lang.Object
- - org.springframework.aop.aspectj.annotation.AbstractAspectJAdvisorFactory

- All Implemented Interfaces:
    AspectJAdvisorFactory
  Direct Known Subclasses:
    ReflectiveAspectJAdvisorFactory

      public abstract class AbstractAspectJAdvisorFactory
      extends Object
      implements AspectJAdvisorFactory

  Abstract base class for factories that can create Spring AOP Advisors given AspectJ classes from classes honoring the AspectJ 5 annotation syntax.

  This class handles annotation parsing and validation functionality. It does not actually generate Spring AOP Advisors, which is deferred to subclasses.

  Since:
    2.0
  Author:
    Rod Johnson, Adrian Colyer, Juergen Hoeller

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected static class` | `AbstractAspectJAdvisorFactory.AspectJAnnotation<A extends Annotation>` Class modelling an AspectJ annotation, exposing its type enumeration and pointcut String.
    `protected static class` | `AbstractAspectJAdvisorFactory.AspectJAnnotationType`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected static ParameterNameDiscoverer` | `ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER`
    `protected Log` | `logger` Logger available to subclasses
    `protected ParameterNameDiscoverer` | `parameterNameDiscoverer`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `AbstractAspectJAdvisorFactory()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected AspectJExpressionPointcut` | `createPointcutExpression(Method annotatedMethod, Class declarationScope, String[] pointcutParameterNames)` The pointcut and advice annotations both have an "argNames" member which contains a comma-separated list of the argument names.
    `protected static AbstractAspectJAdvisorFactory.AspectJAnnotation` | `findAspectJAnnotationOnMethod(Method method)` Find and return the first AspectJ annotation on the given method (there should only be one anyway...)
    `boolean` | `isAspect(Class<?> clazz)` We consider something to be an AspectJ aspect suitable for use by the Spring AOP system if it has the @Aspect annotation, and was not compiled by ajc.
    `void` | `validate(Class<?> aspectClass)` Is the given class a valid AspectJ aspect class?

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

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

    - ### Methods inherited from interface org.springframework.aop.aspectj.annotation.AspectJAdvisorFactory

      `getAdvice, getAdvisor, getAdvisors`

- - ### Field Detail

    - #### ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER

          protected static final ParameterNameDiscoverer ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER

    - #### logger

          protected final Log logger

      Logger available to subclasses

    - #### parameterNameDiscoverer

          protected final ParameterNameDiscoverer parameterNameDiscoverer

  - ### Constructor Detail

    - #### AbstractAspectJAdvisorFactory

          protected AbstractAspectJAdvisorFactory()

  - ### Method Detail

    - #### findAspectJAnnotationOnMethod

          protected static AbstractAspectJAdvisorFactory.AspectJAnnotation findAspectJAnnotationOnMethod(Method method)

      Find and return the first AspectJ annotation on the given method (there should only be one anyway...)

    - #### isAspect

          public boolean isAspect(Class<?> clazz)

      We consider something to be an AspectJ aspect suitable for use by the Spring AOP system if it has the @Aspect annotation, and was not compiled by ajc. The reason for this latter test is that aspects written in the code-style (AspectJ language) also have the annotation present when compiled by ajc with the -1.5 flag, yet they cannot be consumed by Spring AOP.
      Specified by:
        `isAspect` in interface `AspectJAdvisorFactory`
      Parameters:
        `clazz` - the supposed annotation-style AspectJ class
      Returns:
        whether or not this class is recognized by AspectJ as an aspect class

    - #### validate

          public void validate(Class<?> aspectClass)
                        throws AopConfigException

      Description copied from interface: `AspectJAdvisorFactory`
      Is the given class a valid AspectJ aspect class?
      Specified by:
        `validate` in interface `AspectJAdvisorFactory`
      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)

    - #### createPointcutExpression

          protected AspectJExpressionPointcut createPointcutExpression(Method annotatedMethod,
                                                           Class declarationScope,
                                                           String[] pointcutParameterNames)

      The pointcut and advice annotations both have an "argNames" member which contains a comma-separated list of the argument names. We use this (if non-empty) to build the formal parameters for the pointcut.