public class

AntPathMatcher

extends Object
implements PathMatcher
java.lang.Object
   ↳ org.springframework.util.AntPathMatcher

Class Overview

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

Summary

Constants
String DEFAULT_PATH_SEPARATOR Default path separator: "/"
Public Constructors
AntPathMatcher()
Public Methods
String combine(String pattern1, String pattern2)
Combines two patterns into a new pattern that is returned.
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?

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

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.
Protected Methods
boolean doMatch(String pattern, String path, boolean fullMatch, Map<String, String> uriTemplateVariables)
Actually match the given path against the given pattern.
[Expand]
Inherited Methods
From class java.lang.Object
From interface org.springframework.util.PathMatcher

Constants

public static final String DEFAULT_PATH_SEPARATOR

Also: SpringCore

Default path separator: "/"

Constant Value: "/"

Public Constructors

public AntPathMatcher ()

Also: SpringCore

Public Methods

public String combine (String pattern1, String pattern2)

Also: SpringCore

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 1Pattern 2Result
/hotelsnull/hotels
null/hotels/hotels
/hotels/bookings/hotels/bookings
/hotelsbookings/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/*.txtIllegalArgumentException

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

public String extractPathWithinPattern (String pattern, String path)

Also: SpringCore

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(String, String) returns true for 'pattern' and 'path', but does not enforce this.

Parameters
pattern the path pattern
path the full path to introspect
Returns
  • the pattern-mapped part of the given path (never null)

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

Also: SpringCore

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".

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

public Comparator<String> getPatternComparator (String path)

Also: SpringCore

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.

Parameters
path the full path to use for comparison
Returns
  • a comparator capable of sorting patterns in order of explicitness

public boolean isPattern (String path)

Also: SpringCore

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 match(String, String) method does not have to be used because direct equality comparisons on the static path Strings will lead to the same result.

Parameters
path the path String to check
Returns
  • true if the given path represents a pattern

public boolean match (String pattern, String path)

Also: SpringCore

Match the given path against the given pattern, according to this PathMatcher's matching strategy.

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

public boolean matchStart (String pattern, String path)

Also: SpringCore

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.

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

public void setPathSeparator (String pathSeparator)

Also: SpringCore

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

Protected Methods

protected boolean doMatch (String pattern, String path, boolean fullMatch, Map<String, String> uriTemplateVariables)

Also: SpringCore

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