java.lang.Object
- org.springframework.aop.support.StaticMethodMatcher
- - org.springframework.aop.support.StaticMethodMatcherPointcut
  - - org.springframework.aop.support.AbstractRegexpMethodPointcut

All Implemented Interfaces:
Serializable, MethodMatcher, Pointcut
Direct Known Subclasses:
JdkRegexpMethodPointcut
```
public abstract class AbstractRegexpMethodPointcut
extends StaticMethodMatcherPointcut
implements Serializable
```
Abstract base regular expression pointcut bean. JavaBean properties are:
- pattern: regular expression for the fully-qualified method names to match. The exact regexp syntax will depend on the subclass (e.g. Perl5 regular expressions)
- patterns: alternative property taking a String array of patterns. The result will be the union of these patterns.
Note: the regular expressions must be a match. For example, .*get.* will match com.mycom.Foo.getBar(). get.* will not.
This base class is serializable. Subclasses should declare all fields transient; the initPatternRepresentation(java.lang.String[]) method will be invoked again on deserialization.
Since:
1.1
Author:
Rod Johnson, Juergen Hoeller, Rob Harrop
See Also:
JdkRegexpMethodPointcut, Serialized Form

Field Summary
- Fields inherited from interface org.springframework.aop.MethodMatcher
  TRUE
- Fields inherited from interface org.springframework.aop.Pointcut
  TRUE

Constructor Summary
Constructors
Constructor Description
AbstractRegexpMethodPointcut()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods
Modifier and Type	Method	Description
`boolean`	`equals(Object other)`
`String[]`	`getExcludedPatterns()`	Returns the regular expressions for exclusion matching.
`String[]`	`getPatterns()`	Return the regular expressions for method matching.
`int`	`hashCode()`
`protected abstract void`	`initExcludedPatternRepresentation(String[] patterns)`	Subclasses must implement this to initialize regexp pointcuts.
`protected abstract void`	`initPatternRepresentation(String[] patterns)`	Subclasses must implement this to initialize regexp pointcuts.
`boolean`	`matches(Method method, Class<?> targetClass)`	Try to match the regular expression against the fully qualified name of the target class as well as against the method's declaring class, plus the name of the method.
`protected abstract boolean`	`matches(String pattern, int patternIndex)`	Does the pattern at the given index match the given String?
`protected abstract boolean`	`matchesExclusion(String pattern, int patternIndex)`	Does the exclusion pattern at the given index match the given String?
`protected boolean`	`matchesPattern(String signatureString)`	Match the specified candidate against the configured patterns.
`void`	`setExcludedPattern(String excludedPattern)`	Convenience method when we have only a single exclusion pattern.
`void`	`setExcludedPatterns(String... excludedPatterns)`	Set the regular expressions defining methods to match for exclusion.
`void`	`setPattern(String pattern)`	Convenience method when we have only a single pattern.
`void`	`setPatterns(String... patterns)`	Set the regular expressions defining methods to match.
`String`	`toString()`

Methods inherited from class org.springframework.aop.support.StaticMethodMatcherPointcut
getClassFilter, getMethodMatcher, setClassFilter

Methods inherited from class org.springframework.aop.support.StaticMethodMatcher
isRuntime, matches

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - AbstractRegexpMethodPointcut
```
public AbstractRegexpMethodPointcut()
```
- Method Detail
  - setPattern
```
public void setPattern(String pattern)
```
    Convenience method when we have only a single pattern. Use either this method or setPatterns(java.lang.String...), not both.
    See Also:
    setPatterns(java.lang.String...)
  - setPatterns
```
public void setPatterns(String... patterns)
```
    Set the regular expressions defining methods to match. Matching will be the union of all these; if any match, the pointcut matches.
    See Also:
    setPattern(java.lang.String)
  - getPatterns
```
public String[] getPatterns()
```
    Return the regular expressions for method matching.
  - setExcludedPattern
```
public void setExcludedPattern(String excludedPattern)
```
    Convenience method when we have only a single exclusion pattern. Use either this method or setExcludedPatterns(java.lang.String...), not both.
    See Also:
    setExcludedPatterns(java.lang.String...)
  - setExcludedPatterns
```
public void setExcludedPatterns(String... excludedPatterns)
```
    Set the regular expressions defining methods to match for exclusion. Matching will be the union of all these; if any match, the pointcut matches.
    See Also:
    setExcludedPattern(java.lang.String)
  - getExcludedPatterns
```
public String[] getExcludedPatterns()
```
    Returns the regular expressions for exclusion matching.
  - matches
```
public boolean matches(Method method,
                       Class<?> targetClass)
```
    Try to match the regular expression against the fully qualified name of the target class as well as against the method's declaring class, plus the name of the method.
    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
  - matchesPattern
```
protected boolean matchesPattern(String signatureString)
```
    Match the specified candidate against the configured patterns.
    Parameters:
    signatureString - "java.lang.Object.hashCode" style signature
    Returns:
    whether the candidate matches at least one of the specified patterns
  - initPatternRepresentation
```
protected abstract void initPatternRepresentation(String[] patterns)
                                           throws IllegalArgumentException
```
    Subclasses must implement this to initialize regexp pointcuts. Can be invoked multiple times.
    This method will be invoked from the setPatterns(java.lang.String...) method, and also on deserialization.
    Parameters:
    patterns - the patterns to initialize
    Throws:
    IllegalArgumentException - in case of an invalid pattern
  - initExcludedPatternRepresentation
```
protected abstract void initExcludedPatternRepresentation(String[] patterns)
                                                   throws IllegalArgumentException
```
    Subclasses must implement this to initialize regexp pointcuts. Can be invoked multiple times.
    This method will be invoked from the setExcludedPatterns(java.lang.String...) method, and also on deserialization.
    Parameters:
    patterns - the patterns to initialize
    Throws:
    IllegalArgumentException - in case of an invalid pattern
  - matches
```
protected abstract boolean matches(String pattern,
                                   int patternIndex)
```
    Does the pattern at the given index match the given String?
    Parameters:
    pattern - the String pattern to match
    patternIndex - index of pattern (starting from 0)
    Returns:
    true if there is a match, false otherwise
  - matchesExclusion
```
protected abstract boolean matchesExclusion(String pattern,
                                            int patternIndex)
```
    Does the exclusion pattern at the given index match the given String?
    Parameters:
    pattern - the String pattern to match
    patternIndex - index of pattern (starting from 0)
    Returns:
    true if there is a match, false otherwise
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    equals in class Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    hashCode in class Object
  - toString
```
public String toString()
```
    Overrides:
    toString in class Object

Class AbstractRegexpMethodPointcut

Field Summary

Fields inherited from interface org.springframework.aop.MethodMatcher

Fields inherited from interface org.springframework.aop.Pointcut

Constructor Summary

Method Summary

Methods inherited from class org.springframework.aop.support.StaticMethodMatcherPointcut

Methods inherited from class org.springframework.aop.support.StaticMethodMatcher

Methods inherited from class java.lang.Object

Constructor Detail

AbstractRegexpMethodPointcut

Method Detail

setPattern

setPatterns

getPatterns

setExcludedPattern

setExcludedPatterns

getExcludedPatterns

matches

matchesPattern

initPatternRepresentation

initExcludedPatternRepresentation

matches

matchesExclusion

equals

hashCode

toString