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

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