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