Add ParameterizedTypeReference variants to bodyTo[Mono|Flux], toEntity[List]

This commit introduces overloaded variants of `bodytoMono`,
`bodyToFlux`, `toEntity`, and `toEntityList` that take a
`ParameterizedTypeReference`. It also adds similar methods to
`WebClient.ResponseSpec`.

Issue: SPR-15725

Author: poutsma

spring-webflux/src/main/java/org/springframework/web/reactive/function/client/ClientResponse.java

@@ -23,6 +23,7 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -75,6 +76,14 @@ public interface ClientResponse {
 	 */
 	<T> Mono<T> bodyToMono(Class<? extends T> elementClass);
 
+	/**
+	 * Extract the body to a {@code Mono}.
+	 * @param typeReference a type reference describing the expected response body type
+	 * @param <T> the element type
+	 * @return a mono containing the body of the given type {@code T}
+	 */
+	<T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference);
+
 	/**
 	 * Extract the body to a {@code Flux}.
 	 * @param elementClass the class of element in the {@code Flux}
@@ -83,6 +92,14 @@ public interface ClientResponse {
 	 */
 	<T> Flux<T> bodyToFlux(Class<? extends T> elementClass);
 
+	/**
+	 * Extract the body to a {@code Flux}.
+	 * @param typeReference a type reference describing the expected response body type
+	 * @param <T> the element type
+	 * @return a flux containing the body of the given type {@code T}
+	 */
+	<T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference);
+
 	/**
 	 * Return this response as a delayed {@code ResponseEntity}.
 	 * @param bodyType the expected response body type
@@ -91,6 +108,14 @@ public interface ClientResponse {
 	 */
 	<T> Mono<ResponseEntity<T>> toEntity(Class<T> bodyType);
 
+	/**
+	 * Return this response as a delayed {@code ResponseEntity}.
+	 * @param typeReference a type reference describing the expected response body type
+	 * @param <T> response body type
+	 * @return {@code Mono} with the {@code ResponseEntity}
+	 */
+	<T> Mono<ResponseEntity<T>> toEntity(ParameterizedTypeReference<T> typeReference);
+
 	/**
 	 * Return this response as a delayed list of {@code ResponseEntity}s.
 	 * @param elementType the expected response body list element type
@@ -99,6 +124,14 @@ public interface ClientResponse {
 	 */
 	<T> Mono<ResponseEntity<List<T>>> toEntityList(Class<T> elementType);
 
+	/**
+	 * Return this response as a delayed list of {@code ResponseEntity}s.
+	 * @param typeReference a type reference describing the expected response body type
+	 * @param <T> the type of elements in the list
+	 * @return {@code Mono} with the list of {@code ResponseEntity}s
+	 */
+	<T> Mono<ResponseEntity<List<T>>> toEntityList(ParameterizedTypeReference<T> typeReference);
+
 
 	/**
 	 * Represents the headers of the HTTP response.

spring-webflux/src/main/java/org/springframework/web/reactive/function/client/DefaultClientResponse.java

@@ -25,6 +25,7 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpStatus;
 import org.springframework.http.MediaType;
@@ -99,26 +100,55 @@ public <T> Mono<T> bodyToMono(Class<? extends T> elementClass) {
 		return body(BodyExtractors.toMono(elementClass));
 	}
 
+	@Override
+	public <T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference) {
+		return body(BodyExtractors.toMono(typeReference));
+	}
+
 	@Override
 	public <T> Flux<T> bodyToFlux(Class<? extends T> elementClass) {
 		return body(BodyExtractors.toFlux(elementClass));
 	}
 
+	@Override
+	public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference) {
+		return body(BodyExtractors.toFlux(typeReference));
+	}
+
 	@Override
 	public <T> Mono<ResponseEntity<T>> toEntity(Class<T> bodyType) {
+		return toEntityInternal(bodyToMono(bodyType));
+	}
+
+	@Override
+	public <T> Mono<ResponseEntity<T>> toEntity(ParameterizedTypeReference<T> typeReference) {
+		return toEntityInternal(bodyToMono(typeReference));
+	}
+
+	private <T> Mono<ResponseEntity<T>> toEntityInternal(Mono<T> bodyMono) {
 		HttpHeaders headers = headers().asHttpHeaders();
 		HttpStatus statusCode = statusCode();
-		return bodyToMono(bodyType)
+		return bodyMono
 				.map(body -> new ResponseEntity<>(body, headers, statusCode))
 				.switchIfEmpty(Mono.defer(
 						() -> Mono.just(new ResponseEntity<>(headers, statusCode))));
 	}
 
 	@Override
 	public <T> Mono<ResponseEntity<List<T>>> toEntityList(Class<T> responseType) {
+		return toEntityListInternal(bodyToFlux(responseType));
+	}
+
+	@Override
+	public <T> Mono<ResponseEntity<List<T>>> toEntityList(
+			ParameterizedTypeReference<T> typeReference) {
+		return toEntityListInternal(bodyToFlux(typeReference));
+	}
+
+	private <T> Mono<ResponseEntity<List<T>>> toEntityListInternal(Flux<T> bodyFlux) {
 		HttpHeaders headers = headers().asHttpHeaders();
 		HttpStatus statusCode = statusCode();
-		return bodyToFlux(responseType)
+		return bodyFlux
 				.collectList()
 				.map(body -> new ResponseEntity<>(body, headers, statusCode));
 	}

spring-webflux/src/main/java/org/springframework/web/reactive/function/client/DefaultWebClient.java

@@ -35,6 +35,7 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
@@ -422,13 +423,27 @@ public <T> Mono<T> bodyToMono(Class<T> bodyType) {
 							Mono::error));
 		}
 
+		@Override
+		public <T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference) {
+			return this.responseMono.flatMap(
+					response -> bodyToPublisher(response, BodyExtractors.toMono(typeReference),
+							Mono::error));
+		}
+
 		@Override
 		public <T> Flux<T> bodyToFlux(Class<T> elementType) {
 			return this.responseMono.flatMapMany(
 					response -> bodyToPublisher(response, BodyExtractors.toFlux(elementType),
 							Flux::error));
 		}
 
+		@Override
+		public <T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference) {
+			return this.responseMono.flatMapMany(
+					response -> bodyToPublisher(response, BodyExtractors.toFlux(typeReference),
+							Flux::error));
+		}
+
 		private <T extends Publisher<?>> T bodyToPublisher(ClientResponse response,
 				BodyExtractor<T, ? super ClientHttpResponse> extractor,
 				Function<Throwable, T> errorFunction) {

spring-webflux/src/main/java/org/springframework/web/reactive/function/client/WebClient.java

@@ -29,6 +29,7 @@
 import reactor.core.publisher.Flux;
 import reactor.core.publisher.Mono;
 
+import org.springframework.core.ParameterizedTypeReference;
 import org.springframework.http.HttpHeaders;
 import org.springframework.http.HttpMethod;
 import org.springframework.http.HttpStatus;
@@ -559,8 +560,9 @@ ResponseSpec onStatus(Predicate<HttpStatus> statusPredicate,
 				Function<ClientResponse, ? extends Throwable> exceptionFunction);
 
 		/**
-		 * Extract the body to a {@code Mono}. If the response has status code 4xx or 5xx, the
-		 * {@code Mono} will contain a {@link WebClientException}.
+		 * Extract the body to a {@code Mono}. By default, if the response has status code 4xx or
+		 * 5xx, the {@code Mono} will contain a {@link WebClientException}. This can be overridden
+		 * with {@link #onStatus(Predicate, Function)}.
 		 * @param bodyType the expected response body type
 		 * @param <T> response body type
 		 * @return a mono containing the body, or a {@link WebClientException} if the status code is
@@ -569,15 +571,38 @@ ResponseSpec onStatus(Predicate<HttpStatus> statusPredicate,
 		<T> Mono<T> bodyToMono(Class<T> bodyType);
 
 		/**
-		 * Extract the body to a {@code Flux}. If the response has status code 4xx or 5xx, the
-		 * {@code Flux} will contain a {@link WebClientException}.
+		 * Extract the body to a {@code Mono}. By default, if the response has status code 4xx or
+		 * 5xx, the {@code Mono} will contain a {@link WebClientException}. This can be overridden
+		 * with {@link #onStatus(Predicate, Function)}.
+		 * @param typeReference a type reference describing the expected response body type
+		 * @param <T> response body type
+		 * @return a mono containing the body, or a {@link WebClientException} if the status code is
+		 * 4xx or 5xx
+		 */
+		<T> Mono<T> bodyToMono(ParameterizedTypeReference<T> typeReference);
+
+		/**
+		 * Extract the body to a {@code Flux}. By default, if the response has status code 4xx or
+		 * 5xx, the {@code Flux} will contain a {@link WebClientException}. This can be overridden
+         * with {@link #onStatus(Predicate, Function)}.
 		 * @param elementType the type of element in the response
 		 * @param <T> the type of elements in the response
 		 * @return a flux containing the body, or a {@link WebClientException} if the status code is
 		 * 4xx or 5xx
 		 */
 		<T> Flux<T> bodyToFlux(Class<T> elementType);
 
+		/**
+		 * Extract the body to a {@code Flux}. By default, if the response has status code 4xx or
+		 * 5xx, the {@code Flux} will contain a {@link WebClientException}. This can be overridden
+         * with {@link #onStatus(Predicate, Function)}.
+		 * @param typeReference a type reference describing the expected response body type
+		 * @param <T> the type of elements in the response
+		 * @return a flux containing the body, or a {@link WebClientException} if the status code is
+		 * 4xx or 5xx
+		 */
+		<T> Flux<T> bodyToFlux(ParameterizedTypeReference<T> typeReference);
+
 	}