The Spring Framework

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

Constructor Summary
`protected` `AbstractAspectJAdvisorFactory()`

Method Summary
`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 aMethod)` 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 aMethod)

  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.

The Spring Framework

Copyright © 2002-2008 The Spring Framework.