PathPattern

java.lang.Object
- org.springframework.web.util.pattern.PathPattern

All Implemented Interfaces:

java.lang.Comparable<PathPattern>
```
public class PathPattern
extends java.lang.Object
implements java.lang.Comparable<PathPattern>
```
Representation of a parsed path pattern. Includes a chain of path elements for fast matching and accumulates computed state for quick comparison of patterns.
PathPattern matches URL paths using the following rules:
- ? matches one character
- * matches zero or more characters within a path segment
- ** matches zero or more path segments until the end of the path
- {spring} matches a path segment and captures it as a variable named "spring"
- {spring:[a-z]+} matches the regexp [a-z]+ as a path variable named "spring"
- {*spring} matches zero or more path segments until the end of the path and captures it as a variable named "spring"
Examples
- /pages/t?st.html — matches /pages/test.html but also /pages/tast.html but not /pages/toast.html
- /resources/*.png — matches all .png files in the resources directory
- /resources/** — matches all files underneath the /resources/ path, including /resources/image.png and /resources/css/spring.css
- /resources/{*path} — matches all files underneath the /resources/ path and captures their relative path in a variable named "path"; /resources/image.png will match with "spring" -> "/image.png", and /resources/css/spring.css will match with "spring" -> "/css/spring.css"
- /resources/{filename:\\w+}.dat will match /resources/spring.dat and assign the value "spring" to the filename variable
Since:

5.0

Author:

Andy Clement, Rossen Stoyanchev

See Also:

PathContainer

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`(package private) class`	`PathPattern.MatchingContext` Encapsulates context when attempting a match.
`static class`	`PathPattern.PathMatchInfo` Holder for URI variables and path parameters (matrix variables) extracted based on the pattern for a given matched path.
`static class`	`PathPattern.PathRemainingMatchInfo` Holder for the result of a match on the start of a pattern.

Field Summary

Fields
Modifier and Type	Field and Description
`private int`	`capturedVariableCount` How many variables are captured in this pattern
`private boolean`	`caseSensitive` Will this match candidates in a case sensitive way? (case sensitivity at parse time)
`private boolean`	`catchAll` Does the pattern end with {*...}
`private static PathContainer`	`EMPTY_PATH`
`private boolean`	`endsWithSeparatorWildcard` Does the pattern end with '<separator>*'
`private PathElement`	`head` First path element in the parsed chain of path elements for this pattern
`private boolean`	`matchOptionalTrailingSeparator` If this pattern has no trailing slash, allow candidates to include one and still match successfully
`private int`	`normalizedLength` The normalized length is trying to measure the 'active' part of the pattern.
`private PathPatternParser`	`parser` The parser used to construct this pattern
`private java.lang.String`	`patternString` The text of the parsed pattern
`private int`	`score` Score is used to quickly compare patterns.
`private char`	`separator` The separator used when parsing the pattern
`static java.util.Comparator<PathPattern>`	`SPECIFICITY_COMPARATOR` Comparator that sorts patterns by specificity as follows: Null instances are last.

Constructor Summary

Constructors
Constructor and Description

PathPattern(java.lang.String patternText, PathPatternParser parser, PathElement head)

Constructors
Constructor and Description
`PathPattern(java.lang.String patternText, PathPatternParser parser, PathElement head)`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`PathPattern`	`combine(PathPattern pattern2string)` Combine this pattern with another.
`int`	`compareTo(PathPattern otherPattern)` Compare this pattern with a supplied pattern: return -1,0,+1 if this pattern is more specific, the same or less specific than the supplied pattern.
`(package private) java.lang.String`	`computePatternString()`
`private java.lang.String`	`concat(java.lang.String path1, java.lang.String path2)` Join two paths together including a separator if necessary.
`boolean`	`equals(java.lang.Object other)`
`PathContainer`	`extractPathWithinPattern(PathContainer path)` Determine the pattern-mapped part for the given path.
`private java.lang.String`	`extractPathWithinPattern(java.lang.String path)`
`(package private) int`	`getCapturedVariableCount()`
`(package private) PathElement`	`getHeadSection()`
`(package private) int`	`getNormalizedLength()` The normalized length is trying to measure the 'active' part of the pattern.
`java.lang.String`	`getPatternString()` Return the original String that was parsed to create this PathPattern.
`(package private) int`	`getScore()`
`(package private) char`	`getSeparator()`
`int`	`hashCode()`
`private boolean`	`hasLength(PathContainer container)`
`(package private) boolean`	`isCatchAll()`
`PathPattern.PathMatchInfo`	`matchAndExtract(PathContainer pathContainer)` Match this pattern to the given URI path and return extracted URI template variables as well as path parameters (matrix variables).
`boolean`	`matches(PathContainer pathContainer)` Whether this pattern matches the given path.
`PathPattern.PathRemainingMatchInfo`	`matchStartOfPath(PathContainer pathContainer)` Match the beginning of the given path and return the remaining portion not covered by this pattern.
`private static int`	`scoreByNormalizedLength(PathPattern pattern)`
`(package private) java.lang.String`	`toChainString()`
`java.lang.String`	`toString()`

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

- Field Detail
  - EMPTY_PATH
```
private static final PathContainer EMPTY_PATH
```
  - patternString
```
private final java.lang.String patternString
```
    The text of the parsed pattern
  - parser
```
private final PathPatternParser parser
```
    The parser used to construct this pattern
  - separator
```
private final char separator
```
    The separator used when parsing the pattern
  - matchOptionalTrailingSeparator
```
private final boolean matchOptionalTrailingSeparator
```
    If this pattern has no trailing slash, allow candidates to include one and still match successfully
  - caseSensitive
```
private final boolean caseSensitive
```
    Will this match candidates in a case sensitive way? (case sensitivity at parse time)
  - head
```
@Nullable
private final PathElement head
```
    First path element in the parsed chain of path elements for this pattern
  - capturedVariableCount
```
private int capturedVariableCount
```
    How many variables are captured in this pattern
  - normalizedLength
```
private int normalizedLength
```
    The normalized length is trying to measure the 'active' part of the pattern. It is computed by assuming all captured variables have a normalized length of 1. Effectively this means changing your variable name lengths isn't going to change the length of the active part of the pattern. Useful when comparing two patterns.
  - endsWithSeparatorWildcard
```
private boolean endsWithSeparatorWildcard
```
    Does the pattern end with '<separator>*'
  - score
```
private int score
```
    Score is used to quickly compare patterns. Different pattern components are given different weights. A 'lower score' is more specific. Current weights:
    - Captured variables are worth 1
    - Wildcard is worth 100
  - catchAll
```
private boolean catchAll
```
    Does the pattern end with {*...}
  - SPECIFICITY_COMPARATOR
```
public static final java.util.Comparator<PathPattern> SPECIFICITY_COMPARATOR
```
    Comparator that sorts patterns by specificity as follows:
    1. Null instances are last.
    2. Catch-all patterns are last.
    3. If both patterns are catch-all, consider the length (longer wins).
    4. Compare wildcard and captured variable count (lower wins).
    5. Consider length (longer wins)
- Constructor Detail
  - PathPattern
```
PathPattern(java.lang.String patternText,
            PathPatternParser parser,
            @Nullable
            PathElement head)
```
- Method Detail
  - getPatternString
```
public java.lang.String getPatternString()
```
    Return the original String that was parsed to create this PathPattern.
  - matches
```
public boolean matches(PathContainer pathContainer)
```
    Whether this pattern matches the given path.
    
    Parameters:
    
    pathContainer - the candidate path to attempt to match against
    
    Returns:
    
    true if the path matches this pattern
  - matchAndExtract
```
@Nullable
public PathPattern.PathMatchInfo matchAndExtract(PathContainer pathContainer)
```
    Match this pattern to the given URI path and return extracted URI template variables as well as path parameters (matrix variables).
    
    Parameters:
    
    pathContainer - the candidate path to attempt to match against
    
    Returns:
    
    info object with the extracted variables, or null for no match
  - matchStartOfPath
```
@Nullable
public PathPattern.PathRemainingMatchInfo matchStartOfPath(PathContainer pathContainer)
```
    Match the beginning of the given path and return the remaining portion not covered by this pattern. This is useful for matching nested routes where the path is matched incrementally at each level.
    
    Parameters:
    
    pathContainer - the candidate path to attempt to match against
    
    Returns:
    
    info object with the match result or null for no match
  - extractPathWithinPattern
```
public PathContainer extractPathWithinPattern(PathContainer path)
```
    Determine the pattern-mapped part for the given 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'
    Note: Assumes that matches(org.springframework.http.server.PathContainer) returns true for the same path but does not enforce this.
    Parameters:
    
    path - a path that matches this pattern
    
    Returns:
    
    the subset of the path that is matched by pattern or "" if none of it is matched by pattern elements
  - extractPathWithinPattern
```
private java.lang.String extractPathWithinPattern(java.lang.String path)
```
  - compareTo
```
public int compareTo(@Nullable
                     PathPattern otherPattern)
```
    Compare this pattern with a supplied pattern: return -1,0,+1 if this pattern is more specific, the same or less specific than the supplied pattern. The aim is to sort more specific patterns first.
    
    Specified by:
    
    compareTo in interface java.lang.Comparable<PathPattern>
  - combine
```
public PathPattern combine(PathPattern pattern2string)
```
    Combine this pattern with another. Currently does not produce a new PathPattern, just produces a new string.
  - equals
```
public boolean equals(java.lang.Object other)
```
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - getScore
```
int getScore()
```
  - isCatchAll
```
boolean isCatchAll()
```
  - getNormalizedLength
```
int getNormalizedLength()
```
    The normalized length is trying to measure the 'active' part of the pattern. It is computed by assuming all capture variables have a normalized length of 1. Effectively this means changing your variable name lengths isn't going to change the length of the active part of the pattern. Useful when comparing two patterns.
  - getSeparator
```
char getSeparator()
```
  - getCapturedVariableCount
```
int getCapturedVariableCount()
```
  - toChainString
```
java.lang.String toChainString()
```
  - computePatternString
```
java.lang.String computePatternString()
```
    Returns:
    
    string form of the pattern built from walking the path element chain
  - getHeadSection
```
@Nullable
PathElement getHeadSection()
```
  - concat
```
private java.lang.String concat(java.lang.String path1,
                                java.lang.String path2)
```
    Join two paths together including a separator if necessary. Extraneous separators are removed (if the first path ends with one and the second path starts with one).
    
    Parameters:
    
    path1 - first path
    
    path2 - second path
    
    Returns:
    
    joined path that may include separator if necessary
  - hasLength
```
private boolean hasLength(@Nullable
                          PathContainer container)
```
    Parameters:
    
    container - a path container
    
    Returns:
    
    true if the container is not null and has more than zero elements
  - scoreByNormalizedLength
```
private static int scoreByNormalizedLength(PathPattern pattern)
```

Class PathPattern

Examples

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_PATH

patternString

parser

separator

matchOptionalTrailingSeparator

caseSensitive

head

capturedVariableCount

normalizedLength

endsWithSeparatorWildcard

score

catchAll

SPECIFICITY_COMPARATOR

Constructor Detail

PathPattern

Method Detail

getPatternString

matches

matchAndExtract

matchStartOfPath

extractPathWithinPattern

extractPathWithinPattern

compareTo

combine

equals

hashCode

toString

getScore

isCatchAll

getNormalizedLength

getSeparator

getCapturedVariableCount

toChainString

computePatternString

getHeadSection

concat

hasLength

scoreByNormalizedLength