AntPathMatcher (aio-socket-http-common 1.3.0 API)

java.lang.Object
- cn.starboot.http.common.utils.AntPathMatcher

public class AntPathMatcher
extends Object

嵌套类概要

嵌套类
限定符和类型	类和说明
`protected static class`	`AntPathMatcher.AntPathStringMatcher` Tests whether or not a string matches against a pattern via a `Pattern`.
`protected static class`	`AntPathMatcher.AntPatternComparator` The default `Comparator` implementation returned by `getPatternComparator(String)`.
`private static class`	`AntPathMatcher.PathSeparatorPatternCache` A simple cache for patterns that depend on the configured path separator.

字段概要

字段
限定符和类型	字段和说明
`private static int`	`CACHE_TURNOFF_THRESHOLD`
`private Boolean`	`cachePatterns`
`static String`	`DEFAULT_PATH_SEPARATOR` Default path separator: "/"
`private String`	`pathSeparator`
`private AntPathMatcher.PathSeparatorPatternCache`	`pathSeparatorPatternCache`
`(专用程序包) Map<String,AntPathMatcher.AntPathStringMatcher>`	`stringMatcherCache`
`private Map<String,String[]>`	`tokenizedPatternCache`
`private boolean`	`trimTokens`
`private static Pattern`	`VARIABLE_PATTERN`

构造器概要

构造器
构造器和说明
`AntPathMatcher()` Create a new instance with the `DEFAULT_PATH_SEPARATOR`.
`AntPathMatcher(String pathSeparator)` A convenient, alternative constructor to use with a custom path separator.

方法概要

所有方法实例方法具体方法
限定符和类型	方法和说明
`private String`	`concat(String path1, String path2)`
`private void`	`deactivatePatternCache()`
`protected boolean`	`doMatch(String pattern, String path, boolean fullMatch, Map<String,String> uriTemplateVariables)` Actually match the given `path` against the given `pattern`.
`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)`
`Comparator<String>`	`getPatternComparator(String path)` Given a full path, returns a `Comparator` suitable for sorting patterns in order of explicitness.
`protected AntPathMatcher.AntPathStringMatcher`	`getStringMatcher(String pattern)` Build or retrieve an `AntPathMatcher.AntPathStringMatcher` for the given pattern.
`boolean`	`isPattern(String path)`
`boolean`	`match(String pattern, String path)`
`boolean`	`matchStart(String pattern, String path)`
`private boolean`	`matchStrings(String pattern, String str, Map<String,String> uriTemplateVariables)` Test whether or not a string matches against a pattern.
`void`	`setCachePatterns(boolean cachePatterns)` Specify whether to cache parsed pattern metadata for patterns passed into this matcher's `match(java.lang.String, java.lang.String)` method.
`void`	`setPathSeparator(String pathSeparator)` Set the path separator to use for pattern parsing.
`void`	`setTrimTokens(boolean trimTokens)` Specify whether to trim tokenized paths and patterns.
`protected String[]`	`tokenizePath(String path)` Tokenize the given path String into parts, based on this matcher's settings.
`protected String[]`	`tokenizePattern(String pattern)` Tokenize the given path pattern into parts, based on this matcher's settings.

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - DEFAULT_PATH_SEPARATOR
```
public static final String DEFAULT_PATH_SEPARATOR
```
    Default path separator: "/"
    
    另请参阅:
    
    常量字段值
  - CACHE_TURNOFF_THRESHOLD
```
private static final int CACHE_TURNOFF_THRESHOLD
```
    另请参阅:
    
    常量字段值
  - VARIABLE_PATTERN
```
private static final Pattern VARIABLE_PATTERN
```
  - stringMatcherCache
```
final Map<String,AntPathMatcher.AntPathStringMatcher> stringMatcherCache
```
  - tokenizedPatternCache
```
private final Map<String,String[]> tokenizedPatternCache
```
  - pathSeparator
```
private String pathSeparator
```
  - pathSeparatorPatternCache
```
private AntPathMatcher.PathSeparatorPatternCache pathSeparatorPatternCache
```
  - trimTokens
```
private boolean trimTokens
```
  - cachePatterns
```
private volatile Boolean cachePatterns
```
- 构造器详细资料
  - AntPathMatcher
```
public AntPathMatcher()
```
    Create a new instance with the DEFAULT_PATH_SEPARATOR.
  - AntPathMatcher
```
public AntPathMatcher(String pathSeparator)
```
    A convenient, alternative constructor to use with a custom path separator.
    
    参数:
    
    pathSeparator - the path separator to use, must not be null.
    
    从以下版本开始:
    
    4.1
- 方法详细资料
  - 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.
  - setCachePatterns
```
public void setCachePatterns(boolean cachePatterns)
```
    Specify whether to cache parsed pattern metadata for patterns passed into this matcher's match(java.lang.String, java.lang.String) method. A value of true activates an unlimited pattern cache; a value of false turns the pattern cache off completely.
    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.
    
    从以下版本开始:
    
    4.0.1
    
    另请参阅:
    
    getStringMatcher(String)
  - deactivatePatternCache
```
private void deactivatePatternCache()
```
  - isPattern
```
public boolean isPattern(String path)
```
  - match
```
public boolean match(String pattern,
                     String path)
```
  - matchStart
```
public boolean matchStart(String pattern,
                          String path)
```
  - doMatch
```
protected boolean doMatch(String pattern,
                          String path,
                          boolean fullMatch,
                          Map<String,String> uriTemplateVariables)
```
    Actually match the given path against the given pattern.
    
    参数:
    
    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)
    
    返回:
    
    true if the supplied path matched, false if it didn't
  - tokenizePattern
```
protected String[] tokenizePattern(String pattern)
```
    Tokenize the given path pattern into parts, based on this matcher's settings.
    Performs caching based on setCachePatterns(boolean), delegating to tokenizePath(String) for the actual tokenization algorithm.
    
    参数:
    
    pattern - the pattern to tokenize
    
    返回:
    
    the tokenized pattern parts
  - tokenizePath
```
protected String[] tokenizePath(String path)
```
    Tokenize the given path String into parts, based on this matcher's settings.
    
    参数:
    
    path - the path to tokenize
    
    返回:
    
    the tokenized path parts
  - matchStrings
```
private boolean matchStrings(String pattern,
                             String str,
                             Map<String,String> uriTemplateVariables)
```
    Test whether or not a string matches against a pattern.
    
    参数:
    
    pattern - the pattern to match against (never null)
    
    str - the String which must be matched against the pattern (never null)
    
    返回:
    
    true if the string matches against the pattern, or false otherwise
  - getStringMatcher
```
protected AntPathMatcher.AntPathStringMatcher getStringMatcher(String pattern)
```
    Build or retrieve an AntPathMatcher.AntPathStringMatcher for the given pattern.
    The default implementation checks this AntPathMatcher's internal cache (see setCachePatterns(boolean)), creating a new AntPathStringMatcher instance if no cached copy is found.
    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.
    This method may be overridden to implement a custom cache strategy.
    
    参数:
    
    pattern - the pattern to match against (never null)
    
    返回:
    
    a corresponding AntPathStringMatcher (never null)
    
    另请参阅:
    
    setCachePatterns(boolean)
  - 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.
  - extractUriTemplateVariables
```
public Map<String,String> extractUriTemplateVariables(String pattern,
                                                      String path)
```
  - concat
```
private String concat(String path1,
                      String path2)
```
  - getPatternComparator
```
public Comparator<String> getPatternComparator(String path)
```
    Given a full path, returns a Comparator suitable for sorting patterns in order of explicitness.
    ThisComparator 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.
    参数:
    
    path - the full path to use for comparison
    
    返回:
    
    a comparator capable of sorting patterns in order of explicitness

类 AntPathMatcher

嵌套类概要

字段概要

构造器概要

方法概要

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

字段详细资料

DEFAULT_PATH_SEPARATOR

CACHE_TURNOFF_THRESHOLD

VARIABLE_PATTERN

stringMatcherCache

tokenizedPatternCache

pathSeparator

pathSeparatorPatternCache

trimTokens

cachePatterns

构造器详细资料

AntPathMatcher

AntPathMatcher

方法详细资料

setPathSeparator

setTrimTokens

setCachePatterns

deactivatePatternCache

isPattern

match

matchStart

doMatch

tokenizePattern

tokenizePath

matchStrings

getStringMatcher

extractPathWithinPattern

extractUriTemplateVariables

concat

getPatternComparator