Update generics on WebFlux RouterFunctions.Builder

Consistently allow subtypes of ServerResponse to be returned for any
provided HandlerFunction and HandlerFilterFunction. Both allow use of
subtypes such as EntityServerResponse and RenderingResponse, and
in the end we support any ServerResponse.

Closes gh-35791

Author: rstoyanchev

spring-webflux/src/main/java/org/springframework/web/reactive/function/server/RouterFunctionBuilder.java

@@ -51,191 +51,191 @@ class RouterFunctionBuilder implements RouterFunctions.Builder {
 	private final List<HandlerFilterFunction<ServerResponse, ServerResponse>> errorHandlers = new ArrayList<>();
 
 
+	@SuppressWarnings("unchecked")
 	@Override
-	public RouterFunctions.Builder add(RouterFunction<ServerResponse> routerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder add(RouterFunction<T> routerFunction) {
 		Assert.notNull(routerFunction, "RouterFunction must not be null");
-		this.routerFunctions.add(routerFunction);
+		this.routerFunctions.add((RouterFunction<ServerResponse>) routerFunction);
 		return this;
 	}
 
-	private RouterFunctions.Builder add(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
-		this.routerFunctions.add(RouterFunctions.route(predicate, handlerFunction));
-		return this;
+	private <T extends ServerResponse> RouterFunctions.Builder add(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
+		return add(RouterFunctions.route(predicate, handlerFunction));
 	}
 
 	// GET
 
 	@Override
-	public RouterFunctions.Builder GET(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder GET(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.GET), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder GET(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder GET(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.GET).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder GET(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder GET(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.GET(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder GET(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder GET(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.GET(pattern).and(predicate), handlerFunction);
 	}
 
 	// HEAD
 
 	@Override
-	public RouterFunctions.Builder HEAD(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder HEAD(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.HEAD), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder HEAD(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder HEAD(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.HEAD).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder HEAD(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder HEAD(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.HEAD(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder HEAD(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder HEAD(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.HEAD(pattern).and(predicate), handlerFunction);
 	}
 
 	// POST
 
 	@Override
-	public RouterFunctions.Builder POST(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder POST(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.POST), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder POST(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder POST(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.POST).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder POST(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder POST(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.POST(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder POST(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder POST(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.POST(pattern).and(predicate), handlerFunction);
 	}
 
 	// PUT
 
 	@Override
-	public RouterFunctions.Builder PUT(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PUT(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.PUT), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder PUT(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PUT(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.PUT).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder PUT(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PUT(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.PUT(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder PUT(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PUT(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.PUT(pattern).and(predicate), handlerFunction);
 	}
 
 	// PATCH
 
 	@Override
-	public RouterFunctions.Builder PATCH(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PATCH(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.PATCH), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder PATCH(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PATCH(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.PATCH).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder PATCH(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PATCH(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.PATCH(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder PATCH(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder PATCH(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.PATCH(pattern).and(predicate), handlerFunction);
 	}
 
 	// DELETE
 
 	@Override
-	public RouterFunctions.Builder DELETE(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder DELETE(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.DELETE), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder DELETE(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder DELETE(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.DELETE).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder DELETE(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder DELETE(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.DELETE(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder DELETE(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder DELETE(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.DELETE(pattern).and(predicate), handlerFunction);
 	}
 
 	// OPTIONS
 
 	@Override
-	public RouterFunctions.Builder OPTIONS(HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder OPTIONS(HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.OPTIONS), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder OPTIONS(RequestPredicate predicate, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder OPTIONS(RequestPredicate predicate, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.method(HttpMethod.OPTIONS).and(predicate), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder OPTIONS(String pattern, HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder OPTIONS(String pattern, HandlerFunction<T> handlerFunction) {
 		return add(RequestPredicates.OPTIONS(pattern), handlerFunction);
 	}
 
 	@Override
-	public RouterFunctions.Builder OPTIONS(String pattern, RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder OPTIONS(String pattern, RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 
 		return add(RequestPredicates.OPTIONS(pattern).and(predicate), handlerFunction);
 	}
 
 	// other
 
 	@Override
-	public RouterFunctions.Builder route(RequestPredicate predicate,
-			HandlerFunction<ServerResponse> handlerFunction) {
+	public <T extends ServerResponse> RouterFunctions.Builder route(RequestPredicate predicate,
+			HandlerFunction<T> handlerFunction) {
 		return add(RouterFunctions.route(predicate, handlerFunction));
 	}
 
@@ -287,13 +287,14 @@ public RouterFunctions.Builder nest(RequestPredicate predicate,
 		return this;
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
-	public RouterFunctions.Builder nest(RequestPredicate predicate,
-			Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) {
+	public <T extends ServerResponse> RouterFunctions.Builder nest(RequestPredicate predicate,
+			Supplier<RouterFunction<T>> routerFunctionSupplier) {
 
 		Assert.notNull(routerFunctionSupplier, "RouterFunction Supplier must not be null");
 
-		RouterFunction<ServerResponse> nestedRoute = routerFunctionSupplier.get();
+		RouterFunction<ServerResponse> nestedRoute = (RouterFunction<ServerResponse>) routerFunctionSupplier.get();
 		this.routerFunctions.add(RouterFunctions.nest(predicate, nestedRoute));
 		return this;
 	}
@@ -306,17 +307,20 @@ public RouterFunctions.Builder path(String pattern,
 	}
 
 	@Override
-	public RouterFunctions.Builder path(String pattern,
-			Supplier<RouterFunction<ServerResponse>> routerFunctionSupplier) {
+	public <T extends ServerResponse> RouterFunctions.Builder path(String pattern,
+			Supplier<RouterFunction<T>> routerFunctionSupplier) {
 
 		return nest(RequestPredicates.path(pattern), routerFunctionSupplier);
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
-	public RouterFunctions.Builder filter(HandlerFilterFunction<ServerResponse, ServerResponse> filterFunction) {
+	public <T extends ServerResponse, R extends ServerResponse> RouterFunctions.Builder filter(
+			HandlerFilterFunction<T, R> filterFunction) {
+
 		Assert.notNull(filterFunction, "HandlerFilterFunction must not be null");
 
-		this.filterFunctions.add(filterFunction);
+		this.filterFunctions.add((HandlerFilterFunction<ServerResponse, ServerResponse>) filterFunction);
 		return this;
 	}
 
@@ -326,18 +330,19 @@ public RouterFunctions.Builder before(Function<ServerRequest, ServerRequest> req
 		return filter((request, next) -> next.handle(requestProcessor.apply(request)));
 	}
 
+	@SuppressWarnings("unchecked")
 	@Override
-	public RouterFunctions.Builder after(
-			BiFunction<ServerRequest, ServerResponse, ServerResponse> responseProcessor) {
+	public <T extends ServerResponse, R extends ServerResponse> RouterFunctions.Builder after(
+			BiFunction<ServerRequest, T, R> responseProcessor) {
 
 		Assert.notNull(responseProcessor, "ResponseProcessor must not be null");
 		return filter((request, next) -> next.handle(request)
-				.map(serverResponse -> responseProcessor.apply(request, serverResponse)));
+				.map(serverResponse -> responseProcessor.apply(request, (T) serverResponse)));
 	}
 
 	@Override
-	public RouterFunctions.Builder onError(Predicate<? super Throwable> predicate,
-			BiFunction<? super Throwable, ServerRequest, Mono<ServerResponse>> responseProvider) {
+	public <T extends ServerResponse> RouterFunctions.Builder onError(Predicate<? super Throwable> predicate,
+			BiFunction<? super Throwable, ServerRequest, Mono<T>> responseProvider) {
 
 		Assert.notNull(predicate, "Predicate must not be null");
 		Assert.notNull(responseProvider, "ResponseProvider must not be null");