## org.springframework.util
Class AntPathMatcher

    java.lang.Object
      org.springframework.util.AntPathMatcher

All Implemented Interfaces:
  PathMatcher

    public class AntPathMatcher

extends Object
implements PathMatcher

PathMatcher implementation for Ant-style path patterns. Examples are provided below.

Part of this mapping code has been kindly borrowed from Apache Ant.

The mapping matches URLs using the following rules:

- ? matches one character
- * matches zero or more characters
- ** matches zero or more 'directories' in a path

Some examples:

- `com/t?st.jsp` - matches `com/test.jsp` but also `com/tast.jsp` or `com/txst.jsp`
- `com/*.jsp` - matches all `.jsp` files in the `com` directory
- `com/**/test.jsp` - matches all `test.jsp` files underneath the `com` path
- `org/springframework/**/*.jsp` - matches all `.jsp` files underneath the `org/springframework` path
- `org/**/servlet/bla.jsp` - matches `org/springframework/servlet/bla.jsp` but also `org/springframework/testing/servlet/bla.jsp` and `org/servlet/bla.jsp`

Since:
  16.07.2003
Author:
  Alef Arendsen, Juergen Hoeller, Rob Harrop

Field Summary
`static String` `DEFAULT_PATH_SEPARATOR` Default path separator: "/"

Constructor Summary
`AntPathMatcher()`

Method Summary
`protected boolean` `doMatch(String pattern, String path, boolean fullMatch)` Actually match the given `path` against the given `pattern`.
`String` `extractPathWithinPattern(String pattern, String path)` Given a pattern and a full path, determine the pattern-mapped part.
`boolean` `isPattern(String path)` Does the given `path` represent a pattern that can be matched by an implementation of this interface?
`boolean` `match(String pattern, String path)` Match the given `path` against the given `pattern`, according to this PathMatcher's matching strategy.
`boolean` `matchStart(String pattern, String path)` Match the given `path` against the corresponding part of the given `pattern`, according to this PathMatcher's matching strategy.
`void` `setPathSeparator(String pathSeparator)` Set the path separator to use for pattern parsing.

Methods inherited from class java.lang.Object
`clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

Field Detail

### DEFAULT_PATH_SEPARATOR

    public static final String DEFAULT_PATH_SEPARATOR

  Default path separator: "/"

  See Also:
    Constant Field Values

Constructor Detail

### AntPathMatcher

    public AntPathMatcher()

Method Detail

### setPathSeparator

    public void setPathSeparator(String pathSeparator)

  Set the path separator to use for pattern parsing. Default is "/", as in Ant.

### isPattern

    public boolean isPattern(String path)

  Description copied from interface: `PathMatcher`
  Does the given `path` represent a pattern that can be matched by an implementation of this interface?

  If the return value is `false`, then the `PathMatcher.match(java.lang.String, java.lang.String)` method does not have to be used because direct equality comparisons on the static path Strings will lead to the same result.

  Specified by:
    `isPattern` in interface `PathMatcher`
  Parameters:
    `path` - the path String to check
  Returns:
    `true` if the given `path` represents a pattern

### match

    public boolean match(String pattern,
                         String path)

  Description copied from interface: `PathMatcher`
  Match the given `path` against the given `pattern`, according to this PathMatcher's matching strategy.

  Specified by:
    `match` in interface `PathMatcher`
  Parameters:
    `pattern` - the pattern to match against
    `path` - the path String to test
  Returns:
    `true` if the supplied `path` matched, `false` if it didn't

### matchStart

    public boolean matchStart(String pattern,
                              String path)

  Description copied from interface: `PathMatcher`
  Match the given `path` against the corresponding part of the given `pattern`, according to this PathMatcher's matching strategy.

  Determines whether the pattern at least matches as far as the given base path goes, assuming that a full path may then match as well.

  Specified by:
    `matchStart` in interface `PathMatcher`
  Parameters:
    `pattern` - the pattern to match against
    `path` - the path String to test
  Returns:
    `true` if the supplied `path` matched, `false` if it didn't

### doMatch

    protected boolean doMatch(String pattern,
                              String path,
                              boolean fullMatch)

  Actually match the given `path` against the given `pattern`.

  Parameters:
    `pattern` - the pattern to match against
    `path` - the path String to test
    `fullMatch` - whether a full pattern match is required (else a pattern match as far as the given base path goes is sufficient)
  Returns:
    `true` if the supplied `path` matched, `false` if it didn't

### extractPathWithinPattern

    public String extractPathWithinPattern(String pattern,
                                           String path)

  Given a pattern and a full path, determine the pattern-mapped part.

  For example:

  - '`/docs/cvs/commit.html`' and '`/docs/cvs/commit.html` -> ''
  - '`/docs/*`' and '`/docs/cvs/commit` -> '`cvs/commit`'
  - '`/docs/cvs/*.html`' and '`/docs/cvs/commit.html` -> '`commit.html`'
  - '`/docs/**`' and '`/docs/cvs/commit` -> '`cvs/commit`'
  - '`/docs/**\/*.html`' and '`/docs/cvs/commit.html` -> '`cvs/commit.html`'
  - '`/*.html`' and '`/docs/cvs/commit.html` -> '`docs/cvs/commit.html`'
  - '`*.html`' and '`/docs/cvs/commit.html` -> '`/docs/cvs/commit.html`'
  - '`*`' and '`/docs/cvs/commit.html` -> '`/docs/cvs/commit.html`'

  Assumes that `match(java.lang.String, java.lang.String)` returns `true` for '`pattern`' and '`path`', but does not enforce this.

  Specified by:
    `extractPathWithinPattern` in interface `PathMatcher`
  Parameters:
    `pattern` - the path pattern
    `path` - the full path to introspect
  Returns:
    the pattern-mapped part of the given `path` (never `null`)

Copyright © 2002-2008 The Spring Framework.