org.springframework.aop.support

## Class ControlFlowPointcut

- java.lang.Object
- - org.springframework.aop.support.ControlFlowPointcut

- All Implemented Interfaces:
    Serializable, ClassFilter, MethodMatcher, Pointcut

      public class ControlFlowPointcut
      extends Object
      implements Pointcut, ClassFilter, MethodMatcher, Serializable

  Pointcut and method matcher for use in simple cflow-style pointcut. Note that evaluating such pointcuts is 10-15 times slower than evaluating normal pointcuts, but they are useful in some cases.
  Author:
    Rod Johnson, Rob Harrop
  See Also:
    `ControlFlow`, Serialized Form

- - ### Field Summary

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

      `TRUE`

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

      `TRUE`

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

      `TRUE`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ControlFlowPointcut(Class<?> clazz)` Construct a new pointcut that matches all control flows below that class.
    `ControlFlowPointcut(Class<?> clazz, String methodName)` Construct a new pointcut that matches all calls below the given method in the given class.

  - ### Method Summary

    All Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `equals(Object other)`
    `ClassFilter` | `getClassFilter()` Return the ClassFilter for this pointcut.
    `int` | `getEvaluations()` It's useful to know how many times we've fired, for optimization.
    `MethodMatcher` | `getMethodMatcher()` Return the MethodMatcher for this pointcut.
    `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<?> clazz)` Subclasses can override this for greater filtering (and performance).
    `boolean` | `matches(Method method, Class<?> targetClass)` Subclasses can override this if it's possible to filter out some candidate classes.
    `boolean` | `matches(Method method, Class<?> targetClass, Object[] args)` Check whether there a runtime (dynamic) match for this method, which must have matched statically.

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

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

- - ### Constructor Detail

    - #### ControlFlowPointcut

          public ControlFlowPointcut(Class<?> clazz)

      Construct a new pointcut that matches all control flows below that class.
      Parameters:
        `clazz` - the clazz

    - #### ControlFlowPointcut

          public ControlFlowPointcut(Class<?> clazz,
                                     String methodName)

      Construct a new pointcut that matches all calls below the given method in the given class. If the method name is null, matches all control flows below that class.
      Parameters:
        `clazz` - the clazz
        `methodName` - the name of the method

  - ### Method Detail

    - #### matches

          public boolean matches(Class<?> clazz)

      Subclasses can override this for greater filtering (and performance).
      Specified by:
        `matches` in interface `ClassFilter`
      Parameters:
        `clazz` - the candidate target class
      Returns:
        whether the advice should apply to the given target class

    - #### matches

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

      Subclasses can override this if it's possible to filter out some candidate classes.
      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)`

    - #### getEvaluations

          public int getEvaluations()

      It's useful to know how many times we've fired, for optimization.

    - #### 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`)

    - #### equals

          public boolean equals(Object other)

      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`