root
/
spring-framework
mirror of https://github.com/spring-projects/spring-framework.git
1
0
Fork 0
Code Issues Actions 6 Packages Projects Releases Wiki Activity

Add RestTemplate support for HTTP interface client 

See gh-30117
This commit is contained in:
Olga MaciaszekSharma 2023-07-06 19:07:40 +02:00 committed by rstoyanchev
parent bf82ed7186
commit 268f3c853e
21 changed files with 1272 additions and 227 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
framework-docs/modules/ROOT/pages/integration/rest-clients.adoc
View File

@ -382,12 +382,24 @@ One, declare an interface with `@HttpExchange` methods:
}
----
Two, create a proxy that will perform the declared HTTP exchanges:
Two, create a proxy that will perform the declared HTTP exchanges,
either using `WebClient`:
[source,java,indent=0,subs="verbatim,quotes"]
----
WebClient client = WebClient.builder().baseUrl("https://api.github.com/").build();
HttpServiceProxyFactory factory = HttpServiceProxyFactory.builder(WebClientAdapter.forClient(client)).build();
HttpServiceProxyFactory factory = HttpServiceProxyFactory.builder().exchangeAdapter(WebClientAdapter.forClient(webClient)).build();
RepositoryService service = factory.createClient(RepositoryService.class);
----
or using `RestTemplate`:
[source,java,indent=0,subs="verbatim,quotes"]
----
RestTemplate restTemplate = new RestTemplate();
restTemplate.setUriTemplateHandler(new DefaultUriBuilderFactory("https://api.github.com/"));
HttpServiceProxyFactory factory = HttpServiceProxyFactory.builder().exchangeAdapter(RestTemplateAdapter.forTemplate(restTemplate)).build();
RepositoryService service = factory.createClient(RepositoryService.class);
----

136
spring-web/src/main/java/org/springframework/web/client/support/RestTemplateAdapter.java Normal file
View File

@ -0,0 +1,136 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.client.support;
import java.net.URI;
import java.util.List;
import java.util.stream.Collectors;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpCookie;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.RequestEntity;
import org.springframework.http.ResponseEntity;
import org.springframework.util.Assert;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.service.invoker.HttpExchangeAdapter;
import org.springframework.web.service.invoker.HttpRequestValues;
import org.springframework.web.service.invoker.HttpServiceProxyFactory;
/**
* An {@link HttpExchangeAdapter} that enables an {@link HttpServiceProxyFactory} to use
* {@link RestTemplate} for request execution.
* <p>
* Use static factory methods in this class to create an {@link HttpServiceProxyFactory}
* configured with a given {@link RestTemplate}.
*
* @author Olga Maciaszek-Sharma
* @since 6.1
*/
public final class RestTemplateAdapter implements HttpExchangeAdapter {
private final RestTemplate restTemplate;
// Private constructor; use static factory methods to instantiate
private RestTemplateAdapter(RestTemplate restTemplate) {
this.restTemplate = restTemplate;
}
@Override
public Void exchange(HttpRequestValues requestValues) {
this.restTemplate.exchange(newRequest(requestValues), Void.class);
return null;
}
@Override
public HttpHeaders exchangeForHeaders(HttpRequestValues requestValues) {
return this.restTemplate.exchange(newRequest(requestValues), Void.class).getHeaders();
}
@Override
public <T> T exchangeForBody(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
return this.restTemplate.exchange(newRequest(requestValues), bodyType).getBody();
}
@Override
public ResponseEntity<Void> exchangeForBodilessEntity(HttpRequestValues requestValues) {
return this.restTemplate.exchange(newRequest(requestValues), Void.class);
}
@Override
public <T> ResponseEntity<T> exchangeForEntity(HttpRequestValues requestValues,
ParameterizedTypeReference<T> bodyType) {
return this.restTemplate.exchange(newRequest(requestValues), bodyType);
}
@Override
public boolean supportsRequestAttributes() {
return false;
}
private RequestEntity<?> newRequest(HttpRequestValues requestValues) {
URI uri;
if (requestValues.getUri() != null) {
uri = requestValues.getUri();
}
else if (requestValues.getUriTemplate() != null) {
uri = this.restTemplate.getUriTemplateHandler().expand(requestValues.getUriTemplate(),
requestValues.getUriVariables());
}
else {
throw new IllegalStateException("Neither full URL nor URI template");
}
HttpMethod httpMethod = requestValues.getHttpMethod();
Assert.notNull(httpMethod, "HttpMethod is required");
RequestEntity.BodyBuilder builder = RequestEntity.method(httpMethod, uri)
.headers(requestValues.getHeaders());
if (!requestValues.getCookies().isEmpty()) {
MultiValueMap<String, HttpCookie> cookies = new LinkedMultiValueMap<>();
requestValues.getCookies()
.forEach((name, values) -> values.forEach(value ->
cookies.add(name, new HttpCookie(name, value))));
builder.header(HttpHeaders.COOKIE,
cookies.values()
.stream()
.flatMap(List::stream)
.map(HttpCookie::toString)
.collect(Collectors.joining("; ")));
}
if (requestValues.getBodyValue() != null) {
return builder.body(requestValues.getBodyValue());
}
return builder.build();
}
/**
* Create a {@link RestTemplateAdapter} for the given {@link RestTemplate} instance.
* @param restTemplate the {@link RestTemplate} to use
* @return the created adapter instance
*/
public static RestTemplateAdapter forTemplate(RestTemplate restTemplate) {
return new RestTemplateAdapter(restTemplate);
}
}

32
spring-web/src/main/java/org/springframework/web/service/invoker/AbstractReactorHttpExchangeAdapter.java
View File

@ -29,6 +29,10 @@ import org.springframework.lang.Nullable;
import org.springframework.util.Assert;
/**
* A base reactive adapter that implements both {@link HttpClientAdapter}
* and {@link HttpExchangeAdapter}. Allows to ensure backwards compatibility
* with the deprecated {@link HttpClientAdapter} and handles blocking from reactive
* publishers to objects where necessary.
*
* @author Rossen Stoyanchev
* @since 6.1
@ -51,16 +55,16 @@ public abstract class AbstractReactorHttpExchangeAdapter
/**
*
* @param reactiveAdapterRegistry
* Configure the registry for adapting various reactive types.
* <p>By default this is an instance of {@link ReactiveAdapterRegistry} with
* default settings.
*/
public void setReactiveAdapterRegistry(ReactiveAdapterRegistry reactiveAdapterRegistry) {
this.reactiveAdapterRegistry = reactiveAdapterRegistry;
}
/**
*
* @return
* Return the configured reactive type registry of adapters.
*/
@Override
public ReactiveAdapterRegistry getReactiveAdapterRegistry() {
@ -68,31 +72,31 @@ public abstract class AbstractReactorHttpExchangeAdapter
}
/**
*
* @param blockTimeout
* Configure how long to block for the response of an HTTP service method with a
* synchronous (blocking) method signature.
* <p>
* By default, this is not set, in which case the behavior depends on connection and
* request timeout settings of the underlying HTTP client. We recommend configuring
* timeout values directly on the underlying HTTP client, which provides more
* control over such settings.
*/
public void setBlockTimeout(@Nullable Duration blockTimeout) {
this.blockTimeout = blockTimeout;
}
/**
*
* @return
*/
@Override
@Nullable
public Duration getBlockTimeout() {
return this.blockTimeout;
}
@Override
public void exchange(HttpRequestValues requestValues) {
public Void exchange(HttpRequestValues requestValues) {
if (this.blockTimeout != null) {
exchangeForMono(requestValues).block(this.blockTimeout);
return exchangeForMono(requestValues).block(this.blockTimeout);
}
else {
exchangeForMono(requestValues).block();
return exchangeForMono(requestValues).block();
}
}

25
spring-web/src/main/java/org/springframework/web/service/invoker/HttpClientAdapter.java
View File

@ -28,6 +28,7 @@ import org.springframework.http.ResponseEntity;
* {@linkplain HttpServiceProxyFactory#createClient(Class) HTTP service proxy}.
*
* @author Rossen Stoyanchev
* @author Olga Maciaszek-Sharma
* @since 6.0
* @deprecated in favor of {@link ReactorHttpExchangeAdapter}
*/
@ -91,50 +92,58 @@ public interface HttpClientAdapter {
/**
* Adapt this {@link HttpClientAdapter} to {@link ReactorHttpExchangeAdapter}.
* @return
* @return a {@link ReactorHttpExchangeAdapter} instance created that delegating to
* the underlying {@link HttpClientAdapter} implementation
* @since 6.1
*/
default ReactorHttpExchangeAdapter asHttpExchangeAdapter() {
HttpClientAdapter delegate = this;
return new AbstractReactorHttpExchangeAdapter() {
@Override
public Mono<Void> exchangeForMono(HttpRequestValues requestValues) {
return requestToVoid(requestValues);
return delegate.requestToVoid(requestValues);
}
@Override
public Mono<HttpHeaders> exchangeForHeadersMono(HttpRequestValues requestValues) {
return requestToHeaders(requestValues);
return delegate.requestToHeaders(requestValues);
}
@Override
public <T> Mono<T> exchangeForBodyMono(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
return requestToBody(requestValues, bodyType);
return delegate.requestToBody(requestValues, bodyType);
}
@Override
public <T> Flux<T> exchangeForBodyFlux(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
return requestToBodyFlux(requestValues, bodyType);
return delegate.requestToBodyFlux(requestValues, bodyType);
}
@Override
public Mono<ResponseEntity<Void>> exchangeForBodilessEntityMono(HttpRequestValues requestValues) {
return requestToBodilessEntity(requestValues);
return delegate.requestToBodilessEntity(requestValues);
}
@Override
public <T> Mono<ResponseEntity<T>> exchangeForEntityMono(
HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
return requestToEntity(requestValues, bodyType);
return delegate.requestToEntity(requestValues, bodyType);
}
@Override
public <T> Mono<ResponseEntity<Flux<T>>> exchangeForEntityFlux(
HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
return requestToEntityFlux(requestValues, bodyType);
return delegate.requestToEntityFlux(requestValues, bodyType);
}
@Override
public boolean supportsRequestAttributes() {
return true;
}
};
}

9
spring-web/src/main/java/org/springframework/web/service/invoker/HttpExchangeAdapter.java
View File

@ -34,7 +34,7 @@ public interface HttpExchangeAdapter {
* Perform the given request, and release the response content, if any.
* @param requestValues the request to perform
*/
void exchange(HttpRequestValues requestValues);
Void exchange(HttpRequestValues requestValues);
/**
* Perform the given request, release the response content, and return the
@ -48,8 +48,8 @@ public interface HttpExchangeAdapter {
* Perform the given request and decode the response content to the given type.
* @param requestValues the request to perform
* @param bodyType the target type to decode to
* @return the decoded response.
* @param <T> the type the response is decoded to
* @return the decoded response.
*/
@Nullable
<T> T exchangeForBody(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType);
@ -66,4 +66,9 @@ public interface HttpExchangeAdapter {
*/
<T> ResponseEntity<T> exchangeForEntity(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType);
/**
* A flag that indicates whether request attributes are supported by a specific client
* adapter.
*/
boolean supportsRequestAttributes();
}

47
spring-web/src/main/java/org/springframework/web/service/invoker/HttpServiceMethod.java
View File

@ -53,6 +53,7 @@ import org.springframework.web.service.annotation.HttpExchange;
*
* @author Rossen Stoyanchev
* @author Sebastien Deleuze
* @author Olga Maciaszek-Sharma
* @since 6.0
*/
final class HttpServiceMethod {
@ -282,17 +283,57 @@ final class HttpServiceMethod {
}
private record ExchangeResponseFunction(
Function<HttpRequestValues, Object> responseFunction) implements ResponseFunction {
@Override
public Object execute(HttpRequestValues requestValues) {
return null;
return this.responseFunction.apply(requestValues);
}
public static ResponseFunction create(HttpExchangeAdapter client, Method method) {
return new ExchangeResponseFunction(httpRequestValues -> null);
if (KotlinDetector.isSuspendingFunction(method)) {
throw new IllegalStateException("Kotlin Coroutines are only supported with reactive implementations");
}
MethodParameter actualReturnParam = new MethodParameter(method, -1).nestedIfOptional();
boolean returnOptional = actualReturnParam.getParameterType().equals(Optional.class);
Class<?> actualReturnType = actualReturnParam.getNestedParameterType();
Function<HttpRequestValues, Object> responseFunction;
if (actualReturnType.equals(void.class) || actualReturnType.equals(Void.class)) {
responseFunction = client::exchange;
}
else if (actualReturnType.equals(HttpHeaders.class)) {
responseFunction = request -> processResponse(client.exchangeForHeaders(request),
returnOptional);
}
else if (actualReturnType.equals(ResponseEntity.class)) {
MethodParameter bodyParam = actualReturnParam.nested();
Class<?> bodyType = bodyParam.getNestedParameterType();
if (bodyType.equals(Void.class)) {
responseFunction = request -> processResponse(client
.exchangeForBodilessEntity(request), returnOptional);
}
else {
ParameterizedTypeReference<?> bodyTypeReference = ParameterizedTypeReference
.forType(bodyParam.getNestedGenericParameterType());
responseFunction = request -> processResponse(client.exchangeForEntity(request,
bodyTypeReference), returnOptional);
}
}
else {
ParameterizedTypeReference<?> bodyTypeReference = ParameterizedTypeReference
.forType(actualReturnParam.getNestedGenericParameterType());
responseFunction = request -> processResponse(client.exchangeForBody(request,
bodyTypeReference), returnOptional);
}
return new ExchangeResponseFunction(responseFunction);
}
private static @Nullable Object processResponse(@Nullable Object response,
boolean returnOptional) {
return returnOptional ? Optional.ofNullable(response) : response;
}
}

5
spring-web/src/main/java/org/springframework/web/service/invoker/HttpServiceProxyFactory.java
View File

@ -249,6 +249,7 @@ public final class HttpServiceProxyFactory {
this.exchangeAdapter, initArgumentResolvers(), this.embeddedValueResolver);
}
@SuppressWarnings("DataFlowIssue")
private List<HttpServiceArgumentResolver> initArgumentResolvers() {
// Custom
@ -261,10 +262,12 @@ public final class HttpServiceProxyFactory {
resolvers.add(new RequestHeaderArgumentResolver(service));
resolvers.add(new RequestBodyArgumentResolver());
resolvers.add(new PathVariableArgumentResolver(service));
if (this.exchangeAdapter.supportsRequestAttributes()) {
resolvers.add(new RequestAttributeArgumentResolver());
}
resolvers.add(new RequestParamArgumentResolver(service));
resolvers.add(new RequestPartArgumentResolver());
resolvers.add(new CookieValueArgumentResolver(service));
resolvers.add(new RequestAttributeArgumentResolver());
// Specific type
resolvers.add(new UrlArgumentResolver());

15
spring-web/src/main/java/org/springframework/web/service/invoker/ReactorHttpExchangeAdapter.java
View File

@ -25,6 +25,7 @@ import org.springframework.core.ParameterizedTypeReference;
import org.springframework.core.ReactiveAdapterRegistry;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.lang.Nullable;
/**
* Contract to abstract a Project Reactor, HTTP client to decouple it from the
@ -36,17 +37,23 @@ import org.springframework.http.ResponseEntity;
public interface ReactorHttpExchangeAdapter extends HttpExchangeAdapter {
/**
*
* @return
* Return the configured reactive type registry of adapters.
*/
ReactiveAdapterRegistry getReactiveAdapterRegistry();
/**
* Return the configured time to block for the response of an HTTP service method with
* a synchronous (blocking) method signature.
*
* @return
* <p>
* By default, this is not set, in which case the behavior depends on connection and
* request timeout settings of the underlying HTTP client. We recommend configuring
* timeout values directly on the underlying HTTP client, which provides more *
* control over such settings.
*/
@Nullable
Duration getBlockTimeout();
/**
* Perform the given request, and release the response content, if any.
* @param requestValues the request to perform

220
spring-web/src/test/java/org/springframework/web/client/support/RestTemplateHttpServiceProxyTests.java Normal file
View File

@ -0,0 +1,220 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.client.support;
import java.io.IOException;
import java.net.URI;
import java.util.Optional;
import okhttp3.mockwebserver.MockResponse;
import okhttp3.mockwebserver.MockWebServer;
import okhttp3.mockwebserver.RecordedRequest;
import org.junit.jupiter.api.AfterEach;
import org.junit.jupiter.api.BeforeEach;
import org.junit.jupiter.api.Test;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.lang.Nullable;
import org.springframework.util.LinkedMultiValueMap;
import org.springframework.util.MultiValueMap;
import org.springframework.web.bind.annotation.CookieValue;
import org.springframework.web.bind.annotation.PathVariable;
import org.springframework.web.bind.annotation.RequestBody;
import org.springframework.web.bind.annotation.RequestHeader;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RequestPart;
import org.springframework.web.client.RestTemplate;
import org.springframework.web.multipart.MultipartFile;
import org.springframework.web.service.annotation.GetExchange;
import org.springframework.web.service.annotation.PostExchange;
import org.springframework.web.service.annotation.PutExchange;
import org.springframework.web.service.invoker.HttpServiceProxyFactory;
import org.springframework.web.testfixture.servlet.MockMultipartFile;
import org.springframework.web.util.DefaultUriBuilderFactory;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Integration tests for {@link HttpServiceProxyFactory HTTP Service proxy} using
* {@link RestTemplate} and {@link MockWebServer}.
*
* @author Olga Maciaszek-Sharma
*/
class RestTemplateHttpServiceProxyTests {
private MockWebServer server;
private TestService testService;
@BeforeEach
void setUp() {
this.server = new MockWebServer();
prepareResponse();
this.testService = initTestService();
}
private TestService initTestService() {
RestTemplate restTemplate = new RestTemplate();
restTemplate.setUriTemplateHandler(new DefaultUriBuilderFactory(this.server.url("/").toString()));
return HttpServiceProxyFactory.builder()
.exchangeAdapter(RestTemplateAdapter.forTemplate(restTemplate))
.build()
.createClient(TestService.class);
}
@SuppressWarnings("ConstantConditions")
@AfterEach
void shutDown() throws IOException {
if (this.server != null) {
this.server.shutdown();
}
}
@Test
void getRequest() throws InterruptedException {
String response = testService.getRequest();
RecordedRequest request = this.server.takeRequest();
assertThat(response).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/test");
}
@Test
void getRequestWithPathVariable() throws InterruptedException {
ResponseEntity<String> response = testService.getRequestWithPathVariable("456");
RecordedRequest request = this.server.takeRequest();
assertThat(response.getStatusCode()).isEqualTo(HttpStatus.OK);
assertThat(response.getBody()).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getPath()).isEqualTo("/test/456");
}
@Test
void getRequestWithDynamicUri() throws InterruptedException {
URI dynamicUri = this.server.url("/greeting/123").uri();
Optional<String> response = testService.getRequestWithDynamicUri(dynamicUri, "456");
RecordedRequest request = this.server.takeRequest();
assertThat(response.orElse("empty")).isEqualTo("Hello Spring!");
assertThat(request.getMethod()).isEqualTo("GET");
assertThat(request.getRequestUrl().uri()).isEqualTo(dynamicUri);
}
@Test
void postWithRequestHeader() throws InterruptedException {
testService.postRequestWithHeader("testHeader", "testBody");
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("POST");
assertThat(request.getPath()).isEqualTo("/test");
assertThat(request.getHeaders().get("testHeaderName")).isEqualTo("testHeader");
assertThat(request.getBody().readUtf8()).isEqualTo("testBody");
}
@Test
void formData() throws Exception {
MultiValueMap<String, String> map = new LinkedMultiValueMap<>();
map.add("param1", "value 1");
map.add("param2", "value 2");
testService.postForm(map);
RecordedRequest request = this.server.takeRequest();
assertThat(request.getHeaders().get("Content-Type"))
.isEqualTo("application/x-www-form-urlencoded;charset=UTF-8");
assertThat(request.getBody().readUtf8()).isEqualTo("param1=value+1&param2=value+2");
}
@Test // gh-30342
void multipart() throws InterruptedException {
String fileName = "testFileName";
String originalFileName = "originalTestFileName";
MultipartFile file = new MockMultipartFile(fileName, originalFileName, MediaType.APPLICATION_JSON_VALUE,
"test".getBytes());
testService.postMultipart(file, "test2");
RecordedRequest request = this.server.takeRequest();
assertThat(request.getHeaders().get("Content-Type")).startsWith("multipart/form-data;boundary=");
assertThat(request.getBody().readUtf8()).containsSubsequence(
"Content-Disposition: form-data; name=\"file\"; filename=\"originalTestFileName\"",
"Content-Type: application/json", "Content-Length: 4", "test",
"Content-Disposition: form-data; name=\"anotherPart\"", "Content-Type: text/plain;charset=UTF-8",
"Content-Length: 5", "test2");
}
@Test
void putRequestWithCookies() throws InterruptedException {
testService.putRequestWithCookies("test1", "test2");
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("PUT");
assertThat(request.getHeader("Cookie")).isEqualTo("firstCookie=test1; secondCookie=test2");
}
@Test
void putRequestWithSameNameCookies() throws InterruptedException {
testService.putRequestWithSameNameCookies("test1", "test2");
RecordedRequest request = this.server.takeRequest();
assertThat(request.getMethod()).isEqualTo("PUT");
assertThat(request.getHeader("Cookie")).isEqualTo("testCookie=test1; testCookie=test2");
}
private void prepareResponse() {
MockResponse response = new MockResponse();
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!");
this.server.enqueue(response);
}
private interface TestService {
@GetExchange("/test")
String getRequest();
@GetExchange("/test/{id}")
ResponseEntity<String> getRequestWithPathVariable(@PathVariable String id);
@GetExchange("/test/{id}")
Optional<String> getRequestWithDynamicUri(@Nullable URI uri, @PathVariable String id);
@PostExchange("/test")
void postRequestWithHeader(@RequestHeader("testHeaderName") String testHeader,
@RequestBody String requestBody);
@PostExchange(contentType = "application/x-www-form-urlencoded")
void postForm(@RequestParam MultiValueMap<String, String> params);
@PostExchange
void postMultipart(MultipartFile file, @RequestPart String anotherPart);
@PutExchange
void putRequestWithCookies(@CookieValue String firstCookie,
@CookieValue String secondCookie);
@PutExchange
void putRequestWithSameNameCookies(@CookieValue("testCookie") String firstCookie,
@CookieValue("testCookie") String secondCookie);
}
}

39
spring-web/src/test/java/org/springframework/web/service/invoker/HttpClientServiceMethodTests.java Normal file
View File

@ -0,0 +1,39 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.service.invoker;
import org.junit.jupiter.api.BeforeEach;
/**
* Tests for {@link HttpServiceMethod} with a test {@link TestHttpClientAdapter} that
* stubs the client invocations.
* <p>
* The tests do not create or invoke {@code HttpServiceMethod} directly but rather use
* {@link HttpServiceProxyFactory} to create a service proxy in order to use a strongly
* typed interface without the need for class casts.
*
* @author Olga Maciaszek-Sharma
*/
public class HttpClientServiceMethodTests extends ReactiveHttpServiceMethodTests {
@BeforeEach
void setUp(){
this.client = new TestHttpClientAdapter();
this.proxyFactory = HttpServiceProxyFactory.builder((HttpClientAdapter) this.client).build();
}
}

41
spring-web/src/test/java/org/springframework/web/service/invoker/HttpExchangeAdapterServiceMethodTests.java Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.service.invoker;
import org.junit.jupiter.api.BeforeEach;
/**
* Tests for {@link HttpServiceMethod} with a blocking test {@link TestHttpExchangeAdapter} that
* stubs the client invocations.
* <p>
* The tests do not create or invoke {@code HttpServiceMethod} directly but rather use
* {@link HttpServiceProxyFactory} to create a service proxy in order to use a strongly
* typed interface without the need for class casts.
*
* @author Olga Maciaszek-Sharma
*/
class HttpExchangeAdapterServiceMethodTests extends HttpServiceMethodTests {
@BeforeEach
void setUp() {
this.client = new TestHttpExchangeAdapter();
this.proxyFactory = HttpServiceProxyFactory.builder()
.exchangeAdapter((HttpExchangeAdapter) this.client)
.build();
}
}

177
spring-web/src/test/java/org/springframework/web/service/invoker/HttpServiceMethodTests.java
View File

@ -16,18 +16,12 @@
package org.springframework.web.service.invoker;
import java.util.List;
import java.util.Optional;
import io.reactivex.rxjava3.core.Completable;
import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.core.Single;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.http.MediaType;
@ -42,84 +36,25 @@ import static org.springframework.http.MediaType.APPLICATION_CBOR_VALUE;
import static org.springframework.http.MediaType.APPLICATION_JSON_VALUE;
/**
* Tests for {@link HttpServiceMethod} with a test {@link TestHttpClientAdapter}
* that stubs the client invocations.
* Base class for testing {@link HttpServiceMethod} with a test {@link TestHttpClientAdapter}
* and a test {@link TestHttpExchangeAdapter} that stub the client invocations.
*
* <p>The tests do not create or invoke {@code HttpServiceMethod} directly but
* rather use {@link HttpServiceProxyFactory} to create a service proxy in order to
* use a strongly typed interface without the need for class casts.
* <p>
* The tests do not create or invoke {@code HttpServiceMethod} directly but rather use
* {@link HttpServiceProxyFactory} to create a service proxy in order to use a strongly
* typed interface without the need for class casts.
*
* @author Rossen Stoyanchev
* @author Olga Maciaszek-Sharma
*/
class HttpServiceMethodTests {
abstract class HttpServiceMethodTests {
private static final ParameterizedTypeReference<String> BODY_TYPE = new ParameterizedTypeReference<>() {};
protected static final ParameterizedTypeReference<String> BODY_TYPE = new ParameterizedTypeReference<>() {
};
private final TestHttpClientAdapter client = new TestHttpClientAdapter();
protected TestAdapter client;
private final HttpServiceProxyFactory proxyFactory = HttpServiceProxyFactory.builder(this.client).build();
@Test
void reactorService() {
ReactorService service = this.proxyFactory.createClient(ReactorService.class);
Mono<Void> voidMono = service.execute();
StepVerifier.create(voidMono).verifyComplete();
verifyClientInvocation("requestToVoid", null);
Mono<HttpHeaders> headersMono = service.getHeaders();
StepVerifier.create(headersMono).expectNextCount(1).verifyComplete();
verifyClientInvocation("requestToHeaders", null);
Mono<String> body = service.getBody();
StepVerifier.create(body).expectNext("requestToBody").verifyComplete();
verifyClientInvocation("requestToBody", BODY_TYPE);
Flux<String> fluxBody = service.getFluxBody();
StepVerifier.create(fluxBody).expectNext("request", "To", "Body", "Flux").verifyComplete();
verifyClientInvocation("requestToBodyFlux", BODY_TYPE);
Mono<ResponseEntity<Void>> voidEntity = service.getVoidEntity();
StepVerifier.create(voidEntity).expectNext(ResponseEntity.ok().build()).verifyComplete();
verifyClientInvocation("requestToBodilessEntity", null);
Mono<ResponseEntity<String>> entity = service.getEntity();
StepVerifier.create(entity).expectNext(ResponseEntity.ok("requestToEntity"));
verifyClientInvocation("requestToEntity", BODY_TYPE);
Mono<ResponseEntity<Flux<String>>> fluxEntity= service.getFluxEntity();
StepVerifier.create(fluxEntity.flatMapMany(HttpEntity::getBody)).expectNext("request", "To", "Entity", "Flux").verifyComplete();
verifyClientInvocation("requestToEntityFlux", BODY_TYPE);
assertThat(service.getDefaultMethodValue()).isEqualTo("default value");
}
@Test
void rxJavaService() {
RxJavaService service = this.proxyFactory.createClient(RxJavaService.class);
Completable completable = service.execute();
assertThat(completable).isNotNull();
Single<HttpHeaders> headersSingle = service.getHeaders();
assertThat(headersSingle.blockingGet()).isNotNull();
Single<String> bodySingle = service.getBody();
assertThat(bodySingle.blockingGet()).isEqualTo("requestToBody");
Flowable<String> bodyFlow = service.getFlowableBody();
assertThat(bodyFlow.toList().blockingGet()).asList().containsExactly("request", "To", "Body", "Flux");
Single<ResponseEntity<Void>> voidEntity = service.getVoidEntity();
assertThat(voidEntity.blockingGet().getBody()).isNull();
Single<ResponseEntity<String>> entitySingle = service.getEntity();
assertThat(entitySingle.blockingGet().getBody()).isEqualTo("requestToEntity");
Single<ResponseEntity<Flowable<String>>> entityFlow = service.getFlowableEntity();
Flowable<String> body = (entityFlow.blockingGet()).getBody();
assertThat(body.toList().blockingGet()).containsExactly("request", "To", "Entity", "Flux");
}
protected HttpServiceProxyFactory proxyFactory;
@Test
void blockingService() {
@ -131,16 +66,19 @@ class HttpServiceMethodTests {
assertThat(headers).isNotNull();
String body = service.getBody();
assertThat(body).isEqualTo("requestToBody");
assertThat(body).isEqualTo(client.getInvokedMethodReference());
Optional<String> optional = service.getBodyOptional();
assertThat(optional).contains("requestToBody");
assertThat(optional).contains("body");
ResponseEntity<String> entity = service.getEntity();
assertThat(entity.getBody()).isEqualTo("requestToEntity");
assertThat(entity.getBody()).isEqualTo("entity");
ResponseEntity<Void> voidEntity = service.getVoidEntity();
assertThat(voidEntity.getBody()).isNull();
List<String> list = service.getList();
assertThat(list.get(0)).isEqualTo("body");
}
@Test
@ -166,9 +104,12 @@ class HttpServiceMethodTests {
@Test
void typeAndMethodAnnotatedService() {
HttpServiceProxyFactory proxyFactory = HttpServiceProxyFactory.builder(this.client)
.embeddedValueResolver(value -> (value.equals("${baseUrl}") ? "/base" : value))
.build();
HttpExchangeAdapter actualClient = this.client instanceof HttpClientAdapter httpClient
? httpClient.asHttpExchangeAdapter() : (HttpExchangeAdapter) client;
HttpServiceProxyFactory proxyFactory = HttpServiceProxyFactory.builder()
.exchangeAdapter(actualClient)
.embeddedValueResolver(value -> (value.equals("${baseUrl}") ? "/base" : value))
.build();
MethodLevelAnnotatedService service = proxyFactory.createClient(TypeAndMethodLevelAnnotatedService.class);
@ -189,68 +130,11 @@ class HttpServiceMethodTests {
assertThat(requestValues.getHeaders().getAccept()).containsExactly(MediaType.APPLICATION_JSON);
}
private void verifyClientInvocation(String methodName, @Nullable ParameterizedTypeReference<?> expectedBodyType) {
assertThat(this.client.getInvokedMethodName()).isEqualTo(methodName);
protected void verifyClientInvocation(String methodName, @Nullable ParameterizedTypeReference<?> expectedBodyType) {
assertThat(this.client.getInvokedMethodReference()).isEqualTo(methodName);
assertThat(this.client.getBodyType()).isEqualTo(expectedBodyType);
}
@SuppressWarnings("unused")
private interface ReactorService {
@GetExchange
Mono<Void> execute();
@GetExchange
Mono<HttpHeaders> getHeaders();
@GetExchange
Mono<String> getBody();
@GetExchange
Flux<String> getFluxBody();
@GetExchange
Mono<ResponseEntity<Void>> getVoidEntity();
@GetExchange
Mono<ResponseEntity<String>> getEntity();
@GetExchange
Mono<ResponseEntity<Flux<String>>> getFluxEntity();
default String getDefaultMethodValue() {
return "default value";
}
}
@SuppressWarnings("unused")
private interface RxJavaService {
@GetExchange
Completable execute();
@GetExchange
Single<HttpHeaders> getHeaders();
@GetExchange
Single<String> getBody();
@GetExchange
Flowable<String> getFlowableBody();
@GetExchange
Single<ResponseEntity<Void>> getVoidEntity();
@GetExchange
Single<ResponseEntity<String>> getEntity();
@GetExchange
Single<ResponseEntity<Flowable<String>>> getFlowableEntity();
}
@SuppressWarnings("unused")
private interface BlockingService {
@ -271,8 +155,11 @@ class HttpServiceMethodTests {
@GetExchange
ResponseEntity<String> getEntity();
}
@GetExchange
List<String> getList();
}
@SuppressWarnings("unused")
private interface MethodLevelAnnotatedService {
@ -285,10 +172,10 @@ class HttpServiceMethodTests {
}
@SuppressWarnings("unused")
@HttpExchange(url = "${baseUrl}", contentType = APPLICATION_CBOR_VALUE, accept = APPLICATION_CBOR_VALUE)
private interface TypeAndMethodLevelAnnotatedService extends MethodLevelAnnotatedService {
}
}

167
spring-web/src/test/java/org/springframework/web/service/invoker/ReactiveHttpServiceMethodTests.java Normal file
View File

@ -0,0 +1,167 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.service.invoker;
import io.reactivex.rxjava3.core.Completable;
import io.reactivex.rxjava3.core.Flowable;
import io.reactivex.rxjava3.core.Single;
import org.junit.jupiter.api.Test;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
import reactor.test.StepVerifier;
import org.springframework.http.HttpEntity;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.web.service.annotation.GetExchange;
import static org.assertj.core.api.Assertions.assertThat;
/**
* Base class for testing reactive scenarios in {@link HttpServiceMethod} with
* a test {@link TestHttpClientAdapter} and a test {@link TestHttpExchangeAdapter}
* that stub the client invocations.
*
* <p>
* The tests do not create or invoke {@code HttpServiceMethod} directly but rather use
* {@link HttpServiceProxyFactory} to create a service proxy in order to use a strongly
* typed interface without the need for class casts.
*
* @author Rossen Stoyanchev
* @author Olga Maciaszek-Sharma
*/
abstract class ReactiveHttpServiceMethodTests extends HttpServiceMethodTests {
@Test
void reactorService() {
ReactorService service = proxyFactory.createClient(ReactorService.class);
Mono<Void> voidMono = service.execute();
StepVerifier.create(voidMono).verifyComplete();
verifyClientInvocation("void", null);
Mono<HttpHeaders> headersMono = service.getHeaders();
StepVerifier.create(headersMono).expectNextCount(1).verifyComplete();
verifyClientInvocation("headers", null);
Mono<String> body = service.getBody();
StepVerifier.create(body).expectNext("body").verifyComplete();
verifyClientInvocation("body", BODY_TYPE);
Flux<String> fluxBody = service.getFluxBody();
StepVerifier.create(fluxBody).expectNext("request", "To", "Body", "Flux").verifyComplete();
verifyClientInvocation("bodyFlux", BODY_TYPE);
Mono<ResponseEntity<Void>> voidEntity = service.getVoidEntity();
StepVerifier.create(voidEntity).expectNext(ResponseEntity.ok().build()).verifyComplete();
verifyClientInvocation("bodilessEntity", null);
Mono<ResponseEntity<String>> entity = service.getEntity();
StepVerifier.create(entity).expectNext(ResponseEntity.ok("requestToEntity"));
verifyClientInvocation("entity", BODY_TYPE);
Mono<ResponseEntity<Flux<String>>> fluxEntity = service.getFluxEntity();
StepVerifier.create(fluxEntity.flatMapMany(HttpEntity::getBody))
.expectNext("request", "To", "Entity", "Flux")
.verifyComplete();
verifyClientInvocation("entityFlux", BODY_TYPE);
assertThat(service.getDefaultMethodValue()).isEqualTo("default value");
}
@Test
void rxJavaService() {
RxJavaService service = this.proxyFactory.createClient(RxJavaService.class);
Completable completable = service.execute();
assertThat(completable).isNotNull();
Single<HttpHeaders> headersSingle = service.getHeaders();
assertThat(headersSingle.blockingGet()).isNotNull();
Single<String> bodySingle = service.getBody();
assertThat(bodySingle.blockingGet()).isEqualTo("body");
Flowable<String> bodyFlow = service.getFlowableBody();
assertThat(bodyFlow.toList().blockingGet()).asList().containsExactly("request", "To", "Body", "Flux");
Single<ResponseEntity<Void>> voidEntity = service.getVoidEntity();
assertThat(voidEntity.blockingGet().getBody()).isNull();
Single<ResponseEntity<String>> entitySingle = service.getEntity();
assertThat(entitySingle.blockingGet().getBody()).isEqualTo("entity");
Single<ResponseEntity<Flowable<String>>> entityFlow = service.getFlowableEntity();
Flowable<String> body = (entityFlow.blockingGet()).getBody();
assertThat(body.toList().blockingGet()).containsExactly("request", "To", "Entity", "Flux");
}
private interface ReactorService {
@GetExchange
Mono<Void> execute();
@GetExchange
Mono<HttpHeaders> getHeaders();
@GetExchange
Mono<String> getBody();
@GetExchange
Flux<String> getFluxBody();
@GetExchange
Mono<ResponseEntity<Void>> getVoidEntity();
@GetExchange
Mono<ResponseEntity<String>> getEntity();
@GetExchange
Mono<ResponseEntity<Flux<String>>> getFluxEntity();
default String getDefaultMethodValue() {
return "default value";
}
}
@SuppressWarnings("unused")
private interface RxJavaService {
@GetExchange
Completable execute();
@GetExchange
Single<HttpHeaders> getHeaders();
@GetExchange
Single<String> getBody();
@GetExchange
Flowable<String> getFlowableBody();
@GetExchange
Single<ResponseEntity<Void>> getVoidEntity();
@GetExchange
Single<ResponseEntity<String>> getEntity();
@GetExchange
Single<ResponseEntity<Flowable<String>>> getFlowableEntity();
}
}

41
spring-web/src/test/java/org/springframework/web/service/invoker/ReactorExchangeAdapterHttpServiceMethodTests.java Normal file
View File

@ -0,0 +1,41 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.service.invoker;
import org.junit.jupiter.api.BeforeEach;
/**
* Tests for {@link HttpServiceMethod} with an {@link HttpExchangeAdapter}
* build from a test {@link TestHttpClientAdapter} that stubs the client invocations.
* <p>
* The tests do not create or invoke {@code HttpServiceMethod} directly but rather use
* {@link HttpServiceProxyFactory} to create a service proxy in order to use a strongly
* typed interface without the need for class casts.
*
* @author Olga Maciaszek-Sharma
*/
public class ReactorExchangeAdapterHttpServiceMethodTests extends ReactiveHttpServiceMethodTests {
@BeforeEach
void setUp() {
this.client = new TestHttpClientAdapter();
this.proxyFactory = HttpServiceProxyFactory.builder()
.exchangeAdapter(((HttpClientAdapter) this.client).asHttpExchangeAdapter())
.build();
}
}

37
spring-web/src/test/java/org/springframework/web/service/invoker/TestAdapter.java Normal file
View File

@ -0,0 +1,37 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.service.invoker;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.lang.Nullable;
/**
* A helper interface for verifying method invoked on {@link HttpExchangeAdapter}
* and {@link HttpClientAdapter}, as well as their values.
*
* @author Olga Maciaszek-Sharma
*/
interface TestAdapter {
String getInvokedMethodReference();
HttpRequestValues getRequestValues();
@Nullable
ParameterizedTypeReference<?> getBodyType();
}

42
spring-web/src/test/java/org/springframework/web/service/invoker/TestHttpClientAdapter.java
View File

@ -1,5 +1,5 @@
/*
* Copyright 2002-2022 the original author or authors.
* Copyright 2002-2023 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,6 +16,8 @@
package org.springframework.web.service.invoker;
import java.util.Collections;
import reactor.core.publisher.Flux;
import reactor.core.publisher.Mono;
@ -33,10 +35,10 @@ import static org.assertj.core.api.Assertions.assertThat;
* @author Olga Maciaszek-Sharma
*/
@SuppressWarnings("unchecked")
class TestHttpClientAdapter implements HttpClientAdapter {
class TestHttpClientAdapter implements HttpClientAdapter, TestAdapter {
@Nullable
private String invokedMethodName;
private String invokedForReturnMethodReference;
@Nullable
private HttpRequestValues requestValues;
@ -44,17 +46,19 @@ class TestHttpClientAdapter implements HttpClientAdapter {
@Nullable
private ParameterizedTypeReference<?> bodyType;
public String getInvokedMethodName() {
assertThat(this.invokedMethodName).isNotNull();
return this.invokedMethodName;
@Override
public String getInvokedMethodReference() {
assertThat(this.invokedForReturnMethodReference).isNotNull();
return this.invokedForReturnMethodReference;
}
@Override
public HttpRequestValues getRequestValues() {
assertThat(this.requestValues).isNotNull();
return this.requestValues;
}
@Override
@Nullable
public ParameterizedTypeReference<?> getBodyType() {
return this.bodyType;
@ -65,31 +69,33 @@ class TestHttpClientAdapter implements HttpClientAdapter {
@Override
public Mono<Void> requestToVoid(HttpRequestValues requestValues) {
saveInput("requestToVoid", requestValues, null);
saveInput("void", requestValues, null);
return Mono.empty();
}
@Override
public Mono<HttpHeaders> requestToHeaders(HttpRequestValues requestValues) {
saveInput("requestToHeaders", requestValues, null);
saveInput("headers", requestValues, null);
return Mono.just(new HttpHeaders());
}
@Override
public <T> Mono<T> requestToBody(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
saveInput("requestToBody", requestValues, bodyType);
return (Mono<T>) Mono.just(getInvokedMethodName());
saveInput("body", requestValues, bodyType);
return bodyType.getType().getTypeName().contains("List") ?
(Mono<T>) Mono.just(Collections.singletonList(getInvokedMethodReference()))
: (Mono<T>) Mono.just(getInvokedMethodReference());
}
@Override
public <T> Flux<T> requestToBodyFlux(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
saveInput("requestToBodyFlux", requestValues, bodyType);
saveInput("bodyFlux", requestValues, bodyType);
return (Flux<T>) Flux.just("request", "To", "Body", "Flux");
}
@Override
public Mono<ResponseEntity<Void>> requestToBodilessEntity(HttpRequestValues requestValues) {
saveInput("requestToBodilessEntity", requestValues, null);
saveInput("bodilessEntity", requestValues, null);
return Mono.just(ResponseEntity.ok().build());
}
@ -97,22 +103,22 @@ class TestHttpClientAdapter implements HttpClientAdapter {
public <T> Mono<ResponseEntity<T>> requestToEntity(
HttpRequestValues requestValues, ParameterizedTypeReference<T> type) {
saveInput("requestToEntity", requestValues, type);
return Mono.just((ResponseEntity<T>) ResponseEntity.ok("requestToEntity"));
saveInput("entity", requestValues, type);
return Mono.just((ResponseEntity<T>) ResponseEntity.ok("entity"));
}
@Override
public <T> Mono<ResponseEntity<Flux<T>>> requestToEntityFlux(
HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
saveInput("requestToEntityFlux", requestValues, bodyType);
saveInput("entityFlux", requestValues, bodyType);
return Mono.just(ResponseEntity.ok((Flux<T>) Flux.just("request", "To", "Entity", "Flux")));
}
private <T> void saveInput(
String methodName, HttpRequestValues requestValues, @Nullable ParameterizedTypeReference<T> bodyType) {
String reference, HttpRequestValues requestValues, @Nullable ParameterizedTypeReference<T> bodyType) {
this.invokedMethodName = methodName;
this.invokedForReturnMethodReference = reference;
this.requestValues = requestValues;
this.bodyType = bodyType;
}

106
spring-web/src/test/java/org/springframework/web/service/invoker/TestHttpExchangeAdapter.java Normal file
View File

@ -0,0 +1,106 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.service.invoker;
import java.util.Collections;
import org.springframework.core.ParameterizedTypeReference;
import org.springframework.http.HttpHeaders;
import org.springframework.http.ResponseEntity;
import org.springframework.lang.Nullable;
import static org.assertj.core.api.Assertions.assertThat;
/**
* {@link HttpExchangeAdapter} with stubbed responses.
*
* @author Olga Maciaszek-Sharma
*/
@SuppressWarnings("unchecked")
public class TestHttpExchangeAdapter implements HttpExchangeAdapter, TestAdapter {
@Nullable
private String invokedMethodName;
@Nullable
private HttpRequestValues requestValues;
@Nullable
private ParameterizedTypeReference<?> bodyType;
public String getInvokedMethodReference() {
assertThat(this.invokedMethodName).isNotNull();
return this.invokedMethodName;
}
public HttpRequestValues getRequestValues() {
assertThat(this.requestValues).isNotNull();
return this.requestValues;
}
@Override
@Nullable
public ParameterizedTypeReference<?> getBodyType() {
return this.bodyType;
}
@Override
public Void exchange(HttpRequestValues requestValues) {
saveInput("void", requestValues, null);
return null;
}
@Override
public HttpHeaders exchangeForHeaders(HttpRequestValues requestValues) {
saveInput("headers", requestValues, null);
return new HttpHeaders();
}
@Override
public <T> T exchangeForBody(HttpRequestValues requestValues, ParameterizedTypeReference<T> bodyType) {
saveInput("body", requestValues, bodyType);
return bodyType.getType().getTypeName().contains("List")
? (T) Collections.singletonList(getInvokedMethodReference()) : (T) getInvokedMethodReference();
}
@Override
public ResponseEntity<Void> exchangeForBodilessEntity(HttpRequestValues requestValues) {
saveInput("bodilessEntity", requestValues, null);
return ResponseEntity.ok().build();
}
@Override
public <T> ResponseEntity<T> exchangeForEntity(HttpRequestValues requestValues,
ParameterizedTypeReference<T> bodyType) {
saveInput("entity", requestValues, bodyType);
return (ResponseEntity<T>) ResponseEntity.ok(this.getInvokedMethodReference());
}
@Override
public boolean supportsRequestAttributes() {
return false;
}
private <T> void saveInput(String methodName, HttpRequestValues requestValues,
@Nullable ParameterizedTypeReference<T> bodyType) {
this.invokedMethodName = methodName;
this.requestValues = requestValues;
this.bodyType = bodyType;
}
}

218
spring-web/src/test/kotlin/org/springframework/web/client/support/KotlinRestTemplateHttpServiceProxyTests.kt Normal file
View File

@ -0,0 +1,218 @@
/*
* Copyright 2002-2023 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.
* You may obtain a copy of the License at
*
* https://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.springframework.web.client.support
import okhttp3.mockwebserver.MockResponse
import okhttp3.mockwebserver.MockWebServer
import org.assertj.core.api.Assertions.assertThat
import org.junit.jupiter.api.AfterEach
import org.junit.jupiter.api.BeforeEach
import org.junit.jupiter.api.Test
import org.springframework.http.HttpStatus
import org.springframework.http.MediaType
import org.springframework.http.ResponseEntity
import org.springframework.lang.Nullable
import org.springframework.util.LinkedMultiValueMap
import org.springframework.util.MultiValueMap
import org.springframework.web.bind.annotation.*
import org.springframework.web.client.RestTemplate
import org.springframework.web.multipart.MultipartFile
import org.springframework.web.service.annotation.GetExchange
import org.springframework.web.service.annotation.PostExchange
import org.springframework.web.service.annotation.PutExchange
import org.springframework.web.service.invoker.HttpServiceProxyFactory
import org.springframework.web.testfixture.servlet.MockMultipartFile
import org.springframework.web.util.DefaultUriBuilderFactory
import java.net.URI
import java.util.*
/**
* Kotlin integration tests for {@link HttpServiceProxyFactory HTTP Service proxy} using
* {@link RestTemplate} and {@link MockWebServer}.
*
* @author Olga Maciaszek-Sharma
*/
class KotlinRestTemplateHttpServiceProxyTests {
private lateinit var server: MockWebServer
private lateinit var testService: TestService
@BeforeEach
fun setUp() {
server = MockWebServer()
prepareResponse()
testService = initTestService()
}
private fun initTestService(): TestService {
val restTemplate = RestTemplate()
restTemplate.uriTemplateHandler = DefaultUriBuilderFactory(server.url("/").toString())
return HttpServiceProxyFactory.builder()
.exchangeAdapter(RestTemplateAdapter.forTemplate(restTemplate))
.build()
.createClient(TestService::class.java)
}
@AfterEach
fun shutDown() {
server.shutdown()
}
@Test
@Throws(InterruptedException::class)
fun getRequest() {
val response = testService.request
val request = server.takeRequest()
assertThat(response).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/test")
}
@Test
@Throws(InterruptedException::class)
fun getRequestWithPathVariable() {
val response = testService.getRequestWithPathVariable("456")
val request = server.takeRequest()
assertThat(response.statusCode).isEqualTo(HttpStatus.OK)
assertThat(response.body).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.path).isEqualTo("/test/456")
}
@Test
@Throws(InterruptedException::class)
fun getRequestWithDynamicUri() {
val dynamicUri = server.url("/greeting/123").uri()
val response = testService.getRequestWithDynamicUri(dynamicUri, "456")
val request = server.takeRequest()
assertThat(response.orElse("empty")).isEqualTo("Hello Spring!")
assertThat(request.method).isEqualTo("GET")
assertThat(request.requestUrl.uri()).isEqualTo(dynamicUri)
}
@Test
@Throws(InterruptedException::class)
fun postWithRequestHeader() {
testService.postRequestWithHeader("testHeader", "testBody")
val request = server.takeRequest()
assertThat(request.method).isEqualTo("POST")
assertThat(request.path).isEqualTo("/test")
assertThat(request.headers["testHeaderName"]).isEqualTo("testHeader")
assertThat(request.body.readUtf8()).isEqualTo("testBody")
}
@Test
@Throws(Exception::class)
fun formData() {
val map: MultiValueMap<String, String> = LinkedMultiValueMap()
map.add("param1", "value 1")
map.add("param2", "value 2")
testService.postForm(map)
val request = server.takeRequest()
assertThat(request.headers["Content-Type"])
.isEqualTo("application/x-www-form-urlencoded;charset=UTF-8")
assertThat(request.body.readUtf8()).isEqualTo("param1=value+1&param2=value+2")
}
// gh-30342
@Test
@Throws(InterruptedException::class)
fun multipart() {
val fileName = "testFileName"
val originalFileName = "originalTestFileName"
val file: MultipartFile = MockMultipartFile(fileName, originalFileName, MediaType.APPLICATION_JSON_VALUE,
"test".toByteArray())
testService.postMultipart(file, "test2")
val request = server.takeRequest()
assertThat(request.headers["Content-Type"]).startsWith("multipart/form-data;boundary=")
assertThat(request.body.readUtf8()).containsSubsequence(
"Content-Disposition: form-data; name=\"file\"; filename=\"originalTestFileName\"",
"Content-Type: application/json", "Content-Length: 4", "test",
"Content-Disposition: form-data; name=\"anotherPart\"", "Content-Type: text/plain;charset=UTF-8",
"Content-Length: 5", "test2")
}
@Test
@Throws(InterruptedException::class)
fun putRequestWithCookies() {
testService.putRequestWithCookies("test1", "test2")
val request = server.takeRequest()
assertThat(request.method).isEqualTo("PUT")
assertThat(request.getHeader("Cookie"))
.isEqualTo("firstCookie=test1; secondCookie=test2")
}
@Test
@Throws(InterruptedException::class)
fun putRequestWithSameNameCookies() {
testService.putRequestWithSameNameCookies("test1", "test2")
val request = server.takeRequest()
assertThat(request.method).isEqualTo("PUT")
assertThat(request.getHeader("Cookie"))
.isEqualTo("testCookie=test1; testCookie=test2")
}
private fun prepareResponse() {
val response = MockResponse()
response.setHeader("Content-Type", "text/plain").setBody("Hello Spring!")
server.enqueue(response)
}
private interface TestService {
@get:GetExchange("/test")
val request: String
@GetExchange("/test/{id}")
fun getRequestWithPathVariable(@PathVariable id: String): ResponseEntity<String>
@GetExchange("/test/{id}")
fun getRequestWithDynamicUri(@Nullable uri: URI, @PathVariable id: String): Optional<String>
@PostExchange("/test")
fun postRequestWithHeader(@RequestHeader("testHeaderName") testHeader: String,
@RequestBody requestBody: String)
@PostExchange(contentType = "application/x-www-form-urlencoded")
fun postForm(@RequestParam params: MultiValueMap<String, String>)
@PostExchange
fun postMultipart(file: MultipartFile, @RequestPart anotherPart: String)
@PutExchange
fun putRequestWithCookies(@CookieValue firstCookie: String,
@CookieValue secondCookie: String)
@PutExchange
fun putRequestWithSameNameCookies(@CookieValue("testCookie") firstCookie: String,
@CookieValue("testCookie") secondCookie: String)
}
}

117
spring-web/src/test/kotlin/org/springframework/web/service/invoker/HttpServiceMethodKotlinTests.kt
View File

@ -20,6 +20,7 @@ import kotlinx.coroutines.flow.Flow
import kotlinx.coroutines.flow.toList
import kotlinx.coroutines.runBlocking
import org.assertj.core.api.Assertions.assertThat
import org.assertj.core.api.Assertions.assertThatIllegalStateException
import org.junit.jupiter.api.Test
import org.springframework.core.ParameterizedTypeReference
import org.springframework.http.HttpStatus
@ -30,64 +31,124 @@ import org.springframework.web.service.annotation.GetExchange
* Kotlin tests for [HttpServiceMethod].
*
* @author Sebastien Deleuze
* @author Olga Maciaszek-Sharma
*/
class HttpServiceMethodKotlinTests {
@Suppress("DEPRECATION")
class KotlinHttpServiceMethodTests {
private val client = TestHttpClientAdapter()
private val proxyFactory = HttpServiceProxyFactory.builder(client).build()
private val webClientAdapter = TestHttpClientAdapter()
private val httpExchangeAdapter = TestHttpExchangeAdapter()
private val proxyFactory = HttpServiceProxyFactory.builder(webClientAdapter).build()
private val blockingProxyFactory = HttpServiceProxyFactory.builder()
.exchangeAdapter(httpExchangeAdapter).build()
@Test
fun coroutinesService(): Unit = runBlocking {
val service = proxyFactory.createClient(CoroutinesService::class.java)
val service = proxyFactory.createClient(FunctionsService::class.java)
val stringBody = service.stringBody()
assertThat(stringBody).isEqualTo("requestToBody")
verifyClientInvocation("requestToBody", object : ParameterizedTypeReference<String>() {})
assertThat(stringBody).isEqualTo("body")
verifyClientInvocation("body", object : ParameterizedTypeReference<String>() {})
service.listBody()
verifyClientInvocation("requestToBody", object : ParameterizedTypeReference<MutableList<String>>() {})
verifyClientInvocation("body", object : ParameterizedTypeReference<MutableList<String>>() {})
val flowBody = service.flowBody()
assertThat(flowBody.toList()).containsExactly("request", "To", "Body", "Flux")
verifyClientInvocation("requestToBodyFlux", object : ParameterizedTypeReference<String>() {})
verifyClientInvocation("bodyFlux", object : ParameterizedTypeReference<String>() {})
val stringEntity = service.stringEntity()
assertThat(stringEntity).isEqualTo(ResponseEntity.ok<String>("requestToEntity"))
verifyClientInvocation("requestToEntity", object : ParameterizedTypeReference<String>() {})
assertThat(stringEntity).isEqualTo(ResponseEntity.ok<String>("entity"))
verifyClientInvocation("entity", object : ParameterizedTypeReference<String>() {})
service.listEntity()
verifyClientInvocation("requestToEntity", object : ParameterizedTypeReference<MutableList<String>>() {})
verifyClientInvocation("entity", object : ParameterizedTypeReference<MutableList<String>>() {})
val flowEntity = service.flowEntity()
assertThat(flowEntity.statusCode).isEqualTo(HttpStatus.OK)
assertThat(flowEntity.body!!.toList()).containsExactly("request", "To", "Entity", "Flux")
verifyClientInvocation("requestToEntityFlux", object : ParameterizedTypeReference<String>() {})
verifyClientInvocation("entityFlux", object : ParameterizedTypeReference<String>() {})
}
private fun verifyClientInvocation(methodName: String, expectedBodyType: ParameterizedTypeReference<*>) {
assertThat(client.invokedMethodName).isEqualTo(methodName)
assertThat(client.bodyType).isEqualTo(expectedBodyType)
@Test
fun blockingServiceWithExchangeResponseFunction() {
val service = blockingProxyFactory.createClient(BlockingFunctionsService::class.java)
val stringBody = service.stringBodyBlocking()
assertThat(stringBody).isEqualTo("body")
verifyTemplateInvocation("body", object : ParameterizedTypeReference<String>() {})
val listBody = service.listBodyBlocking()
assertThat(listBody.size).isEqualTo(1)
verifyTemplateInvocation("body", object : ParameterizedTypeReference<MutableList<String>>() {})
val stringEntity = service.stringEntityBlocking()
assertThat(stringEntity).isEqualTo(ResponseEntity.ok<String>("entity"))
verifyTemplateInvocation("entity", object : ParameterizedTypeReference<String>() {})
service.listEntityBlocking()
verifyTemplateInvocation("entity", object : ParameterizedTypeReference<MutableList<String>>() {})
}
@Test
fun coroutineServiceWithExchangeResponseFunction() {
assertThatIllegalStateException().isThrownBy {
blockingProxyFactory.createClient(FunctionsService::class.java)
}
assertThatIllegalStateException().isThrownBy {
blockingProxyFactory.createClient(SuspendingFunctionsService::class.java)
}
}
private fun verifyTemplateInvocation(methodReference: String, expectedBodyType: ParameterizedTypeReference<*>) {
assertThat(httpExchangeAdapter.invokedMethodReference).isEqualTo(methodReference)
assertThat(httpExchangeAdapter.bodyType).isEqualTo(expectedBodyType)
}
private fun verifyClientInvocation(methodReference: String, expectedBodyType: ParameterizedTypeReference<*>) {
assertThat(webClientAdapter.invokedMethodReference).isEqualTo(methodReference)
assertThat(webClientAdapter.bodyType).isEqualTo(expectedBodyType)
}
private interface CoroutinesService {
@GetExchange
suspend fun stringBody(): String
@GetExchange
suspend fun listBody(): MutableList<String>
private interface FunctionsService : SuspendingFunctionsService {
@GetExchange
fun flowBody(): Flow<String>
@GetExchange
suspend fun stringEntity(): ResponseEntity<String>
@GetExchange
suspend fun listEntity(): ResponseEntity<MutableList<String>>
@GetExchange
fun flowEntity(): ResponseEntity<Flow<String>>
}
private interface SuspendingFunctionsService : BlockingFunctionsService {
@GetExchange
suspend fun stringBody(): String
@GetExchange
suspend fun listBody(): MutableList<String>
@GetExchange
suspend fun stringEntity(): ResponseEntity<String>
@GetExchange
suspend fun listEntity(): ResponseEntity<MutableList<String>>
}
private interface BlockingFunctionsService {
@GetExchange
fun stringBodyBlocking(): String
@GetExchange
fun listBodyBlocking(): MutableList<String>
@GetExchange
fun stringEntityBlocking(): ResponseEntity<String>
@GetExchange
fun listEntityBlocking(): ResponseEntity<MutableList<String>>
}
}

6
spring-webflux/src/main/java/org/springframework/web/reactive/function/client/support/WebClientAdapter.java
View File

@ -25,10 +25,10 @@ import org.springframework.http.HttpMethod;
import org.springframework.http.ResponseEntity;
import org.springframework.util.Assert;
import org.springframework.web.reactive.function.client.WebClient;
import org.springframework.web.service.invoker.AbstractReactorHttpExchangeAdapter;
import org.springframework.web.service.invoker.HttpRequestValues;
import org.springframework.web.service.invoker.HttpServiceProxyFactory;
import org.springframework.web.service.invoker.ReactorHttpExchangeAdapter;
import org.springframework.web.service.invoker.AbstractReactorHttpExchangeAdapter;
/**
* {@link ReactorHttpExchangeAdapter} that enables an {@link HttpServiceProxyFactory}
@ -132,4 +132,8 @@ public final class WebClientAdapter extends AbstractReactorHttpExchangeAdapter {
return new WebClientAdapter(webClient);
}
@Override
public boolean supportsRequestAttributes() {
return true;
}
}

3
spring-webflux/src/test/kotlin/org/springframework/web/reactive/function/client/support/WebClientHttpServiceProxyKotlinTests.kt
View File

@ -41,7 +41,8 @@ import java.util.function.Consumer
* @author DongHyeon Kim
* @author Sebastien Deleuze
*/
class WebClientHttpServiceProxyKotlinTests {
@Suppress("DEPRECATION")
class KotlinWebClientHttpServiceProxyTests {
private lateinit var server: MockWebServer