org.springframework.aop.support

## Class DynamicMethodMatcher

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

All Implemented Interfaces:
  MethodMatcher

Direct Known Subclasses:
  DynamicMethodMatcherPointcut

    public abstract class DynamicMethodMatcher
    extends Object
    implements MethodMatcher

Convenient abstract superclass for dynamic method matchers, which do care about arguments at runtime.

### Field Summary

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

`TRUE`

### Constructor Summary

Constructors
Constructor and Description
`DynamicMethodMatcher()`

### Method Summary

Methods
`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(Method method, Class<?> targetClass)` Can override to add preconditions for dynamic matching.

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

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

### Methods inherited from interface org.springframework.aop.MethodMatcher

`matches`

### Constructor Detail

#### DynamicMethodMatcher

    public DynamicMethodMatcher()

### Method Detail

#### isRuntime

    public final 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)

Can override to add preconditions for dynamic matching. This implementation always returns true.

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