Class AntPathMatcher

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.

• setTrimTokens

  public void setTrimTokens(boolean trimTokens)

  Specify whether to trim tokenized paths and patterns. Default is true.

• 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

• tokenizePath

  protected String[] tokenizePath(String path)

  Tokenize the given path String into parts, based on this matcher's settings.

  Parameters:

  path - the path to tokenize

  Returns:

  the tokenized path parts

• 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