## org.springframework.web.servlet.mvc.condition
Class PatternsRequestCondition

    java.lang.Object
      org.springframework.web.servlet.mvc.condition.AbstractRequestCondition<PatternsRequestCondition>
          org.springframework.web.servlet.mvc.condition.PatternsRequestCondition

All Implemented Interfaces:
  RequestCondition<PatternsRequestCondition>

    public final class PatternsRequestCondition

extends AbstractRequestCondition<PatternsRequestCondition>

A logical disjunction (' || ') request condition that matches a request against a set of URL path patterns.

Since:
  3.1
Author:
  Rossen Stoyanchev

Constructor Summary
`PatternsRequestCondition(String... patterns)` Creates a new instance with the given URL patterns.
`PatternsRequestCondition(String[] patterns, UrlPathHelper urlPathHelper, PathMatcher pathMatcher, boolean useSuffixPatternMatch, boolean useTrailingSlashMatch)` Creates a new instance with the given URL patterns.

Method Summary
`PatternsRequestCondition` `combine(PatternsRequestCondition other)` Returns a new instance with URL patterns from the current instance ("this") and the "other" instance as follows: If there are patterns in both instances, combine the patterns in "this" with the patterns in "other" using `PathMatcher.combine(String, String)`.
`int` `compareTo(PatternsRequestCondition other, HttpServletRequest request)` Compare the two conditions based on the URL patterns they contain.
`protected Collection<String>` `getContent()` Return the discrete items a request condition is composed of.
`PatternsRequestCondition` `getMatchingCondition(HttpServletRequest request)` Checks if any of the patterns match the given request and returns an instance that is guaranteed to contain matching patterns, sorted via `PathMatcher.getPatternComparator(String)`.
`Set<String>` `getPatterns()`
`protected String` `getToStringInfix()` The notation to use when printing discrete items of content.

Methods inherited from class org.springframework.web.servlet.mvc.condition.AbstractRequestCondition
`equals, hashCode, toString`

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

Constructor Detail

### PatternsRequestCondition

    public PatternsRequestCondition(String... patterns)

  Creates a new instance with the given URL patterns. Each pattern that is not empty and does not start with "/" is pre-pended with "/".

  Parameters:
    `patterns` - 0 or more URL patterns; if 0 the condition will match to every request.

### PatternsRequestCondition

    public PatternsRequestCondition(String[] patterns,
                                    UrlPathHelper urlPathHelper,
                                    PathMatcher pathMatcher,
                                    boolean useSuffixPatternMatch,
                                    boolean useTrailingSlashMatch)

  Creates a new instance with the given URL patterns. Each pattern that is not empty and does not start with "/" is pre-pended with "/".

  Parameters:
    `patterns` - the URL patterns to use; if 0, the condition will match to every request.
    `urlPathHelper` - a `UrlPathHelper` for determining the lookup path for a request
    `pathMatcher` - a `PathMatcher` for pattern path matching
    `useSuffixPatternMatch` - whether to enable matching by suffix (".*")
    `useTrailingSlashMatch` - whether to match irrespective of a trailing slash

Method Detail

### getPatterns

    public Set<String> getPatterns()

### getContent

    protected Collection<String> getContent()

  Description copied from class: `AbstractRequestCondition`
  Return the discrete items a request condition is composed of. For example URL patterns, HTTP request methods, param expressions, etc.

  Specified by:
    `getContent` in class `AbstractRequestCondition<PatternsRequestCondition>`
  Returns:
    a collection of objects, never `null`

### getToStringInfix

    protected String getToStringInfix()

  Description copied from class: `AbstractRequestCondition`
  The notation to use when printing discrete items of content. For example " || " for URL patterns or " && " for param expressions.

  Specified by:
    `getToStringInfix` in class `AbstractRequestCondition<PatternsRequestCondition>`

### combine

    public PatternsRequestCondition combine(PatternsRequestCondition other)

  Returns a new instance with URL patterns from the current instance ("this") and the "other" instance as follows:
  - If there are patterns in both instances, combine the patterns in "this" with the patterns in "other" using `PathMatcher.combine(String, String)`.
  - If only one instance has patterns, use them.
  - If neither instance has patterns, use an empty String (i.e. "").

  Parameters:
    `other` - the condition to combine with.

### getMatchingCondition

    public PatternsRequestCondition getMatchingCondition(HttpServletRequest request)

  Checks if any of the patterns match the given request and returns an instance that is guaranteed to contain matching patterns, sorted via `PathMatcher.getPatternComparator(String)`.

  A matching pattern is obtained by making checks in the following order:

  - Direct match
  - Pattern match with ".*" appended if the pattern doesn't already contain a "."
  - Pattern match
  - Pattern match with "/" appended if the pattern doesn't already end in "/"

  Parameters:
    `request` - the current request
  Returns:
    the same instance if the condition contains no patterns; or a new condition with sorted matching patterns; or `null` if no patterns match.

### compareTo

    public int compareTo(PatternsRequestCondition other,
                         HttpServletRequest request)

  Compare the two conditions based on the URL patterns they contain. Patterns are compared one at a time, from top to bottom via `PathMatcher.getPatternComparator(String)`. If all compared patterns match equally, but one instance has more patterns, it is considered a closer match.

  It is assumed that both instances have been obtained via `getMatchingCondition(HttpServletRequest)` to ensure they contain only patterns that match the request and are sorted with the best matches on top.