Use ParameterizedTypeReference instead of Class in Kotlin extensions

This commit also removes WebFlux non-extension functions in favor of
regular Kotlin extensions leveraging ParameterizedTypeReference parameter.

Issue: SPR-15818

Author: sdeleuze

spring-web/src/main/kotlin/org/springframework/web/client/RestOperationsExtensions.kt

@@ -16,6 +16,7 @@
 
 package org.springframework.web.client
 
+import org.springframework.core.ParameterizedTypeReference
 import org.springframework.http.HttpEntity
 import org.springframework.http.HttpMethod
 import org.springframework.http.RequestEntity
@@ -142,7 +143,7 @@ inline fun <reified T: Any> RestOperations.postForEntity(url: URI, request: Any)
  */
 @Throws(RestClientException::class)
 inline fun <reified T: Any> RestOperations.exchange(url: String, method: HttpMethod, requestEntity: HttpEntity<*>, vararg uriVariables: Any): ResponseEntity<T> =
-		exchange(url, method, requestEntity, T::class.java, *uriVariables)
+		exchange(url, method, requestEntity, object : ParameterizedTypeReference<T>() {}, *uriVariables)
 
 /**
  * Extension for [RestOperations.exchange] avoiding specifying the type parameter thanks to Kotlin reified type parameters.
@@ -153,7 +154,7 @@ inline fun <reified T: Any> RestOperations.exchange(url: String, method: HttpMet
  */
 @Throws(RestClientException::class)
 inline fun <reified T: Any> RestOperations.exchange(url: String, method: HttpMethod, requestEntity: HttpEntity<*>, uriVariables: Map<String, *>): ResponseEntity<T> =
-		exchange(url, method, requestEntity, T::class.java, uriVariables)
+		exchange(url, method, requestEntity, object : ParameterizedTypeReference<T>() {}, uriVariables)
 
 /**
  * Extension for [RestOperations.exchange] avoiding specifying the type parameter thanks to Kotlin reified type parameters.
@@ -164,7 +165,7 @@ inline fun <reified T: Any> RestOperations.exchange(url: String, method: HttpMet
  */
 @Throws(RestClientException::class)
 inline fun <reified T: Any> RestOperations.exchange(url: URI, method: HttpMethod, requestEntity: HttpEntity<*>): ResponseEntity<T> =
-		exchange(url, method, requestEntity, T::class.java)
+		exchange(url, method, requestEntity, object : ParameterizedTypeReference<T>() {})
 
 /**
  * Extension for [RestOperations.exchange] avoiding specifying the type parameter thanks to Kotlin reified type parameters.
@@ -175,4 +176,4 @@ inline fun <reified T: Any> RestOperations.exchange(url: URI, method: HttpMethod
  */
 @Throws(RestClientException::class)
 inline fun <reified T: Any> RestOperations.exchange(requestEntity: RequestEntity<*>): ResponseEntity<T> =
-		exchange(requestEntity, T::class.java)
+		exchange(requestEntity, object : ParameterizedTypeReference<T>() {})

spring-web/src/test/kotlin/org/springframework/web/client/RestOperationsExtensionsTests.kt

@@ -23,6 +23,7 @@ import org.mockito.Answers
 import org.mockito.Mock
 import org.mockito.Mockito.*
 import org.mockito.junit.MockitoJUnitRunner
+import org.springframework.core.ParameterizedTypeReference
 import org.springframework.http.HttpEntity
 import org.springframework.http.HttpMethod
 import org.springframework.http.RequestEntity
@@ -133,8 +134,8 @@ class RestOperationsExtensionsTests {
 		val entity = mock<HttpEntity<Foo>>()
 		val var1 = "var1"
 		val var2 = "var2"
-		template.exchange<Foo>(url, method, entity, var1, var2)
-		verify(template, times(1)).exchange(url, method, entity, Foo::class.java, var1, var2)
+		template.exchange<List<Foo>>(url, method, entity, var1, var2)
+		verify(template, times(1)).exchange(url, method, entity, object : ParameterizedTypeReference<List<Foo>>() {}, var1, var2)
 	}
 
 	@Test
@@ -143,24 +144,24 @@ class RestOperationsExtensionsTests {
 		val method = HttpMethod.GET
 		val entity = mock<HttpEntity<Foo>>()
 		val vars = mapOf(Pair("key1", "value1"), Pair("key2", "value2"))
-		template.exchange<Foo>(url, method, entity, vars)
-		verify(template, times(1)).exchange(url, method, entity, Foo::class.java, vars)
+		template.exchange<List<Foo>>(url, method, entity, vars)
+		verify(template, times(1)).exchange(url, method, entity, object : ParameterizedTypeReference<List<Foo>>() {}, vars)
 	}
 
 	@Test
 	fun `exchange with reified type parameters, String, HttpMethod, HttpEntity`() {
 		val url = "https://spring.io"
 		val method = HttpMethod.GET
 		val entity = mock<HttpEntity<Foo>>()
-		template.exchange<Foo>(url, method, entity)
-		verify(template, times(1)).exchange(url, method, entity, Foo::class.java)
+		template.exchange<List<Foo>>(url, method, entity)
+		verify(template, times(1)).exchange(url, method, entity, object : ParameterizedTypeReference<List<Foo>>() {})
 	}
 
 	@Test
 	fun `exchange with reified type parameters, String, HttpEntity`() {
 		val entity = mock<RequestEntity<Foo>>()
-		template.exchange<Foo>(entity)
-		verify(template, times(1)).exchange(entity, Foo::class.java)
+		template.exchange<List<Foo>>(entity)
+		verify(template, times(1)).exchange(entity, object : ParameterizedTypeReference<List<Foo>>() {})
 	}
 
 	class Foo

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

@@ -294,6 +294,12 @@ public RequestHeadersSpec<?> body(BodyInserter<?, ? super ClientHttpRequest> ins
 			return this;
 		}
 
+		@Override
+		public <T, P extends Publisher<T>> RequestHeadersSpec<?> body(P publisher, ParameterizedTypeReference<T> typeReference) {
+			this.inserter = BodyInserters.fromPublisher(publisher, typeReference);
+			return this;
+		}
+
 		@Override
 		public <T, P extends Publisher<T>> RequestHeadersSpec<?> body(P publisher, Class<T> elementClass) {
 			this.inserter = BodyInserters.fromPublisher(publisher, elementClass);

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

@@ -518,6 +518,19 @@ interface RequestBodySpec extends RequestHeadersSpec<RequestBodySpec> {
 		 */
 		RequestHeadersSpec<?> body(BodyInserter<?, ? super ClientHttpRequest> inserter);
 
+		/**
+		 * Set the body of the request to the given asynchronous {@code Publisher}.
+		 * <p>This method is a convenient shortcut for {@link #body(BodyInserter)} with a
+		 * {@linkplain org.springframework.web.reactive.function.BodyInserters#fromPublisher}
+		 * Publisher body inserter}.
+		 * @param publisher the {@code Publisher} to write to the request
+		 * @param typeReference the type reference of elements contained in the publisher
+		 * @param <T> the type of the elements contained in the publisher
+		 * @param <P> the type of the {@code Publisher}
+		 * @return this builder
+		 */
+		<T, P extends Publisher<T>> RequestHeadersSpec<?> body(P publisher, ParameterizedTypeReference<T> typeReference);
+
 		/**
 		 * Set the body of the request to the given asynchronous {@code Publisher}.
 		 * <p>This method is a convenient shortcut for {@link #body(BodyInserter)} with a

spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/BodyExtractorsExtensions.kt

@@ -16,39 +16,48 @@
 
 package org.springframework.web.reactive.function.client
 
+import org.springframework.core.ParameterizedTypeReference
 import org.springframework.http.ResponseEntity
 import reactor.core.publisher.Flux
 import reactor.core.publisher.Mono
 
 
 /**
- * Extension for [ClientResponse.bodyToMono] providing a `bodyToMono<Foo>()` variant.
+ * Extension for [ClientResponse.bodyToMono] providing a `bodyToMono<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ClientResponse.bodyToMono(): Mono<T> = bodyToMono(T::class.java)
+inline fun <reified T : Any> ClientResponse.bodyToMono(): Mono<T> =
+		bodyToMono(object : ParameterizedTypeReference<T>() {})
 
 /**
- * Extension for [ClientResponse.bodyToFlux] providing a `bodyToFlux<Foo>()` variant.
+ * Extension for [ClientResponse.bodyToFlux] providing a `bodyToFlux<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ClientResponse.bodyToFlux(): Flux<T> = bodyToFlux(T::class.java)
+inline fun <reified T : Any> ClientResponse.bodyToFlux(): Flux<T> =
+		bodyToFlux(object : ParameterizedTypeReference<T>() {})
 
 /**
- * Extension for [ClientResponse.toEntity] providing a `toEntity<Foo>()` variant.
+ * Extension for [ClientResponse.toEntity] providing a `toEntity<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ClientResponse.toEntity(): Mono<ResponseEntity<T>> = toEntity(T::class.java)
+inline fun <reified T : Any> ClientResponse.toEntity(): Mono<ResponseEntity<T>> =
+		toEntity(object : ParameterizedTypeReference<T>() {})
 
 /**
- * Extension for [ClientResponse.toEntityList] providing a `bodyToEntityList<Foo>()` variant.
+ * Extension for [ClientResponse.toEntityList] providing a `bodyToEntityList<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ClientResponse.toEntityList(): Mono<ResponseEntity<List<T>>> = toEntityList(T::class.java)
+inline fun <reified T : Any> ClientResponse.toEntityList(): Mono<ResponseEntity<List<T>>> =
+		toEntityList(object : ParameterizedTypeReference<T>() {})

spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/BodyInsertersExtensions.kt

@@ -17,34 +17,39 @@
 package org.springframework.web.reactive.function.client
 
 import org.reactivestreams.Publisher
+import org.springframework.core.ParameterizedTypeReference
 import reactor.core.publisher.Flux
 import reactor.core.publisher.Mono
 
 
 /**
- * Extension for [WebClient.RequestBodySpec.body] providing a variant without explicit class
- * parameter thanks to Kotlin reified type parameters.
+ * Extension for [WebClient.RequestBodySpec.body] providing a `body<Foo>() variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
 @Suppress("EXTENSION_SHADOWED_BY_MEMBER")
-inline fun <reified T : Any, S : Publisher<T>> WebClient.RequestBodySpec.body(publisher: S): WebClient.RequestHeadersSpec<*>
-        = body(publisher, T::class.java)
+inline fun <reified T : Any, S : Publisher<T>> WebClient.RequestBodySpec.body(publisher: S): WebClient.RequestHeadersSpec<*> =
+		body(publisher, object : ParameterizedTypeReference<T>() {})
 
 /**
- * Extension for [WebClient.ResponseSpec.bodyToMono] providing a `bodyToMono<Foo>()` variant.
+ * Extension for [WebClient.ResponseSpec.bodyToMono] providing a `bodyToMono<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> WebClient.ResponseSpec.bodyToMono(): Mono<T> = bodyToMono(T::class.java)
+inline fun <reified T : Any> WebClient.ResponseSpec.bodyToMono(): Mono<T> =
+		bodyToMono(object : ParameterizedTypeReference<T>() {})
 
 
 /**
- * Extension for [WebClient.ResponseSpec.bodyToFlux] providing a `bodyToFlux<Foo>()` variant.
+ * Extension for [WebClient.ResponseSpec.bodyToFlux] providing a `bodyToFlux<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> WebClient.ResponseSpec.bodyToFlux(): Flux<T> = bodyToFlux(T::class.java)
+inline fun <reified T : Any> WebClient.ResponseSpec.bodyToFlux(): Flux<T> =
+		bodyToFlux(object : ParameterizedTypeReference<T>() {})

spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/client/ClientResponseExtensions.kt

@@ -16,22 +16,27 @@
 
 package org.springframework.web.reactive.function.server
 
+import org.springframework.core.ParameterizedTypeReference
 import reactor.core.publisher.Flux
 import reactor.core.publisher.Mono
 
 
 /**
- * Extension for [ServerRequest.bodyToMono] providing a `bodyToMono<Foo>()` variant.
- *
+ * Extension for [ServerRequest.bodyToMono] providing a `bodyToMono<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
+ * 
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ServerRequest.bodyToMono(): Mono<T> = bodyToMono(T::class.java)
+inline fun <reified T : Any> ServerRequest.bodyToMono(): Mono<T> =
+		bodyToMono(object : ParameterizedTypeReference<T>() {})
 
 /**
- * Extension for [ServerRequest.bodyToFlux] providing a `bodyToFlux<Foo>()` variant.
+ * Extension for [ServerRequest.bodyToFlux] providing a `bodyToFlux<Foo>()` variant
+ * leveraging Kotlin reified type parameters.
  *
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ServerRequest.bodyToFlux(): Flux<T> = bodyToFlux(T::class.java)
+inline fun <reified T : Any> ServerRequest.bodyToFlux(): Flux<T> =
+		bodyToFlux(object : ParameterizedTypeReference<T>() {})

spring-webflux/src/main/kotlin/org/springframework/web/reactive/function/client/WebClientExtensions.kt

@@ -17,6 +17,8 @@
 package org.springframework.web.reactive.function.server
 
 import org.reactivestreams.Publisher
+import org.springframework.core.ParameterizedTypeReference
+import org.springframework.http.MediaType
 import reactor.core.publisher.Mono
 
 /**
@@ -25,4 +27,14 @@ import reactor.core.publisher.Mono
  * @author Sebastien Deleuze
  * @since 5.0
  */
-inline fun <reified T : Any> ServerResponse.BodyBuilder.body(publisher: Publisher<T>): Mono<ServerResponse> = body(publisher, T::class.java)
+inline fun <reified T : Any> ServerResponse.BodyBuilder.body(publisher: Publisher<T>): Mono<ServerResponse> =
+		body(publisher, object : ParameterizedTypeReference<T>() {})
+
+/**
+ * Extension for [ServerResponse.BodyBuilder.body] providing a `bodyToServerSentEvents(Publisher<T>)` variant.
+ *
+ * @author Sebastien Deleuze
+ * @since 5.0
+ */
+inline fun <reified T : Any> ServerResponse.BodyBuilder.bodyToServerSentEvents(publisher: Publisher<T>): Mono<ServerResponse> =
+		contentType(MediaType.TEXT_EVENT_STREAM).body(publisher, object : ParameterizedTypeReference<T>() {})