public class AntPathMatcher extends Object implements PathMatcher
PathMatcher implementation for Ant-style path patterns.
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{spring:[a-z]+} matches the regexp [a-z]+ as a path variable named "spring"com/t?st.jsp — matches com/test.jsp but also
com/tast.jsp or com/txst.jspcom/*.jsp — matches all .jsp files in the
com directorycom/**/test.jsp — matches all test.jsp
files underneath the com pathorg/springframework/**/*.jsp — matches all
.jsp files underneath the org/springframework pathorg/**/servlet/bla.jsp — matches
org/springframework/servlet/bla.jsp but also
org/springframework/testing/servlet/bla.jsp and org/servlet/bla.jspcom/{filename:\\w+}.jsp will match com/test.jsp and assign the value test
to the filename variableNote: a pattern and a path must both be absolute or must both be relative in order for the two to match. Therefore it is recommended that users of this implementation to sanitize patterns in order to prefix them with "/" as it makes sense in the context in which they're used.
| Modifier and Type | Class and Description |
|---|---|
protected static class |
AntPathMatcher.AntPathStringMatcher
Tests whether or not a string matches against a pattern via a
Pattern. |
protected static class |
AntPathMatcher.AntPatternComparator
The default
Comparator implementation returned by
getPatternComparator(String). |
| Modifier and Type | Field and Description |
|---|---|
static String |
DEFAULT_PATH_SEPARATOR
Default path separator: "/".
|
| Constructor and Description |
|---|
AntPathMatcher()
Create a new instance with the
DEFAULT_PATH_SEPARATOR. |
AntPathMatcher(String pathSeparator)
A convenient, alternative constructor to use with a custom path separator.
|
| Modifier and Type | Method and Description |
|---|---|
String |
combine(String pattern1,
String pattern2)
Combine two patterns into a new pattern.
|
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. |
protected AntPathMatcher.AntPathStringMatcher |
getStringMatcher(String pattern)
Build or retrieve an
AntPathMatcher.AntPathStringMatcher for the given pattern. |
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 |
setCachePatterns(boolean cachePatterns)
Specify whether to cache parsed pattern metadata for patterns passed
into this matcher's
match(java.lang.String, java.lang.String) method. |
void |
setCaseSensitive(boolean caseSensitive)
Specify whether to perform pattern matching in a case-sensitive fashion.
|
void |
setPathSeparator(String pathSeparator)
Set the path separator to use for pattern parsing.
|
void |
setTrimTokens(boolean trimTokens)
Specify whether to trim tokenized paths and patterns.
|
protected String[] |
tokenizePath(String path)
Tokenize the given path into parts, based on this matcher's settings.
|
protected String[] |
tokenizePattern(String pattern)
Tokenize the given path pattern into parts, based on this matcher's settings.
|
public static final String DEFAULT_PATH_SEPARATOR
public AntPathMatcher()
DEFAULT_PATH_SEPARATOR.public AntPathMatcher(String pathSeparator)
pathSeparator - the path separator to use, must not be null.public void setPathSeparator(@Nullable String pathSeparator)
Default is "/", as in Ant.
public void setCaseSensitive(boolean caseSensitive)
Default is true. Switch this to false for case-insensitive matching.
public void setTrimTokens(boolean trimTokens)
Default is false.
public void setCachePatterns(boolean cachePatterns)
match(java.lang.String, java.lang.String) method. A value of true
activates an unlimited pattern cache; a value of false turns
the pattern cache off completely.
Default is for the cache to be on, but with the variant to automatically turn it off when encountering too many patterns to cache at runtime (the threshold is 65536), assuming that arbitrary permutations of patterns are coming in, with little chance for encountering a recurring pattern.
getStringMatcher(String)public boolean isPattern(@Nullable String path)
PathMatcherpath 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.
isPattern in interface PathMatcherpath - the path to checktrue if the given path represents a patternpublic boolean match(String pattern, String path)
PathMatcherpath against the given pattern,
according to this PathMatcher's matching strategy.match in interface PathMatcherpattern - the pattern to match againstpath - the path to testtrue if the supplied path matched,
false if it didn'tpublic boolean matchStart(String pattern, String path)
PathMatcherpath 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.
matchStart in interface PathMatcherpattern - the pattern to match againstpath - the path to testtrue if the supplied path matched,
false if it didn'tprotected boolean doMatch(String pattern, @Nullable String path, boolean fullMatch, @Nullable Map<String,String> uriTemplateVariables)
path against the given pattern.pattern - the pattern to match againstpath - the path to testfullMatch - whether a full pattern match is required (else a pattern match
as far as the given base path goes is sufficient)true if the supplied path matched, false if it didn'tprotected String[] tokenizePattern(String pattern)
Performs caching based on setCachePatterns(boolean), delegating to
tokenizePath(String) for the actual tokenization algorithm.
pattern - the pattern to tokenizeprotected String[] tokenizePath(String path)
path - the path to tokenizeprotected AntPathMatcher.AntPathStringMatcher getStringMatcher(String pattern)
AntPathMatcher.AntPathStringMatcher for the given pattern.
The default implementation checks this AntPathMatcher's internal cache
(see setCachePatterns(boolean)), creating a new AntPathStringMatcher instance
if no cached copy is found.
When encountering too many patterns to cache at runtime (the threshold is 65536), it turns the default cache off, assuming that arbitrary permutations of patterns are coming in, with little chance for encountering a recurring pattern.
This method may be overridden to implement a custom cache strategy.
pattern - the pattern to match against (never null)null)setCachePatterns(boolean)public String extractPathWithinPattern(String pattern, String path)
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.
extractPathWithinPattern in interface PathMatcherpattern - the path patternpath - the full path to introspectpath
(never null)public Map<String,String> extractUriTemplateVariables(String pattern, String path)
PathMatcherFor example: For pattern "/hotels/{hotel}" and path "/hotels/1", this method will return a map containing "hotel" → "1".
extractUriTemplateVariables in interface PathMatcherpattern - the path pattern, possibly containing URI templatespath - the full path to extract template variables frompublic String combine(String pattern1, String pattern2)
This implementation simply concatenates the two patterns, unless
the first pattern contains a file extension match (e.g., *.html).
In that case, the second pattern will be merged into the first. Otherwise,
an IllegalArgumentException will be thrown.
| Pattern 1 | Pattern 2 | Result |
|---|---|---|
null | null | |
| /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 |
combine in interface PathMatcherpattern1 - the first patternpattern2 - the second patternIllegalArgumentException - if the two patterns cannot be combinedpublic Comparator<String> getPatternComparator(String path)
Comparator suitable for sorting patterns in order of
explicitness.
This 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, the returned comparator
will sort this list so that the order will be as indicated.
/hotels/new/hotels/{hotel}/hotels/*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.
getPatternComparator in interface PathMatcherpath - the full path to use for comparison