new method usePathSegment(int index, Predicate<RequestPath> excludePath) in ApiVersionConfigurer to exclude certain paths Signed-off-by: Martin Mois <martin.mois@gmail.com>

Signed-off-by: Martin Mois <martin.mois@gmail.com>

Author: siom79

.idea/icon.svg

@@ -16,11 +16,15 @@
 
 package org.springframework.web.reactive.accept;
 
+import org.jspecify.annotations.Nullable;
 import org.springframework.http.server.PathContainer;
+import org.springframework.http.server.RequestPath;
 import org.springframework.util.Assert;
 import org.springframework.web.accept.InvalidApiVersionException;
 import org.springframework.web.server.ServerWebExchange;
 
+import java.util.function.Predicate;
+
 /**
  * {@link ApiVersionResolver} that extract the version from a path segment.
  *
@@ -30,11 +34,13 @@
  * cannot yield to other resolvers.
  *
  * @author Rossen Stoyanchev
+ * @author Martin Mois
  * @since 7.0
  */
 public class PathApiVersionResolver implements ApiVersionResolver {
 
 	private final int pathSegmentIndex;
+	private @Nullable Predicate<RequestPath> excludePath = null;
 
 
 	/**
@@ -47,11 +53,25 @@ public PathApiVersionResolver(int pathSegmentIndex) {
 		this.pathSegmentIndex = pathSegmentIndex;
 	}
 
+	/**
+	 * Create a resolver instance.
+	 * @param pathSegmentIndex the index of the path segment that contains the API version
+	 * @param excludePath a {@link Predicate} that tests if the given path should be excluded
+	 */
+	public PathApiVersionResolver(int pathSegmentIndex, Predicate<RequestPath> excludePath) {
+		this(pathSegmentIndex);
+		this.excludePath = excludePath;
+	}
+
 
 	@Override
-	public String resolveVersion(ServerWebExchange exchange) {
+	public @Nullable String resolveVersion(ServerWebExchange exchange) {
 		int i = 0;
-		for (PathContainer.Element e : exchange.getRequest().getPath().pathWithinApplication().elements()) {
+		RequestPath path = exchange.getRequest().getPath();
+		if (this.excludePath != null && this.excludePath.test(path)) {
+			return null;
+		}
+		for (PathContainer.Element e : path.pathWithinApplication().elements()) {
 			if (e instanceof PathContainer.PathSegment && i++ == this.pathSegmentIndex) {
 				return e.value();
 			}

spring-webflux/src/main/java/org/springframework/web/reactive/accept/PathApiVersionResolver.java

@@ -27,6 +27,7 @@
 import org.jspecify.annotations.Nullable;
 
 import org.springframework.http.MediaType;
+import org.springframework.http.server.RequestPath;
 import org.springframework.util.Assert;
 import org.springframework.web.accept.ApiVersionParser;
 import org.springframework.web.accept.InvalidApiVersionException;
@@ -108,6 +109,20 @@ public ApiVersionConfigurer usePathSegment(int index) {
 		return this;
 	}
 
+	/**
+	 * Add a resolver that extracts the API version from a path segment
+	 * and that allows to exclude certain paths based on the provided {@link Predicate}.
+	 * <p>Note that this resolver never returns {@code null}, and therefore
+	 * cannot yield to other resolvers, see {@link org.springframework.web.accept.PathApiVersionResolver}.
+	 * @param index the index of the path segment to check; e.g. for URL's like
+	 * {@code "/{version}/..."} use index 0, for {@code "/api/{version}/..."} index 1.
+	 * @param excludePath a {@link Predicate} that allows to exclude certain paths
+	 */
+	public ApiVersionConfigurer usePathSegment(int index, Predicate<RequestPath> excludePath) {
+		this.versionResolvers.add(new PathApiVersionResolver(index, excludePath));
+		return this;
+	}
+
 	/**
 	 * Add custom resolvers to resolve the API version.
 	 * @param resolvers the resolvers to use

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

@@ -18,17 +18,21 @@
 
 import org.junit.jupiter.api.Test;
 
+import org.springframework.http.server.PathContainer;
 import org.springframework.web.accept.InvalidApiVersionException;
 import org.springframework.web.server.ServerWebExchange;
 import org.springframework.web.testfixture.http.server.reactive.MockServerHttpRequest;
 import org.springframework.web.testfixture.server.MockServerWebExchange;
 
+import java.util.List;
+
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.assertj.core.api.Assertions.assertThatThrownBy;
 
 /**
  * Unit tests for {@link org.springframework.web.accept.PathApiVersionResolver}.
  * @author Rossen Stoyanchev
+ * @author Martin Mois
  */
 public class PathApiVersionResolverTests {
 
@@ -43,6 +47,39 @@ void insufficientPathSegments() {
 		assertThatThrownBy(() -> testResolve(0, "/", "1.0")).isInstanceOf(InvalidApiVersionException.class);
 	}
 
+	@Test
+	void excludePathTrue() {
+		String requestUri = "/v3/api-docs";
+		testResolveWithExcludePath(requestUri, null);
+	}
+
+	@Test
+	void excludePathFalse() {
+		String requestUri = "/app/1.0/path";
+		testResolveWithExcludePath(requestUri, "1.0");
+	}
+
+	@Test
+	void excludePathFalseShortPath() {
+		String requestUri = "/app";
+		assertThatThrownBy(() -> testResolveWithExcludePath(requestUri, null)).isInstanceOf(InvalidApiVersionException.class);
+	}
+
+	private static void testResolveWithExcludePath(String requestUri, String expected) {
+		ServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get(requestUri));
+		String actual = new PathApiVersionResolver(1, requestPath -> {
+			List<PathContainer.Element> elements = requestPath.elements();
+			if (elements.size() < 4) {
+				return false;
+			}
+			return elements.get(0).value().equals("/") &&
+					elements.get(1).value().equals("v3") &&
+					elements.get(2).value().equals("/") &&
+					elements.get(3).value().equals("api-docs");
+		}).resolveVersion(exchange);
+		assertThat(actual).isEqualTo(expected);
+	}
+
 	private static void testResolve(int index, String requestUri, String expected) {
 		ServerWebExchange exchange = MockServerWebExchange.from(MockServerHttpRequest.get(requestUri));
 		String actual = new PathApiVersionResolver(index).resolveVersion(exchange);