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
`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
`protected static ParameterNameDiscoverer` `ASPECTJ_ANNOTATION_PARAMETER_NAME_DISCOVERER`
`protected Log` `logger` Logger available to subclasses
`protected ParameterNameDiscoverer` `parameterNameDiscoverer`

### Constructor Summary

Constructors
`protected` `AbstractAspectJAdvisorFactory()`

### Method Summary

Methods
`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.