Create a new instance with the {@link #DEFAULT_PATH_SEPARATOR}.
A convenient, alternative constructor to use with a custom path separator. @param pathSeparator the path separator to use, must not be {@code null}. @since 4.1
Combine two patterns into a new pattern. <p>This implementation simply concatenates the two patterns, unless the first pattern contains a file extension match (e.g., {@code *.html}). In that case, the second pattern will be merged into the first. Otherwise, an {@code IllegalArgumentException} will be thrown. <h3>Examples</h3> <table border="1"> <tr><th>Pattern 1</th><th>Pattern 2</th><th>Result</th></tr> <tr><td>{@code null}</td><td>{@code null}</td><td> </td></tr> <tr><td>/hotels</td><td>{@code null}</td><td>/hotels</td></tr> <tr><td>{@code null}</td><td>/hotels</td><td>/hotels</td></tr> <tr><td>/hotels</td><td>/bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels</td><td>bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels/*</td><td>/bookings</td><td>/hotels/bookings</td></tr> <tr><td>/hotels/**</td><td>/bookings</td><td>/hotels/**/bookings</td></tr> <tr><td>/hotels</td><td>{hotel}</td><td>/hotels/{hotel}</td></tr> <tr><td>/hotels/*</td><td>{hotel}</td><td>/hotels/{hotel}</td></tr> <tr><td>/hotels/**</td><td>{hotel}</td><td>/hotels/**/{hotel}</td></tr> <tr><td>/*.html</td><td>/hotels.html</td><td>/hotels.html</td></tr> <tr><td>/*.html</td><td>/hotels</td><td>/hotels.html</td></tr> <tr><td>/*.html</td><td>/*.txt</td><td>{@code IllegalArgumentException}</td></tr> </table> @param pattern1 the first pattern @param pattern2 the second pattern @return the combination of the two patterns @throws IllegalArgumentException if the two patterns cannot be combined
Actually match the given {@code path} against the given {@code pattern}. @param pattern the pattern to match against @param path the path string to test @param fullMatch whether a full pattern match is required (else a pattern match as far as the given base path goes is sufficient) @return {@code true} if the supplied {@code path} matched, {@code false} if it didn't
Given a pattern and a full path, determine the pattern-mapped part. <p>For example: <ul> <li>'{@code /docs/cvs/commit.html}' and '{@code /docs/cvs/commit.html} -> ''</li> <li>'{@code /docs/*}' and '{@code /docs/cvs/commit} -> '{@code cvs/commit}'</li> <li>'{@code /docs/cvs/*.html}' and '{@code /docs/cvs/commit.html} -> '{@code commit.html}'</li> <li>'{@code /docs/**}' and '{@code /docs/cvs/commit} -> '{@code cvs/commit}'</li> <li>'{@code /docs/**\/*.html}' and '{@code /docs/cvs/commit.html} -> '{@code cvs/commit.html}'</li> <li>'{@code /*.html}' and '{@code /docs/cvs/commit.html} -> '{@code docs/cvs/commit.html}'</li> <li>'{@code *.html}' and '{@code /docs/cvs/commit.html} -> '{@code /docs/cvs/commit.html}'</li> <li>'{@code *}' and '{@code /docs/cvs/commit.html} -> '{@code /docs/cvs/commit.html}'</li> </ul> <p>Assumes that {@link #match} returns {@code true} for '{@code pattern}' and '{@code path}', but does <strong>not</strong> enforce this.
Build or retrieve an {@link AntPathStringMatcher} for the given pattern. <p>The default implementation checks this AntPathMatcher's internal cache (see {@link #setCachePatterns}), creating a new AntPathStringMatcher instance if no cached copy is found. <p>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. <p>This method may be overridden to implement a custom cache strategy. @param pattern the pattern to match against (never {@code null}) @return a corresponding AntPathStringMatcher (never {@code null}) @see #setCachePatterns
Specify whether to cache parsed pattern metadata for patterns passed into this matcher's {@link #match} method. A value of {@code true} activates an unlimited pattern cache; a value of {@code false} turns the pattern cache off completely. <p>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. @since 4.0.1 @see #getStringMatcher(string)
Specify whether to perform pattern matching in a case-sensitive fashion. <p>Default is {@code true}. Switch this to {@code false} for case-insensitive matching. @since 4.2
Set the path separator to use for pattern parsing. <p>Default is "/", as in Ant.
Specify whether to trim tokenized paths and patterns. <p>Default is {@code false}.
Default path separator: "/"
Does the given {@code path} represent a pattern that can be matched by an implementation of this interface? <p>If the return value is {@code false}, then the {@link #match} method does not have to be used because direct equality comparisons on the static path Strings will lead to the same result. @param path the path string to check @return {@code true} if the given {@code path} represents a pattern
Match the given {@code path} against the given {@code pattern}, according to this PathMatcher's matching strategy. @param pattern the pattern to match against @param path the path string to test @return {@code true} if the supplied {@code path} matched, {@code false} if it didn't
Match the given {@code path} against the corresponding part of the given {@code pattern}, according to this PathMatcher's matching strategy. <p>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. @param pattern the pattern to match against @param path the path string to test @return {@code true} if the supplied {@code path} matched, {@code false} if it didn't
Given a pattern and a full path, determine the pattern-mapped part. <p>This method is supposed to find out which part of the path is matched dynamically through an actual pattern, that is, it strips off a statically defined leading path from the given full path, returning only the actually pattern-matched part of the path. <p>For example: For "myroot/*.html" as pattern and "myroot/myfile.html" as full path, this method should return "myfile.html". The detailed determination rules are specified to this PathMatcher's matching strategy. <p>A simple implementation may return the given full path as-is in case of an actual pattern, and the empty string in case of the pattern not containing any dynamic parts (i.e. the {@code pattern} parameter being a static path that wouldn't qualify as an actual {@link #isPattern pattern}). A sophisticated implementation will differentiate between the static parts and the dynamic parts of the given path pattern. @param pattern the path pattern @param path the full path to introspect @return the pattern-mapped part of the given {@code path} (never {@code null})
Given a pattern and a full path, extract the URI template variables. URI template variables are expressed through curly brackets ('{' and '}'). <p>For example: For pattern "/hotels/{hotel}" and path "/hotels/1", this method will return a map containing "hotel"->"1". @param pattern the path pattern, possibly containing URI templates @param path the full path to extract template variables from @return a map, containing variable names as keys; variables values as values
Combines two patterns into a new pattern that is returned. <p>The full algorithm used for combining the two pattern depends on the underlying implementation. @param pattern1 the first pattern @param pattern2 the second pattern @return the combination of the two patterns @throws IllegalArgumentException when the two patterns cannot be combined
{@link PathMatcher} implementation for Ant-style path patterns.
<p>Part of this mapping code has been kindly borrowed from <a href="http://ant.apache.org">Apache Ant</a>.
<p>The mapping matches URLs using the following rules:<br> <ul> <li>{@code ?} matches one character</li> <li>{@code *} matches zero or more characters</li> <li>{@code **} matches zero or more <em>directories</em> in a path</li> <li>{@code {spring:[a-z]+}} matches the regexp {@code [a-z]+} as a path variable named "spring"</li> </ul>
<h3>Examples</h3> <ul> <li>{@code com/t?st.jsp} — matches {@code com/test.jsp} but also {@code com/tast.jsp} or {@code com/txst.jsp}</li> <li>{@code com/*.jsp} — matches all {@code .jsp} files in the {@code com} directory</li> <li><code>com/**/test.jsp</code> — matches all {@code test.jsp} files underneath the {@code com} path</li> <li><code>org/springframework/**/*.jsp</code> — matches all {@code .jsp} files underneath the {@code org/springframework} path</li> <li><code>org/**/servlet/bla.jsp</code> — matches {@code org/springframework/servlet/bla.jsp} but also {@code org/springframework/testing/servlet/bla.jsp} and {@code org/servlet/bla.jsp}</li> <li>{@code com/{filename:\\w+}.jsp} will match {@code com/test.jsp} and assign the value {@code test} to the {@code filename} variable</li> </ul>
<p><strong>Note:</strong> 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.
@author Alef Arendsen @author Juergen Hoeller @author Rob Harrop @author Arjen Poutsma @author Rossen Stoyanchev @author Sam Brannen