org.springframework.aop.support

## Class JdkRegexpMethodPointcut

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

- All Implemented Interfaces:
    Serializable, MethodMatcher, Pointcut

      public class JdkRegexpMethodPointcut
      extends AbstractRegexpMethodPointcut

  Regular expression pointcut based on the `java.util.regex` package. Supports the following JavaBean properties:
  - pattern: regular expression for the fully-qualified method names to match
  - 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.

  Since:
    1.1
  Author:
    Dmitriy Kopylenko, Rob Harrop
  See Also:
    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
    `JdkRegexpMethodPointcut()`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `initExcludedPatternRepresentation(String[] excludedPatterns)` Initialize exclusion `Patterns` from the supplied `String[]`.
    `protected void` | `initPatternRepresentation(String[] patterns)` Initialize `Patterns` from the supplied `String[]`.
    `protected boolean` | `matches(String pattern, int patternIndex)` Returns `true` if the `Pattern` at index `patternIndex` matches the supplied candidate `String`.
    `protected boolean` | `matchesExclusion(String candidate, int patternIndex)` Returns `true` if the exclusion `Pattern` at index `patternIndex` matches the supplied candidate `String`.

    - ### Methods inherited from class org.springframework.aop.support.AbstractRegexpMethodPointcut

      `equals, getExcludedPatterns, getPatterns, hashCode, matches, matchesPattern, setExcludedPattern, setExcludedPatterns, setPattern, setPatterns, 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

    - #### JdkRegexpMethodPointcut

          public JdkRegexpMethodPointcut()

  - ### Method Detail

    - #### initPatternRepresentation

          protected void initPatternRepresentation(String[] patterns)
                                            throws PatternSyntaxException

      Initialize `Patterns` from the supplied `String[]`.
      Specified by:
        `initPatternRepresentation` in class `AbstractRegexpMethodPointcut`
      Parameters:
        `patterns` - the patterns to initialize
      Throws:
        `PatternSyntaxException`

    - #### initExcludedPatternRepresentation

          protected void initExcludedPatternRepresentation(String[] excludedPatterns)
                                                    throws PatternSyntaxException

      Initialize exclusion `Patterns` from the supplied `String[]`.
      Specified by:
        `initExcludedPatternRepresentation` in class `AbstractRegexpMethodPointcut`
      Parameters:
        `excludedPatterns` - the patterns to initialize
      Throws:
        `PatternSyntaxException`

    - #### matches

          protected boolean matches(String pattern,
                        int patternIndex)

      Returns `true` if the `Pattern` at index `patternIndex` matches the supplied candidate `String`.
      Specified by:
        `matches` in class `AbstractRegexpMethodPointcut`
      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 boolean matchesExclusion(String candidate,
                                 int patternIndex)

      Returns `true` if the exclusion `Pattern` at index `patternIndex` matches the supplied candidate `String`.
      Specified by:
        `matchesExclusion` in class `AbstractRegexpMethodPointcut`
      Parameters:
        `candidate` - the `String` pattern to match
        `patternIndex` - index of pattern (starting from 0)
      Returns:
        `true` if there is a match, `false` otherwise