Path prefixes for groups of controllers

Issue: SPR-16336

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

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -16,7 +16,11 @@
 
 package org.springframework.web.reactive.config;
 
+import java.util.LinkedHashMap;
+import java.util.Map;
+
 import org.springframework.lang.Nullable;
+import org.springframework.web.method.HandlerTypePredicate;
 
 /**
  * Assist with configuring {@code HandlerMapping}'s with path matching options.
@@ -34,6 +38,9 @@ public class PathMatchConfigurer {
 	@Nullable
 	private Boolean caseSensitiveMatch;
 
+	@Nullable
+	private Map<String, HandlerTypePredicate> pathPrefixes;
+
 
 	/**
 	 * Whether to match to URLs irrespective of their case.
@@ -55,6 +62,22 @@ public class PathMatchConfigurer {
 		return this;
 	}
 
+	/**
+	 * Configure a path prefix to apply to matching controller methods.
+	 * <p>Prefixes are used to enrich the mappings of every {@code @RequestMapping}
+	 * method whose controller type is matched by the corresponding
+	 * {@link HandlerTypePredicate}. The prefix for the first matching predicate
+	 * is used.
+	 * @param prefix the path prefix to apply
+	 * @param predicate a predicate for matching controller types
+	 * @since 5.1
+	 */
+	public PathMatchConfigurer addPathPrefix(String prefix, HandlerTypePredicate predicate) {
+		this.pathPrefixes = this.pathPrefixes == null ? new LinkedHashMap<>() : this.pathPrefixes;
+		this.pathPrefixes.put(prefix, predicate);
+		return this;
+	}
+
 	@Nullable
 	protected Boolean isUseTrailingSlashMatch() {
 		return this.trailingSlashMatch;
@@ -65,4 +88,8 @@ public class PathMatchConfigurer {
 		return this.caseSensitiveMatch;
 	}
 
+	@Nullable
+	protected Map<String, HandlerTypePredicate> getPathPrefixes() {
+		return this.pathPrefixes;
+	}
 }

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

@@ -44,6 +44,7 @@ import org.springframework.validation.Validator;
 import org.springframework.web.bind.WebDataBinder;
 import org.springframework.web.bind.support.ConfigurableWebBindingInitializer;
 import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.method.HandlerTypePredicate;
 import org.springframework.web.reactive.DispatcherHandler;
 import org.springframework.web.reactive.HandlerMapping;
 import org.springframework.web.reactive.accept.RequestedContentTypeResolver;
@@ -119,14 +120,22 @@ public class WebFluxConfigurationSupport implements ApplicationContextAware {
 		mapping.setCorsConfigurations(getCorsConfigurations());
 
 		PathMatchConfigurer configurer = getPathMatchConfigurer();
+
 		Boolean useTrailingSlashMatch = configurer.isUseTrailingSlashMatch();
-		Boolean useCaseSensitiveMatch = configurer.isUseCaseSensitiveMatch();
 		if (useTrailingSlashMatch != null) {
 			mapping.setUseTrailingSlashMatch(useTrailingSlashMatch);
 		}
+
+		Boolean useCaseSensitiveMatch = configurer.isUseCaseSensitiveMatch();
 		if (useCaseSensitiveMatch != null) {
 			mapping.setUseCaseSensitiveMatch(useCaseSensitiveMatch);
 		}
+
+		Map<String, HandlerTypePredicate> pathPrefixes = configurer.getPathPrefixes();
+		if (pathPrefixes != null) {
+			mapping.setPathPrefixes(pathPrefixes);
+		}
+
 		return mapping;
 	}
 

spring-webflux/src/main/java/org/springframework/web/reactive/result/method/annotation/RequestMappingHandlerMapping.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2017 the original author or authors.
+ * Copyright 2002-2018 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.
@@ -18,6 +18,9 @@ package org.springframework.web.reactive.result.method.annotation;
 
 import java.lang.reflect.AnnotatedElement;
 import java.lang.reflect.Method;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
 
 import org.springframework.context.EmbeddedValueResolverAware;
 import org.springframework.core.annotation.AnnotatedElementUtils;
@@ -25,11 +28,13 @@ import org.springframework.lang.Nullable;
 import org.springframework.stereotype.Controller;
 import org.springframework.util.Assert;
 import org.springframework.util.CollectionUtils;
+import org.springframework.util.StringUtils;
 import org.springframework.util.StringValueResolver;
 import org.springframework.web.bind.annotation.CrossOrigin;
 import org.springframework.web.bind.annotation.RequestMapping;
 import org.springframework.web.bind.annotation.RequestMethod;
 import org.springframework.web.cors.CorsConfiguration;
+import org.springframework.web.method.HandlerTypePredicate;
 import org.springframework.web.method.HandlerMethod;
 import org.springframework.web.reactive.accept.RequestedContentTypeResolver;
 import org.springframework.web.reactive.accept.RequestedContentTypeResolverBuilder;
@@ -48,6 +53,8 @@ import org.springframework.web.reactive.result.method.RequestMappingInfoHandlerM
 public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMapping
 		implements EmbeddedValueResolverAware {
 
+	private final Map<String, HandlerTypePredicate> pathPrefixes = new LinkedHashMap<>();
+
 	private RequestedContentTypeResolver contentTypeResolver = new RequestedContentTypeResolverBuilder().build();
 
 	@Nullable
@@ -56,6 +63,22 @@ public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMappi
 	private RequestMappingInfo.BuilderConfiguration config = new RequestMappingInfo.BuilderConfiguration();
 
 
+	/**
+	 * Configure path prefixes to apply to controller methods.
+	 * <p>Prefixes are used to enrich the mappings of every {@code @RequestMapping}
+	 * method whose controller type is matched by the corresponding
+	 * {@link HandlerTypePredicate} in the map. The prefix for the first matching
+	 * predicate is used, assuming the input map has predictable order.
+	 * @param prefixes a map with path prefixes as key
+	 * @since 5.1
+	 */
+	public void setPathPrefixes(Map<String, HandlerTypePredicate> prefixes) {
+		this.pathPrefixes.clear();
+		prefixes.entrySet().stream()
+				.filter(entry -> StringUtils.hasText(entry.getKey()))
+				.forEach(entry -> this.pathPrefixes.put(entry.getKey(), entry.getValue()));
+	}
+
 	/**
 	 * Set the {@link RequestedContentTypeResolver} to use to determine requested media types.
 	 * If not set, the default constructor is used.
@@ -80,6 +103,14 @@ public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMappi
 	}
 
 
+	/**
+	 * The configured path prefixes as a read-only, possibly empty map.
+	 * @since 5.1
+	 */
+	public Map<String, HandlerTypePredicate> getPathPrefixes() {
+		return Collections.unmodifiableMap(this.pathPrefixes);
+	}
+
 	/**
 	 * Return the configured {@link RequestedContentTypeResolver}.
 	 */
@@ -113,6 +144,16 @@ public class RequestMappingHandlerMapping extends RequestMappingInfoHandlerMappi
 			if (typeInfo != null) {
 				info = typeInfo.combine(info);
 			}
+			for (Map.Entry<String, HandlerTypePredicate> entry : this.pathPrefixes.entrySet()) {
+				if (entry.getValue().test(handlerType)) {
+					String prefix = entry.getKey();
+					if (this.embeddedValueResolver != null) {
+						prefix = this.embeddedValueResolver.resolveStringValue(prefix);
+					}
+					info = RequestMappingInfo.paths(prefix).build().combine(info);
+					break;
+				}
+			}
 		}
 		return info;
 	}