org.springframework.aop.support

Class AbstractRegexpMethodPointcut

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.Pointcut

TRUE

Fields inherited from interface org.springframework.aop.MethodMatcher

TRUE

Constructor Summary

Constructors

Constructor and Description
AbstractRegexpMethodPointcut()

Method Summary

Modifier and Type	Method and 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,
                       @Nullable
                       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