程序包 cn.taketoday.web.util.pattern

类 PathPattern

java.lang.Object

cn.taketoday.web.util.pattern.PathPattern

所有已实现的接口:

Comparable<PathPattern>

public class PathPattern
extends Object
implements 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"

Note: In contrast to AntPathMatcher, ** is supported only at the end of a pattern. For example /pages/{**} is valid but /pages/{**}/details is not. The same applies also to the capturing variant {*spring}. The aim is to eliminate ambiguity when comparing patterns for specificity.

Examples

• /pages/t?st.html — matches /pages/test.html as well as /pages/tXst.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/, as well as /resources, and captures their relative path in a variable named "path"; /resources/image.png will match with "path" → "/image.png", and /resources/css/spring.css will match with "path" → "/css/spring.css"
• /resources/{filename:\\w+}.dat will match /resources/spring.dat and assign the value "spring" to the filename variable

从以下版本开始:

4.0

作者:

Andy Clement, Rossen Stoyanchev

另请参阅:

• PathContainer

嵌套类概要

嵌套类

修饰符和类型	类	说明
(专用程序包) class	PathPattern.MatchingContext	Encapsulates context when attempting a match.
static class	PathPattern.PathRemainingMatchInfo	Holder for the result of a match on the start of a pattern.

字段概要

字段

修饰符和类型	字段	说明
private int	capturedVariableCount	How many variables are captured in this pattern.
private final boolean	caseSensitive	Will this match candidates in a case sensitive way?
private boolean	catchAll	Does the pattern end with {*...}.
private static final PathContainer	EMPTY_PATH
private boolean	endsWithSeparatorWildcard	Does the pattern end with '<separator>'.
private final PathElement	head	First path element in the parsed chain of path elements for this pattern.
private final 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 final PathPatternParser	parser	The parser used to construct this pattern.
private final PathContainer.Options	pathOptions	The options to use to parse a pattern.
private final String	patternString	The text of the parsed pattern.
private int	score	Score is used to quickly compare patterns.
static final Comparator<PathPattern>	SPECIFICITY_COMPARATOR	Comparator that sorts patterns by specificity as follows: Null instances are last.
private ArrayList<String>	variableNames

构造器概要

构造器

构造器	说明
PathPattern(String patternText, PathPatternParser parser, PathElement head)

方法概要

修饰符和类型	方法	说明
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.
(专用程序包) String	computePatternString()	Return the string form of the pattern built from walking the path element chain.
private String	concat(String path1, String path2)	Join two paths together including a separator if necessary.
boolean	equals(Object other)
PathContainer	extractPathWithinPattern(PathContainer path)	Determine the pattern-mapped part for the given path.
(专用程序包) int	getCapturedVariableCount()
(专用程序包) PathElement	getHeadSection()
(专用程序包) int	getNormalizedLength()	The normalized length is trying to measure the 'active' part of the pattern.
String	getPatternString()	Return the original String that was parsed to create this PathPattern.
(专用程序包) int	getScore()
(专用程序包) char	getSeparator()
ArrayList<String>	getVariableNames()	returns variable names
int	hashCode()
private boolean	hasLength(PathContainer container)	Return if the container is not null and has more than zero elements.
boolean	hasPatternSyntax()	Whether the pattern string contains pattern syntax that would require use of matches(PathContainer), or if it is a regular String that could be compared directly to others.
(专用程序包) boolean	isCatchAll()
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 boolean	pathContainerIsJustSeparator(PathContainer pathContainer)
private static int	scoreByNormalizedLength(PathPattern pattern)
(专用程序包) String	toChainString()
String	toString()

从类继承的方法 java.lang.Object

clone, finalize, getClass, notify, notifyAll, wait, wait, wait

字段详细资料

EMPTY_PATH

private static final PathContainer EMPTY_PATH

SPECIFICITY_COMPARATOR

public static final 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)

patternString

private final String patternString

The text of the parsed pattern.

parser

private final PathPatternParser parser

The parser used to construct this pattern.

pathOptions

private final PathContainer.Options pathOptions

The options to use to parse a 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 {*...}.

variableNames

@Nullable
private ArrayList<String> variableNames

构造器详细资料

PathPattern

PathPattern(String patternText,
 PathPatternParser parser,
 @Nullable
 PathElement head)

方法详细资料

getPatternString

public String getPatternString()

Return the original String that was parsed to create this PathPattern.

hasPatternSyntax

public boolean hasPatternSyntax()

Whether the pattern string contains pattern syntax that would require use of matches(PathContainer), or if it is a regular String that could be compared directly to others.

matches

public boolean matches(PathContainer pathContainer)

Whether this pattern matches the given path.

参数:

pathContainer - the candidate path to attempt to match against

返回:

true if the path matches this pattern

matchAndExtract

@Nullable
public 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).

参数:

pathContainer - the candidate path to attempt to match against

返回:

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.

参数:

pathContainer - the candidate path to attempt to match against

返回:

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'

Notes:

• Assumes that matches(cn.taketoday.http.server.PathContainer) returns true for the same path but does not enforce this.
• Duplicate occurrences of separators within the returned result are removed
• Leading and trailing separators are removed from the returned result

参数:

path - a path that matches this pattern

返回:

the subset of the path that is matched by pattern or "" if none of it is matched by pattern elements

getVariableNames

public ArrayList<String> getVariableNames()

returns variable names

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.

指定者:

compareTo 在接口中 Comparable<PathPattern>

combine

public PathPattern combine(PathPattern pattern2string)

Combine this pattern with another.

equals

public boolean equals(@Nullable
 Object other)

覆盖:

equals 在类中 Object

hashCode

public int hashCode()

覆盖:

hashCode 在类中 Object

toString

public String toString()

覆盖:

toString 在类中 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

String toChainString()

computePatternString

String computePatternString()

Return the string form of the pattern built from walking the path element chain.

返回:

the string form of the pattern

getHeadSection

@Nullable
PathElement getHeadSection()

concat

private String concat(String path1,
 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).

参数:

path1 - first path

path2 - second path

返回:

joined path that may include separator if necessary

hasLength

private boolean hasLength(@Nullable
 PathContainer container)

Return if the container is not null and has more than zero elements.

参数:

container - a path container

返回:

true has more than zero elements

scoreByNormalizedLength

private static int scoreByNormalizedLength(PathPattern pattern)

pathContainerIsJustSeparator

private boolean pathContainerIsJustSeparator(PathContainer pathContainer)