## 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, Arjen Poutsma

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

Constructor Summary
`AntPathMatcher()`

Method Summary
`String` `combine(String pattern1, String pattern2)` Combines two patterns into a new pattern that is returned.
`protected boolean` `doMatch(String pattern, String path, boolean fullMatch, Map<String,String> uriTemplateVariables)` 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.
`Map<String,String>` `extractUriTemplateVariables(String pattern, String path)` Given a pattern and a full path, extract the URI template variables.
`Comparator<String>` `getPatternComparator(String path)` Given a full path, returns a `Comparator` suitable for sorting patterns in order of explicitness.
`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,
                              Map<String,String> uriTemplateVariables)

  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`)

### extractUriTemplateVariables

    public Map<String,String> extractUriTemplateVariables(String pattern,
                                                          String path)

  Description copied from interface: `PathMatcher`
  Given a pattern and a full path, extract the URI template variables. URI template variables are expressed through curly brackets ('{' and '}').

  For example: For pattern "/hotels/{hotel}" and path "/hotels/1", this method will return a map containing "hotel"->"1".

  Specified by:
    `extractUriTemplateVariables` in interface `PathMatcher`
  Parameters:
    `pattern` - the path pattern, possibly containing URI templates
    `path` - the full path to extract template variables from
  Returns:
    a map, containing variable names as keys; variables values as values

### combine

    public String combine(String pattern1,
                          String pattern2)

  Combines two patterns into a new pattern that is returned.

  This implementation simply concatenates the two patterns, unless the first pattern contains a file extension match (such as `*.html`. In that case, the second pattern should be included in the first, or an `IllegalArgumentException` is thrown.

  For example:

  Pattern 1 | Pattern 2 | Result
  --- | --- | ---
  /hotels | `null` | /hotels
  `null` | /hotels | /hotels
  /hotels | /bookings | /hotels/bookings
  /hotels | bookings | /hotels/bookings
  /hotels/* | /bookings | /hotels/bookings
  /hotels/** | /bookings | /hotels/**/bookings
  /hotels | {hotel} | /hotels/{hotel}
  /hotels/* | {hotel} | /hotels/{hotel}
  /hotels/** | {hotel} | /hotels/**/{hotel}
  /*.html | /hotels.html | /hotels.html
  /*.html | /hotels | /hotels.html
  /*.html | /*.txt | IllegalArgumentException

  Specified by:
    `combine` in interface `PathMatcher`
  Parameters:
    `pattern1` - the first pattern
    `pattern2` - the second pattern
  Returns:
    the combination of the two patterns
  Throws:
    `IllegalArgumentException` - when the two patterns cannot be combined

### getPatternComparator

    public Comparator<String> getPatternComparator(String path)

  Given a full path, returns a `Comparator` suitable for sorting patterns in order of explicitness.

  The returned `Comparator` will sort a list so that more specific patterns (without uri templates or wild cards) come before generic patterns. So given a list with the following patterns:

  1. `/hotels/new`
  2. `/hotels/{hotel}`
  3. `/hotels/*`
  the returned comparator will sort this list so that the order will be as indicated.

  The full path given as parameter is used to test for exact matches. So when the given path is `/hotels/2`, the pattern `/hotels/2` will be sorted before `/hotels/1`.

  Specified by:
    `getPatternComparator` in interface `PathMatcher`
  Parameters:
    `path` - the full path to use for comparison
  Returns:
    a comparator capable of sorting patterns in order of explicitness