Add PathPatternRegistry for handler mapping matching

Previously `HandlerMapping` implementation were heavily relying on
`String` path patterns, `PathMatcher` implementations and dedicated maps
for matching incoming request URL to an actual request handler.

This commit adds the `PathPatternRegistry` that holds `PathPattern`
instances and the associated request handler — matching results are then
shared as `PathMatchResult` instances. `AbstractUrlHandlerMapping` will
use this registry directly, but other components dealing with request
matching (like `PatternsRequestCondition`) will directly use ordered
`PathPattern` collections since ordering is important there.

This opens the door for faster request matching and simplifies the
design of this part.

Issue: SPR-15608

Author: bclozel

spring-web/src/main/java/org/springframework/web/util/pattern/PathPatternComparator.java

@@ -0,0 +1,66 @@
+/*
+ * Copyright 2002-2017 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.springframework.web.util.pattern;
+
+import java.util.Comparator;
+
+/**
+ * {@link PathPattern} comparator that takes account of a specified
+ * path and sorts anything that exactly matches it to be first.
+ *
+ * <p>Patterns that have the same specificity are then compared
+ * using their String representation, in order to avoid
+ * considering them as "duplicates" when sorting them
+ * in {@link java.util.Set} collections.
+ *
+ * @author Brian Clozel
+ * @since 5.0
+ */
+public class PathPatternComparator implements Comparator<PathPattern> {
+
+	private final String path;
+
+	public PathPatternComparator(String path) {
+		this.path = path;
+	}
+
+	@Override
+	public int compare(PathPattern o1, PathPattern o2) {
+		// Nulls get sorted to the end
+		if (o1 == null) {
+			return (o2 == null ? 0 : +1);
+		}
+		else if (o2 == null) {
+			return -1;
+		}
+		// exact matches get sorted first
+		if (o1.getPatternString().equals(path)) {
+			return (o2.getPatternString().equals(path)) ? 0 : -1;
+		}
+		else if (o2.getPatternString().equals(path)) {
+			return +1;
+		}
+		// compare pattern specificity
+		int result = o1.compareTo(o2);
+		// if equal specificity, sort using pattern string
+		if (result == 0) {
+			return o1.getPatternString().compareTo(o2.getPatternString());
+		}
+		return result;
+	}
+
+}

spring-webflux/src/main/java/org/springframework/web/reactive/config/PathMatchConfigurer.java

@@ -17,34 +17,27 @@
 package org.springframework.web.reactive.config;
 
 import org.springframework.lang.Nullable;
-import org.springframework.util.PathMatcher;
-import org.springframework.web.util.pattern.ParsingPathMatcher;
 
 /**
  * Assist with configuring {@code HandlerMapping}'s with path matching options.
  *
  * @author Rossen Stoyanchev
+ * @author Brian Clozel
  * @since 5.0
  */
 public class PathMatchConfigurer {
 
-	private Boolean suffixPatternMatch;
-
 	private Boolean trailingSlashMatch;
 
-	private Boolean registeredSuffixPatternMatch;
-
-	private PathMatcher pathMatcher;
-
+	private Boolean caseSensitiveMatch;
 
 	/**
-	 * Whether to use suffix pattern match (".*") when matching patterns to
-	 * requests. If enabled a method mapped to "/users" also matches to "/users.*".
-	 * <p>By default this is set to {@code true}.
-	 * @see #registeredSuffixPatternMatch
+	 * Whether to match to URLs irrespective of their case.
+	 * If enabled a method mapped to "/users" won't match to "/Users/".
+	 * <p>The default value is {@code false}.
 	 */
-	public PathMatchConfigurer setUseSuffixPatternMatch(Boolean suffixPatternMatch) {
-		this.suffixPatternMatch = suffixPatternMatch;
+	public PathMatchConfigurer setUseCaseSensitiveMatch(Boolean caseSensitiveMatch) {
+		this.caseSensitiveMatch = caseSensitiveMatch;
 		return this;
 	}
 
@@ -58,49 +51,14 @@ public PathMatchConfigurer setUseTrailingSlashMatch(Boolean trailingSlashMatch)
 		return this;
 	}
 
-	/**
-	 * Whether suffix pattern matching should work only against path extensions
-	 * that are explicitly registered. This is generally recommended to reduce
-	 * ambiguity and to avoid issues such as when a "." (dot) appears in the path
-	 * for other reasons.
-	 * <p>By default this is set to "true".
-	 */
-	public PathMatchConfigurer setUseRegisteredSuffixPatternMatch(Boolean registeredSuffixPatternMatch) {
-		this.registeredSuffixPatternMatch = registeredSuffixPatternMatch;
-		return this;
-	}
-
-	/**
-	 * Set the PathMatcher for matching URL paths against registered URL patterns.
-	 * <p>The default is a {@link org.springframework.web.util.pattern.ParsingPathMatcher}.
-	 */
-	public PathMatchConfigurer setPathMatcher(PathMatcher pathMatcher) {
-		this.pathMatcher = pathMatcher;
-		return this;
-	}
-
-	@Nullable
-	protected Boolean isUseSuffixPatternMatch() {
-		return this.suffixPatternMatch;
-	}
-
 	@Nullable
 	protected Boolean isUseTrailingSlashMatch() {
 		return this.trailingSlashMatch;
 	}
 
 	@Nullable
-	protected Boolean isUseRegisteredSuffixPatternMatch() {
-		return this.registeredSuffixPatternMatch;
-	}
-
-	@Nullable
-	public PathMatcher getPathMatcher() {
-		if (this.pathMatcher instanceof ParsingPathMatcher && (this.trailingSlashMatch || this.suffixPatternMatch)) {
-			throw new IllegalStateException("When using a ParsingPathMatcher, useTrailingSlashMatch" +
-					" and useSuffixPatternMatch should be set to 'false'.");
-		}
-		return this.pathMatcher;
+	protected Boolean isUseCaseSensitiveMatch() {
+		return this.caseSensitiveMatch;
 	}
 
 }

spring-webflux/src/main/java/org/springframework/web/reactive/config/ResourceHandlerRegistry.java

@@ -26,7 +26,7 @@
 import org.springframework.context.ApplicationContext;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
-import org.springframework.web.reactive.handler.AbstractHandlerMapping;
+import org.springframework.web.reactive.handler.AbstractUrlHandlerMapping;
 import org.springframework.web.reactive.handler.SimpleUrlHandlerMapping;
 import org.springframework.web.reactive.resource.ResourceWebHandler;
 import org.springframework.web.server.WebHandler;
@@ -76,7 +76,7 @@ public ResourceHandlerRegistry(ApplicationContext applicationContext) {
 	 * URL path patterns. The handler will be invoked for every incoming request
 	 * that matches to one of the specified path patterns.
 	 * <p>Patterns like {@code "/static/**"} or {@code "/css/{filename:\\w+\\.css}"}
-	 * are allowed. See {@link org.springframework.web.util.pattern.ParsingPathMatcher}
+	 * are allowed. See {@link org.springframework.web.util.pattern.PathPattern}
 	 * for more details on the syntax.
 	 * @return A {@link ResourceHandlerRegistration} to use to further
 	 * configure the registered resource handler
@@ -115,7 +115,7 @@ public ResourceHandlerRegistry setOrder(int order) {
 	 * of no registrations.
 	 */
 	@Nullable
-	protected AbstractHandlerMapping getHandlerMapping() {
+	protected AbstractUrlHandlerMapping getHandlerMapping() {
 		if (this.registrations.isEmpty()) {
 			return null;
 		}

spring-webflux/src/main/java/org/springframework/web/reactive/config/WebFluxConfigurationSupport.java

@@ -36,7 +36,6 @@
 import org.springframework.http.codec.ServerCodecConfigurer;
 import org.springframework.lang.Nullable;
 import org.springframework.util.ClassUtils;
-import org.springframework.util.PathMatcher;
 import org.springframework.validation.Errors;
 import org.springframework.validation.MessageCodesResolver;
 import org.springframework.validation.Validator;
@@ -73,13 +72,6 @@
  */
 public class WebFluxConfigurationSupport implements ApplicationContextAware {
 
-	static final boolean jackson2Present =
-			ClassUtils.isPresent("com.fasterxml.jackson.databind.ObjectMapper",
-					WebFluxConfigurationSupport.class.getClassLoader()) &&
-			ClassUtils.isPresent("com.fasterxml.jackson.core.JsonGenerator",
-					WebFluxConfigurationSupport.class.getClassLoader());
-
-
 	private Map<String, CorsConfiguration> corsConfigurations;
 
 	private PathMatchConfigurer pathMatchConfigurer;
@@ -118,21 +110,11 @@ public RequestMappingHandlerMapping requestMappingHandlerMapping() {
 		mapping.setCorsConfigurations(getCorsConfigurations());
 
 		PathMatchConfigurer configurer = getPathMatchConfigurer();
-		Boolean useSuffixPatternMatch = configurer.isUseSuffixPatternMatch();
-		Boolean useRegisteredSuffixPatternMatch = configurer.isUseRegisteredSuffixPatternMatch();
-		Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
-		if (useSuffixPatternMatch != null) {
-			mapping.setUseSuffixPatternMatch(useSuffixPatternMatch);
-		}
-		if (useRegisteredSuffixPatternMatch != null) {
-			mapping.setUseRegisteredSuffixPatternMatch(useRegisteredSuffixPatternMatch);
+		if (configurer.isUseTrailingSlashMatch() != null) {
+			mapping.setUseTrailingSlashMatch(configurer.isUseTrailingSlashMatch());
 		}
-		if (useTrailingSlashMatch != null) {
-			mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
-		}
-		PathMatcher pathMatcher = configurer.getPathMatcher();
-		if (pathMatcher != null) {
-			mapping.setPathMatcher(pathMatcher);
+		if (configurer.isUseCaseSensitiveMatch() != null) {
+			mapping.setUseCaseSensitiveMatch(configurer.isUseCaseSensitiveMatch());
 		}
 		return mapping;
 	}
@@ -224,9 +206,12 @@ public HandlerMapping resourceHandlerMapping() {
 
 		AbstractHandlerMapping handlerMapping = registry.getHandlerMapping();
 		if (handlerMapping != null) {
-			PathMatchConfigurer pathMatchConfigurer = getPathMatchConfigurer();
-			if (pathMatchConfigurer.getPathMatcher() != null) {
-				handlerMapping.setPathMatcher(pathMatchConfigurer.getPathMatcher());
+			PathMatchConfigurer configurer = getPathMatchConfigurer();
+			if (configurer.isUseTrailingSlashMatch() != null) {
+				handlerMapping.setUseTrailingSlashMatch(configurer.isUseTrailingSlashMatch());
+			}
+			if (configurer.isUseCaseSensitiveMatch() != null) {
+				handlerMapping.setUseCaseSensitiveMatch(configurer.isUseCaseSensitiveMatch());
 			}
 		}
 		else {

spring-webflux/src/main/java/org/springframework/web/reactive/config/WebFluxConfigurer.java

@@ -58,13 +58,6 @@ default void addCorsMappings(CorsRegistry registry) {
 	/**
 	 * Configure path matching options.
 	 * 
-	 * <p>Note that if a {@link org.springframework.web.util.pattern.ParsingPathMatcher}
-	 * is configured here,
-	 * the {@link PathMatchConfigurer#setUseTrailingSlashMatch(Boolean)} and
-	 * {@link PathMatchConfigurer#setUseSuffixPatternMatch(Boolean)} options must be set
-	 * to {@literal false}as they can lead to illegal patterns,
-	 * see {@link org.springframework.web.util.pattern.ParsingPathMatcher}.
-	 * 
 	 * {@code HandlerMapping}s with path matching options.
 	 * @param configurer the {@link PathMatchConfigurer} instance
 	 */

spring-webflux/src/main/java/org/springframework/web/reactive/handler/AbstractHandlerMapping.java

@@ -24,7 +24,6 @@
 import org.springframework.core.Ordered;
 import org.springframework.lang.Nullable;
 import org.springframework.util.Assert;
-import org.springframework.util.PathMatcher;
 import org.springframework.web.cors.CorsConfiguration;
 import org.springframework.web.cors.reactive.CorsConfigurationSource;
 import org.springframework.web.cors.reactive.CorsProcessor;
@@ -34,7 +33,7 @@
 import org.springframework.web.reactive.HandlerMapping;
 import org.springframework.web.server.ServerWebExchange;
 import org.springframework.web.server.WebHandler;
-import org.springframework.web.util.pattern.ParsingPathMatcher;
+import org.springframework.web.util.pattern.PathPatternParser;
 
 /**
  * Abstract base class for {@link org.springframework.web.reactive.HandlerMapping}
@@ -52,7 +51,7 @@ public abstract class AbstractHandlerMapping extends ApplicationObjectSupport im
 
 	private int order = Integer.MAX_VALUE;  // default: same as non-Ordered
 
-	private PathMatcher pathMatcher = new ParsingPathMatcher();
+	private PathPatternParser patternParser = new PathPatternParser();
 
 	private final UrlBasedCorsConfigurationSource globalCorsConfigSource = new UrlBasedCorsConfigurationSource();
 
@@ -74,22 +73,28 @@ public final int getOrder() {
 	}
 
 	/**
-	 * Set the PathMatcher implementation to use for matching URL paths
-	 * against registered URL patterns.
-	 * <p>The default is a {@link ParsingPathMatcher}.
+	 * Whether to match to URLs irrespective of their case.
+	 * If enabled a method mapped to "/users" won't match to "/Users/".
+	 * <p>The default value is {@code false}.
 	 */
-	public void setPathMatcher(PathMatcher pathMatcher) {
-		Assert.notNull(pathMatcher, "PathMatcher must not be null");
-		this.pathMatcher = pathMatcher;
-		this.globalCorsConfigSource.setPathMatcher(pathMatcher);
+	public void setUseCaseSensitiveMatch(boolean caseSensitiveMatch) {
+		this.patternParser.setCaseSensitive(caseSensitiveMatch);
 	}
 
 	/**
-	 * Return the PathMatcher implementation to use for matching URL paths
-	 * against registered URL patterns.
+	 * Whether to match to URLs irrespective of the presence of a trailing slash.
+	 * If enabled a method mapped to "/users" also matches to "/users/".
+	 * <p>The default value is {@code true}.
 	 */
-	public PathMatcher getPathMatcher() {
-		return this.pathMatcher;
+	public void setUseTrailingSlashMatch(boolean trailingSlashMatch) {
+		this.patternParser.setMatchOptionalTrailingSlash(trailingSlashMatch);
+	}
+
+	/**
+	 * Return the {@link PathPatternParser} instance.
+	 */
+	public PathPatternParser getPathPatternParser() {
+		return this.patternParser;
 	}
 
 	/**