org.springframework.aop.aspectj

## Class AspectJExpressionPointcut

- java.lang.Object
- - org.springframework.aop.support.AbstractExpressionPointcut
  - - org.springframework.aop.aspectj.AspectJExpressionPointcut

- All Implemented Interfaces:
    Serializable, ClassFilter, IntroductionAwareMethodMatcher, MethodMatcher, Pointcut, ExpressionPointcut, Aware, BeanFactoryAware

      public class AspectJExpressionPointcut
      extends AbstractExpressionPointcut
      implements ClassFilter, IntroductionAwareMethodMatcher, BeanFactoryAware

  Spring `Pointcut` implementation that uses the AspectJ weaver to evaluate a pointcut expression.

  The pointcut expression value is an AspectJ expression. This can reference other pointcuts and use composition and other operations.

  Naturally, as this is to be processed by Spring AOP's proxy-based model, only method execution pointcuts are supported.

  Since:
    2.0
  Author:
    Rob Harrop, Adrian Colyer, Rod Johnson, Juergen Hoeller, Ramnivas Laddad, Dave Syer
  See Also:
    Serialized Form

- - ### Field Summary

    - ### Fields inherited from interface org.springframework.aop.ClassFilter

      `TRUE`

    - ### Fields inherited from interface org.springframework.aop.Pointcut

      `TRUE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `AspectJExpressionPointcut()` Create a new default AspectJExpressionPointcut.
    `AspectJExpressionPointcut(Class declarationScope, String[] paramNames, Class[] paramTypes)` Create a new AspectJExpressionPointcut with the given settings.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(Object other)`
    `ClassFilter` | `getClassFilter()` Return the ClassFilter for this pointcut.
    `protected String` | `getCurrentProxiedBeanName()`
    `MethodMatcher` | `getMethodMatcher()` Return the MethodMatcher for this pointcut.
    `org.aspectj.weaver.tools.PointcutExpression` | `getPointcutExpression()` Return the underlying AspectJ pointcut expression.
    `int` | `hashCode()`
    `boolean` | `isRuntime()` Is this MethodMatcher dynamic, that is, must a final call be made on the `MethodMatcher.matches(java.lang.reflect.Method, Class, Object[])` method at runtime even if the 2-arg matches method returns `true`?
    `boolean` | `matches(Class targetClass)` Should the pointcut apply to the given interface or target class?
    `boolean` | `matches(Method method, Class targetClass)` Perform static checking whether the given method matches.
    `boolean` | `matches(Method method, Class targetClass, boolean beanHasIntroductions)` Perform static checking whether the given method matches.
    `boolean` | `matches(Method method, Class targetClass, Object[] args)` Check whether there a runtime (dynamic) match for this method, which must have matched statically.
    `void` | `setBeanFactory(BeanFactory beanFactory)` Callback that supplies the owning factory to a bean instance.
    `void` | `setParameterNames(String[] names)` Set the parameter names for the pointcut.
    `void` | `setParameterTypes(Class[] types)` Set the parameter types for the pointcut.
    `void` | `setPointcutDeclarationScope(Class pointcutDeclarationScope)` Set the declaration scope for the pointcut.
    `String` | `toString()`

    - ### Methods inherited from class org.springframework.aop.support.AbstractExpressionPointcut

      `getExpression, getLocation, onSetExpression, setExpression, setLocation`

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

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### AspectJExpressionPointcut

          public AspectJExpressionPointcut()

      Create a new default AspectJExpressionPointcut.

    - #### AspectJExpressionPointcut

          public AspectJExpressionPointcut(Class declarationScope,
                                   String[] paramNames,
                                   Class[] paramTypes)

      Create a new AspectJExpressionPointcut with the given settings.
      Parameters:
        `declarationScope` - the declaration scope for the pointcut
        `paramNames` - the parameter names for the pointcut
        `paramTypes` - the parameter types for the pointcut

  - ### Method Detail

    - #### setPointcutDeclarationScope

          public void setPointcutDeclarationScope(Class pointcutDeclarationScope)

      Set the declaration scope for the pointcut.

    - #### setParameterNames

          public void setParameterNames(String[] names)

      Set the parameter names for the pointcut.

    - #### setParameterTypes

          public void setParameterTypes(Class[] types)

      Set the parameter types for the pointcut.

    - #### setBeanFactory

          public void setBeanFactory(BeanFactory beanFactory)

      Description copied from interface: `BeanFactoryAware`
      Callback that supplies the owning factory to a bean instance.

      Invoked after the population of normal bean properties but before an initialization callback such as `InitializingBean.afterPropertiesSet()` or a custom init-method.

      Specified by:
        `setBeanFactory` in interface `BeanFactoryAware`
      Parameters:
        `beanFactory` - owning BeanFactory (never `null`). The bean can immediately call methods on the factory.
      See Also:
        `BeanInitializationException`

    - #### getClassFilter

          public ClassFilter getClassFilter()

      Description copied from interface: `Pointcut`
      Return the ClassFilter for this pointcut.
      Specified by:
        `getClassFilter` in interface `Pointcut`
      Returns:
        the ClassFilter (never `null`)

    - #### getMethodMatcher

          public MethodMatcher getMethodMatcher()

      Description copied from interface: `Pointcut`
      Return the MethodMatcher for this pointcut.
      Specified by:
        `getMethodMatcher` in interface `Pointcut`
      Returns:
        the MethodMatcher (never `null`)

    - #### getPointcutExpression

          public org.aspectj.weaver.tools.PointcutExpression getPointcutExpression()

      Return the underlying AspectJ pointcut expression.

    - #### matches

          public boolean matches(Class targetClass)

      Description copied from interface: `ClassFilter`
      Should the pointcut apply to the given interface or target class?
      Specified by:
        `matches` in interface `ClassFilter`
      Parameters:
        `targetClass` - the candidate target class
      Returns:
        whether the advice should apply to the given target class

    - #### matches

          public boolean matches(Method method,
                        Class targetClass,
                        boolean beanHasIntroductions)

      Description copied from interface: `IntroductionAwareMethodMatcher`
      Perform static checking whether the given method matches. This may be invoked instead of the 2-arg `MethodMatcher.matches(java.lang.reflect.Method, Class)` method if the caller supports the extended IntroductionAwareMethodMatcher interface.
      Specified by:
        `matches` in interface `IntroductionAwareMethodMatcher`
      Parameters:
        `method` - the candidate method
        `targetClass` - the target class (may be `null`, in which case the candidate class must be taken to be the method's declaring class)
        `beanHasIntroductions` - `true` if the object on whose behalf we are asking is the subject on one or more introductions; `false` otherwise
      Returns:
        whether or not this method matches statically

    - #### matches

          public boolean matches(Method method,
                        Class targetClass)

      Description copied from interface: `MethodMatcher`
      Perform static checking whether the given method matches. If this returns `false` or if the `MethodMatcher.isRuntime()` method returns `false`, no runtime check (i.e. no. `MethodMatcher.matches(java.lang.reflect.Method, Class, Object[])` call) will be made.
      Specified by:
        `matches` in interface `MethodMatcher`
      Parameters:
        `method` - the candidate method
        `targetClass` - the target class (may be `null`, in which case the candidate class must be taken to be the method's declaring class)
      Returns:
        whether or not this method matches statically

    - #### isRuntime

          public boolean isRuntime()

      Description copied from interface: `MethodMatcher`
      Is this MethodMatcher dynamic, that is, must a final call be made on the `MethodMatcher.matches(java.lang.reflect.Method, Class, Object[])` method at runtime even if the 2-arg matches method returns `true`?

      Can be invoked when an AOP proxy is created, and need not be invoked again before each method invocation,

      Specified by:
        `isRuntime` in interface `MethodMatcher`
      Returns:
        whether or not a runtime match via the 3-arg `MethodMatcher.matches(java.lang.reflect.Method, Class, Object[])` method is required if static matching passed

    - #### matches

          public boolean matches(Method method,
                        Class targetClass,
                        Object[] args)

      Description copied from interface: `MethodMatcher`
      Check whether there a runtime (dynamic) match for this method, which must have matched statically.

      This method is invoked only if the 2-arg matches method returns `true` for the given method and target class, and if the `MethodMatcher.isRuntime()` method returns `true`. Invoked immediately before potential running of the advice, after any advice earlier in the advice chain has run.

      Specified by:
        `matches` in interface `MethodMatcher`
      Parameters:
        `method` - the candidate method
        `targetClass` - the target class (may be `null`, in which case the candidate class must be taken to be the method's declaring class)
        `args` - arguments to the method
      Returns:
        whether there's a runtime match
      See Also:
        `MethodMatcher.matches(Method, Class)`

    - #### getCurrentProxiedBeanName

          protected String getCurrentProxiedBeanName()

    - #### equals

          public boolean equals(Object other)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`