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

    All Methods Instance Methods Abstract Methods Concrete Methods
    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,
                                 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`