org.springframework.aop.aspectj

## 类 AspectJExpressionPointcut

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

- 所有已实现的接口:
    Serializable, ClassFilter, IntroductionAwareMethodMatcher, MethodMatcher, Pointcut, ExpressionPointcut, org.springframework.beans.factory.Aware, org.springframework.beans.factory.BeanFactoryAware

      public class AspectJExpressionPointcut
      extends AbstractExpressionPointcut
      implements ClassFilter, IntroductionAwareMethodMatcher, org.springframework.beans.factory.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.

  从以下版本开始:
    2.0
  作者:
    Rob Harrop, Adrian Colyer, Rod Johnson, Juergen Hoeller, Ramnivas Laddad, Dave Syer
  另请参阅:
    序列化表格

- - ### 字段概要

    - ### 从接口继承的字段 org.springframework.aop.ClassFilter

      `TRUE`

    - ### 从接口继承的字段 org.springframework.aop.Pointcut

      `TRUE`

  - ### 构造器概要

    构造器
    构造器和说明
    `AspectJExpressionPointcut()` Create a new default AspectJExpressionPointcut.
    `AspectJExpressionPointcut(Class<?> declarationScope, String[] paramNames, Class<?>[] paramTypes)` Create a new AspectJExpressionPointcut with the given settings.

  - ### 方法概要

    所有方法 实例方法 具体方法
    限定符和类型 | 方法和说明
    --- | ---
    `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 hasIntroductions)` 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(org.springframework.beans.factory.BeanFactory beanFactory)`
    `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()`

    - ### 从类继承的方法 org.springframework.aop.support.AbstractExpressionPointcut

      `getExpression, getLocation, onSetExpression, setExpression, setLocation`

    - ### 从类继承的方法 java.lang.Object

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

- - ### 构造器详细资料

    - #### 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.
      参数:
        `declarationScope` - the declaration scope for the pointcut
        `paramNames` - the parameter names for the pointcut
        `paramTypes` - the parameter types for the pointcut

  - ### 方法详细资料

    - #### 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(org.springframework.beans.factory.BeanFactory beanFactory)

      指定者:
        `setBeanFactory` 在接口中 `org.springframework.beans.factory.BeanFactoryAware`

    - #### getClassFilter

          public ClassFilter getClassFilter()

      从接口复制的说明: `Pointcut`
      Return the ClassFilter for this pointcut.
      指定者:
        `getClassFilter` 在接口中 `Pointcut`
      返回:
        the ClassFilter (never `null`)

    - #### getMethodMatcher

          public MethodMatcher getMethodMatcher()

      从接口复制的说明: `Pointcut`
      Return the MethodMatcher for this pointcut.
      指定者:
        `getMethodMatcher` 在接口中 `Pointcut`
      返回:
        the MethodMatcher (never `null`)

    - #### getPointcutExpression

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

      Return the underlying AspectJ pointcut expression.

    - #### matches

          public boolean matches(Class<?> targetClass)

      从接口复制的说明: `ClassFilter`
      Should the pointcut apply to the given interface or target class?
      指定者:
        `matches` 在接口中 `ClassFilter`
      参数:
        `targetClass` - the candidate target class
      返回:
        whether the advice should apply to the given target class

    - #### matches

          public boolean matches(Method method,
                                 @Nullable
                                 Class<?> targetClass,
                                 boolean hasIntroductions)

      从接口复制的说明: `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.
      指定者:
        `matches` 在接口中 `IntroductionAwareMethodMatcher`
      参数:
        `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)
        `hasIntroductions` - `true` if the object on whose behalf we are asking is the subject on one or more introductions; `false` otherwise
      返回:
        whether or not this method matches statically

    - #### matches

          public boolean matches(Method method,
                                 @Nullable
                                 Class<?> targetClass)

      从接口复制的说明: `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.

      指定者:
        `matches` 在接口中 `MethodMatcher`
      参数:
        `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)
      返回:
        whether or not this method matches statically

    - #### isRuntime

          public boolean isRuntime()

      从接口复制的说明: `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,

      指定者:
        `isRuntime` 在接口中 `MethodMatcher`
      返回:
        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,
                                 @Nullable
                                 Class<?> targetClass,
                                 Object... args)

      从接口复制的说明: `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.

      指定者:
        `matches` 在接口中 `MethodMatcher`
      参数:
        `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
      返回:
        whether there's a runtime match
      另请参阅:
        `MethodMatcher.matches(Method, Class)`

    - #### getCurrentProxiedBeanName

          @Nullable
          protected String getCurrentProxiedBeanName()

    - #### equals

          public boolean equals(Object other)

      覆盖:
        `equals` 在类中 `Object`

    - #### hashCode

          public int hashCode()

      覆盖:
        `hashCode` 在类中 `Object`

    - #### toString

          public String toString()

      覆盖:
        `toString` 在类中 `Object`