Spring/spring-framework
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polishing

Browse Source
This commit is contained in:
Juergen Hoeller
2014-09-04 00:55:38 +02:00
parent c6d29f1a31
commit 20c2ba35dc
24 changed files with 453 additions and 615 deletions
Download Patch File Download Diff File Expand all files Collapse all files

223
spring-web/src/main/java/org/springframework/web/client/AsyncRestTemplate.java
View File

@@ -90,8 +90,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
*/
public AsyncRestTemplate(AsyncListenableTaskExecutor taskExecutor) {
Assert.notNull(taskExecutor, "AsyncTaskExecutor must not be null");
SimpleClientHttpRequestFactory requestFactory =
new SimpleClientHttpRequestFactory();
SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
requestFactory.setTaskExecutor(taskExecutor);
this.syncTemplate = new RestTemplate(requestFactory);
setAsyncRequestFactory(requestFactory);
@@ -116,8 +115,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
* @param asyncRequestFactory the asynchronous request factory
* @param syncRequestFactory the synchronous request factory
*/
public AsyncRestTemplate(AsyncClientHttpRequestFactory asyncRequestFactory,
ClientHttpRequestFactory syncRequestFactory) {
public AsyncRestTemplate(AsyncClientHttpRequestFactory asyncRequestFactory, ClientHttpRequestFactory syncRequestFactory) {
this(asyncRequestFactory, new RestTemplate(syncRequestFactory));
}
@@ -127,8 +125,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
* @param requestFactory the asynchronous request factory to use
* @param restTemplate the synchronous template to use
*/
public AsyncRestTemplate(AsyncClientHttpRequestFactory requestFactory,
RestTemplate restTemplate) {
public AsyncRestTemplate(AsyncClientHttpRequestFactory requestFactory, RestTemplate restTemplate) {
Assert.notNull(restTemplate, "'restTemplate' must not be null");
this.syncTemplate = restTemplate;
setAsyncRequestFactory(requestFactory);
@@ -197,6 +194,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return execute(url, HttpMethod.GET, requestCallback, responseExtractor);
}
// HEAD
@Override
@@ -220,30 +218,29 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
// POST
@Override
public ListenableFuture<URI> postForLocation(String url, HttpEntity<?> request,
Object... uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
ListenableFuture<HttpHeaders> headersFuture =
execute(url, HttpMethod.POST, requestCallback, headersExtractor,
uriVariables);
return extractLocationHeader(headersFuture);
}
@Override
public ListenableFuture<URI> postForLocation(String url, HttpEntity<?> request,
Map<String, ?> uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
ListenableFuture<HttpHeaders> headersFuture =
execute(url, HttpMethod.POST, requestCallback, headersExtractor,
uriVariables);
return extractLocationHeader(headersFuture);
}
@Override
public ListenableFuture<URI> postForLocation(URI url, HttpEntity<?> request)
public ListenableFuture<URI> postForLocation(String url, HttpEntity<?> request, Object... uriVariables)
throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
ListenableFuture<HttpHeaders> headersFuture =
execute(url, HttpMethod.POST, requestCallback, headersExtractor, uriVariables);
return extractLocationHeader(headersFuture);
}
@Override
public ListenableFuture<URI> postForLocation(String url, HttpEntity<?> request, Map<String, ?> uriVariables)
throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
ListenableFuture<HttpHeaders> headersFuture =
execute(url, HttpMethod.POST, requestCallback, headersExtractor, uriVariables);
return extractLocationHeader(headersFuture);
}
@Override
public ListenableFuture<URI> postForLocation(URI url, HttpEntity<?> request) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
ResponseExtractor<HttpHeaders> headersExtractor = headersExtractor();
ListenableFuture<HttpHeaders> headersFuture =
@@ -253,28 +250,23 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
private static ListenableFuture<URI> extractLocationHeader(final ListenableFuture<HttpHeaders> headersFuture) {
return new ListenableFuture<URI>() {
@Override
public void addCallback(final ListenableFutureCallback<? super URI> callback) {
addCallback(callback, callback);
}
@Override
public void addCallback(final SuccessCallback<? super URI> successCallback,
final FailureCallback failureCallback) {
public void addCallback(final SuccessCallback<? super URI> successCallback, final FailureCallback failureCallback) {
headersFuture.addCallback(new ListenableFutureCallback<HttpHeaders>() {
@Override
public void onSuccess(HttpHeaders result) {
successCallback.onSuccess(result.getLocation());
}
@Override
public void onFailure(Throwable t) {
failureCallback.onFailure(t);
public void onFailure(Throwable ex) {
failureCallback.onFailure(ex);
}
});
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {
return headersFuture.cancel(mayInterruptIfRunning);
@@ -293,8 +285,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return headers.getLocation();
}
@Override
public URI get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
public URI get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
HttpHeaders headers = headersFuture.get(timeout, unit);
return headers.getLocation();
}
@@ -304,45 +295,41 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
@Override
public <T> ListenableFuture<ResponseEntity<T>> postForEntity(String url, HttpEntity<?> request,
Class<T> responseType, Object... uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(responseType);
return execute(url, HttpMethod.POST, requestCallback, responseExtractor,
uriVariables);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> postForEntity(String url, HttpEntity<?> request,
Class<T> responseType, Map<String, ?> uriVariables)
throws RestClientException {
Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(responseType);
return execute(url, HttpMethod.POST, requestCallback, responseExtractor,
uriVariables);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
return execute(url, HttpMethod.POST, requestCallback, responseExtractor, uriVariables);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> postForEntity(URI url, HttpEntity<?> request,
Class<T> responseType) throws RestClientException {
public <T> ListenableFuture<ResponseEntity<T>> postForEntity(URI url, HttpEntity<?> request, Class<T> responseType)
throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
return execute(url, HttpMethod.POST, requestCallback, responseExtractor);
}
// PUT
@Override
public ListenableFuture<?> put(String url, HttpEntity<?> request, Object... uriVariables)
throws RestClientException {
public ListenableFuture<?> put(String url, HttpEntity<?> request, Object... uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
return execute(url, HttpMethod.PUT, requestCallback, null, uriVariables);
}
@Override
public ListenableFuture<?> put(String url, HttpEntity<?> request,
Map<String, ?> uriVariables) throws RestClientException {
public ListenableFuture<?> put(String url, HttpEntity<?> request, Map<String, ?> uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(request);
return execute(url, HttpMethod.PUT, requestCallback, null, uriVariables);
}
@@ -353,17 +340,16 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return execute(url, HttpMethod.PUT, requestCallback, null);
}
// DELETE
@Override
public ListenableFuture<?> delete(String url, Object... urlVariables)
throws RestClientException {
public ListenableFuture<?> delete(String url, Object... urlVariables) throws RestClientException {
return execute(url, HttpMethod.DELETE, null, null, urlVariables);
}
@Override
public ListenableFuture<?> delete(String url, Map<String, ?> urlVariables)
throws RestClientException {
public ListenableFuture<?> delete(String url, Map<String, ?> urlVariables) throws RestClientException {
return execute(url, HttpMethod.DELETE, null, null, urlVariables);
}
@@ -372,6 +358,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return execute(url, HttpMethod.DELETE, null, null);
}
// OPTIONS
@Override
@@ -397,12 +384,10 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
private static ListenableFuture<Set<HttpMethod>> extractAllowHeader(final ListenableFuture<HttpHeaders> headersFuture) {
return new ListenableFuture<Set<HttpMethod>>() {
@Override
public void addCallback(final ListenableFutureCallback<? super Set<HttpMethod>> callback) {
addCallback(callback, callback);
}
@Override
public void addCallback(final SuccessCallback<? super Set<HttpMethod>> successCallback, final FailureCallback failureCallback) {
headersFuture.addCallback(new ListenableFutureCallback<HttpHeaders>() {
@@ -410,14 +395,12 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
public void onSuccess(HttpHeaders result) {
successCallback.onSuccess(result.getAllow());
}
@Override
public void onFailure(Throwable t) {
failureCallback.onFailure(t);
public void onFailure(Throwable ex) {
failureCallback.onFailure(ex);
}
});
}
@Override
public boolean cancel(boolean mayInterruptIfRunning) {
return headersFuture.cancel(mayInterruptIfRunning);
@@ -436,8 +419,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return headers.getAllow();
}
@Override
public Set<HttpMethod> get(long timeout, TimeUnit unit)
throws InterruptedException, ExecutionException, TimeoutException {
public Set<HttpMethod> get(long timeout, TimeUnit unit) throws InterruptedException, ExecutionException, TimeoutException {
HttpHeaders headers = headersFuture.get(timeout, unit);
return headers.getAllow();
}
@@ -448,68 +430,59 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
// exchange
@Override
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method,
HttpEntity<?> requestEntity, Class<T> responseType, Object... uriVariables)
throws RestClientException {
AsyncRequestCallback requestCallback =
httpEntityCallback(requestEntity, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(responseType);
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Object... uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method,
HttpEntity<?> requestEntity, Class<T> responseType,
Map<String, ?> uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback =
httpEntityCallback(requestEntity, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(responseType);
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method,
HttpEntity<?> requestEntity, Class<T> responseType)
throws RestClientException {
AsyncRequestCallback requestCallback =
httpEntityCallback(requestEntity, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(responseType);
public <T> ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
Class<T> responseType) throws RestClientException {
AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, responseType);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(responseType);
return execute(url, method, requestCallback, responseExtractor);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method,
HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType,
Object... uriVariables) throws RestClientException {
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Object... uriVariables) throws RestClientException {
Type type = responseType.getType();
AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(type);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method,
HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType,
Map<String, ?> uriVariables) throws RestClientException {
public <T> ListenableFuture<ResponseEntity<T>> exchange(String url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType, Map<String, ?> uriVariables) throws RestClientException {
Type type = responseType.getType();
AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(type);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
return execute(url, method, requestCallback, responseExtractor, uriVariables);
}
@Override
public <T> ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method,
HttpEntity<?> requestEntity, ParameterizedTypeReference<T> responseType)
throws RestClientException {
public <T> ListenableFuture<ResponseEntity<T>> exchange(URI url, HttpMethod method, HttpEntity<?> requestEntity,
ParameterizedTypeReference<T> responseType) throws RestClientException {
Type type = responseType.getType();
AsyncRequestCallback requestCallback = httpEntityCallback(requestEntity, type);
ResponseExtractor<ResponseEntity<T>> responseExtractor =
responseEntityExtractor(type);
ResponseExtractor<ResponseEntity<T>> responseExtractor = responseEntityExtractor(type);
return execute(url, method, requestCallback, responseExtractor);
}
@@ -517,27 +490,24 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
// general execution
@Override
public <T> ListenableFuture<T> execute(String url, HttpMethod method,
AsyncRequestCallback requestCallback, ResponseExtractor<T> responseExtractor,
Object... urlVariables) throws RestClientException {
public <T> ListenableFuture<T> execute(String url, HttpMethod method, AsyncRequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Object... urlVariables) throws RestClientException {
URI expanded = new UriTemplate(url).expand(urlVariables);
return doExecute(expanded, method, requestCallback, responseExtractor);
}
@Override
public <T> ListenableFuture<T> execute(String url, HttpMethod method,
AsyncRequestCallback requestCallback, ResponseExtractor<T> responseExtractor,
Map<String, ?> urlVariables) throws RestClientException {
public <T> ListenableFuture<T> execute(String url, HttpMethod method, AsyncRequestCallback requestCallback,
ResponseExtractor<T> responseExtractor, Map<String, ?> urlVariables) throws RestClientException {
URI expanded = new UriTemplate(url).expand(urlVariables);
return doExecute(expanded, method, requestCallback, responseExtractor);
}
@Override
public <T> ListenableFuture<T> execute(URI url, HttpMethod method,
AsyncRequestCallback requestCallback, ResponseExtractor<T> responseExtractor)
throws RestClientException {
public <T> ListenableFuture<T> execute(URI url, HttpMethod method, AsyncRequestCallback requestCallback,
ResponseExtractor<T> responseExtractor) throws RestClientException {
return doExecute(url, method, requestCallback, responseExtractor);
}
@@ -565,8 +535,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
requestCallback.doWithRequest(request);
}
ListenableFuture<ClientHttpResponse> responseFuture = request.executeAsync();
return new ResponseExtractorFuture<T>(method, url, responseFuture,
responseExtractor);
return new ResponseExtractorFuture<T>(method, url, responseFuture, responseExtractor);
}
catch (IOException ex) {
throw new ResourceAccessException("I/O error on " + method.name() +
@@ -577,9 +546,8 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
private void logResponseStatus(HttpMethod method, URI url, ClientHttpResponse response) {
if (logger.isDebugEnabled()) {
try {
logger.debug("Async " + method.name() + " request for \"" + url +
"\" resulted in " + response.getStatusCode() + " (" +
response.getStatusText() + ")");
logger.debug("Async " + method.name() + " request for \"" + url + "\" resulted in " +
response.getStatusCode() + " (" + response.getStatusText() + ")");
}
catch (IOException ex) {
// ignore
@@ -590,9 +558,8 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
private void handleResponseError(HttpMethod method, URI url, ClientHttpResponse response) throws IOException {
if (logger.isWarnEnabled()) {
try {
logger.warn("Async " + method.name() + " request for \"" + url +
"\" resulted in " + response.getStatusCode() + " (" +
response.getStatusText() + "); invoking error handler");
logger.warn("Async " + method.name() + " request for \"" + url + "\" resulted in " +
response.getStatusCode() + " (" + response.getStatusText() + "); invoking error handler");
}
catch (IOException ex) {
// ignore
@@ -640,12 +607,12 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return this.syncTemplate.headersExtractor();
}
/**
* Future returned from
* {@link #doExecute(URI, HttpMethod, AsyncRequestCallback, ResponseExtractor)}
*/
private class ResponseExtractorFuture<T>
extends ListenableFutureAdapter<T, ClientHttpResponse> {
private class ResponseExtractorFuture<T> extends ListenableFutureAdapter<T, ClientHttpResponse> {
private final HttpMethod method;
@@ -654,8 +621,7 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
private final ResponseExtractor<T> responseExtractor;
public ResponseExtractorFuture(HttpMethod method, URI url,
ListenableFuture<ClientHttpResponse> clientHttpResponseFuture,
ResponseExtractor<T> responseExtractor) {
ListenableFuture<ClientHttpResponse> clientHttpResponseFuture, ResponseExtractor<T> responseExtractor) {
super(clientHttpResponseFuture);
this.method = method;
this.url = url;
@@ -684,12 +650,11 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
}
protected T convertResponse(ClientHttpResponse response) throws IOException {
return responseExtractor != null ? responseExtractor.extractData(response) :
null;
return (this.responseExtractor != null ? this.responseExtractor.extractData(response) : null);
}
}
/**
* Adapts a {@link RequestCallback} to the {@link AsyncRequestCallback} interface.
*/

96
spring-web/src/test/java/org/springframework/http/client/AbstractAsyncHttpRequestFactoryTestCase.java
View File

@@ -17,7 +17,6 @@
package org.springframework.http.client;
import java.io.IOException;
import java.io.OutputStream;
import java.net.URI;
import java.util.Arrays;
import java.util.Locale;
@@ -37,11 +36,11 @@ import org.springframework.util.concurrent.ListenableFutureCallback;
import static org.junit.Assert.*;
public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
AbstractJettyServerTestCase {
public abstract class AbstractAsyncHttpRequestFactoryTestCase extends AbstractJettyServerTestCase {
protected AsyncClientHttpRequestFactory factory;
@Before
public final void createFactory() throws Exception {
factory = createRequestFactory();
@@ -52,6 +51,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
protected abstract AsyncClientHttpRequestFactory createRequestFactory();
@Test
public void status() throws Exception {
URI uri = new URI(baseUrl + "/status/notfound");
@@ -60,8 +60,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
assertEquals("Invalid HTTP URI", uri, request.getURI());
Future<ClientHttpResponse> futureResponse = request.executeAsync();
ClientHttpResponse response = futureResponse.get();
assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
response.getStatusCode());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
}
@Test
@@ -70,46 +69,34 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
AsyncClientHttpRequest request = factory.createAsyncRequest(uri, HttpMethod.GET);
assertEquals("Invalid HTTP method", HttpMethod.GET, request.getMethod());
assertEquals("Invalid HTTP URI", uri, request.getURI());
Future<ClientHttpResponse> futureResponse = request.executeAsync();
if (futureResponse instanceof ListenableFuture) {
ListenableFuture<ClientHttpResponse> listenableFuture =
(ListenableFuture<ClientHttpResponse>) futureResponse;
listenableFuture.addCallback(new ListenableFutureCallback<ClientHttpResponse>() {
@Override
public void onSuccess(ClientHttpResponse result) {
try {
System.out.println("SUCCESS! " + result.getStatusCode());
System.out.println("Callback: " + System.currentTimeMillis());
System.out.println(Thread.currentThread().getId());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
result.getStatusCode());
}
catch (IOException e) {
e.printStackTrace(); //To change body of catch statement use File | Settings | File Templates.
}
ListenableFuture<ClientHttpResponse> listenableFuture = request.executeAsync();
listenableFuture.addCallback(new ListenableFutureCallback<ClientHttpResponse>() {
@Override
public void onSuccess(ClientHttpResponse result) {
try {
System.out.println("SUCCESS! " + result.getStatusCode());
System.out.println("Callback: " + System.currentTimeMillis());
System.out.println(Thread.currentThread().getId());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, result.getStatusCode());
}
@Override
public void onFailure(Throwable t) {
System.out.println("FAILURE: " + t);
catch (IOException ex) {
ex.printStackTrace();
}
});
}
ClientHttpResponse response = futureResponse.get();
}
@Override
public void onFailure(Throwable ex) {
System.out.println("FAILURE: " + ex);
}
});
ClientHttpResponse response = listenableFuture.get();
System.out.println("Main thread: " + System.currentTimeMillis());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
response.getStatusCode());
assertEquals("Invalid status code", HttpStatus.NOT_FOUND, response.getStatusCode());
System.out.println(Thread.currentThread().getId());
}
@Test
public void echo() throws Exception {
AsyncClientHttpRequest
request = factory.createAsyncRequest(new URI(baseUrl + "/echo"),
HttpMethod.PUT);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.PUT);
assertEquals("Invalid HTTP method", HttpMethod.PUT, request.getMethod());
String headerName = "MyHeader";
String headerValue1 = "value1";
@@ -118,19 +105,15 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
request.getHeaders().add(headerName, headerValue2);
final byte[] body = "Hello World".getBytes("UTF-8");
request.getHeaders().setContentLength(body.length);
if (request instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingRequest =
(StreamingHttpOutputMessage) request;
streamingRequest.setBody(new StreamingHttpOutputMessage.Body() {
@Override
public void writeTo(OutputStream outputStream) throws IOException {
StreamUtils.copy(body, outputStream);
}
});
StreamingHttpOutputMessage streamingRequest = (StreamingHttpOutputMessage) request;
streamingRequest.setBody(outputStream -> StreamUtils.copy(body, outputStream));
}
else {
StreamUtils.copy(body, request.getBody());
}
Future<ClientHttpResponse> futureResponse = request.executeAsync();
ClientHttpResponse response = futureResponse.get();
try {
@@ -148,19 +131,12 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
@Test(expected = IllegalStateException.class)
public void multipleWrites() throws Exception {
AsyncClientHttpRequest
request = factory.createAsyncRequest(new URI(baseUrl + "/echo"),
HttpMethod.POST);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.POST);
final byte[] body = "Hello World".getBytes("UTF-8");
if (request instanceof StreamingHttpOutputMessage) {
StreamingHttpOutputMessage streamingRequest =
(StreamingHttpOutputMessage) request;
streamingRequest.setBody(new StreamingHttpOutputMessage.Body() {
@Override
public void writeTo(OutputStream outputStream) throws IOException {
StreamUtils.copy(body, outputStream);
}
});
StreamingHttpOutputMessage streamingRequest = (StreamingHttpOutputMessage) request;
streamingRequest.setBody(outputStream -> StreamUtils.copy(body, outputStream));
}
else {
StreamUtils.copy(body, request.getBody());
@@ -178,9 +154,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
@Test(expected = UnsupportedOperationException.class)
public void headersAfterExecute() throws Exception {
AsyncClientHttpRequest
request = factory.createAsyncRequest(new URI(baseUrl + "/echo"),
HttpMethod.POST);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/echo"), HttpMethod.POST);
request.getHeaders().add("MyHeader", "value");
byte[] body = "Hello World".getBytes("UTF-8");
FileCopyUtils.copy(body, request.getBody());
@@ -208,9 +182,7 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
protected void assertHttpMethod(String path, HttpMethod method) throws Exception {
ClientHttpResponse response = null;
try {
AsyncClientHttpRequest request = factory.createAsyncRequest(
new URI(baseUrl + "/methods/" + path), method);
AsyncClientHttpRequest request = factory.createAsyncRequest(new URI(baseUrl + "/methods/" + path), method);
Future<ClientHttpResponse> futureResponse = request.executeAsync();
response = futureResponse.get();
assertEquals("Invalid response status", HttpStatus.OK, response.getStatusCode());

315
spring-web/src/test/java/org/springframework/web/client/AsyncRestTemplateIntegrationTests.java
View File

@@ -16,16 +16,12 @@
package org.springframework.web.client;
import java.io.UnsupportedEncodingException;
import java.net.URI;
import java.net.URISyntaxException;
import java.nio.charset.Charset;
import java.util.EnumSet;
import java.util.Set;
import java.util.concurrent.ExecutionException;
import java.util.concurrent.Future;
import static org.junit.Assert.*;
import org.junit.Before;
import org.junit.Test;
@@ -43,6 +39,8 @@ import org.springframework.util.MultiValueMap;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import static org.junit.Assert.*;
/**
* @author Arjen Poutsma
* @author Sebastien Deleuze
@@ -51,16 +49,17 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
private AsyncRestTemplate template;
@Before
public void createTemplate() {
template = new AsyncRestTemplate(
new HttpComponentsAsyncClientHttpRequestFactory());
template = new AsyncRestTemplate(new HttpComponentsAsyncClientHttpRequestFactory());
}
@Test
public void getEntity() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void getEntity() throws Exception {
Future<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
ResponseEntity<String> entity = futureEntity.get();
assertEquals("Invalid content", helloWorld, entity.getBody());
assertFalse("No headers", entity.getHeaders().isEmpty());
@@ -69,17 +68,17 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void multipleFutureGets() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void multipleFutureGets() throws Exception {
Future<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
futureEntity.get();
futureEntity.get();
}
@Test
public void getEntityCallback() throws ExecutionException, InterruptedException {
ListenableFuture<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void getEntityCallback() throws Exception {
ListenableFuture<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
futureEntity.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
@Override
public void onSuccess(ResponseEntity<String> entity) {
@@ -88,10 +87,9 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
assertEquals("Invalid content-type", textContentType, entity.getHeaders().getContentType());
assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
// wait till done
@@ -100,80 +98,70 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void getEntityCallbackWithLambdas() throws ExecutionException, InterruptedException {
ListenableFuture<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/{method}", String.class, "get");
public void getEntityCallbackWithLambdas() throws Exception {
ListenableFuture<ResponseEntity<String>> futureEntity =
template.getForEntity(baseUrl + "/{method}", String.class, "get");
futureEntity.addCallback((entity) -> {
assertEquals("Invalid content", helloWorld, entity.getBody());
assertFalse("No headers", entity.getHeaders().isEmpty());
assertEquals("Invalid content-type", textContentType, entity.getHeaders().getContentType());
assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
}, (t) -> fail(t.getMessage()));
}, ex -> fail(ex.getMessage()));
// wait till done
while (!futureEntity.isDone()) {
}
}
@Test
public void getNoResponse() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
futureEntity = template.getForEntity(baseUrl + "/get/nothing", String.class);
public void getNoResponse() throws Exception {
Future<ResponseEntity<String>> futureEntity = template.getForEntity(baseUrl + "/get/nothing", String.class);
ResponseEntity<String> entity = futureEntity.get();
assertNull("Invalid content", entity.getBody());
}
@Test
public void getNoContentTypeHeader()
throws UnsupportedEncodingException, ExecutionException,
InterruptedException {
Future<ResponseEntity<byte[]>>
futureEntity = template.getForEntity(baseUrl + "/get/nocontenttype",
byte[].class);
public void getNoContentTypeHeader() throws Exception {
Future<ResponseEntity<byte[]>> futureEntity = template.getForEntity(baseUrl + "/get/nocontenttype", byte[].class);
ResponseEntity<byte[]> responseEntity = futureEntity.get();
assertArrayEquals("Invalid content", helloWorld.getBytes("UTF-8"),
responseEntity.getBody());
assertArrayEquals("Invalid content", helloWorld.getBytes("UTF-8"), responseEntity.getBody());
}
@Test
public void getNoContent() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
responseFuture = template.getForEntity(baseUrl + "/status/nocontent", String.class);
public void getNoContent() throws Exception {
Future<ResponseEntity<String>> responseFuture = template.getForEntity(baseUrl + "/status/nocontent", String.class);
ResponseEntity<String> entity = responseFuture.get();
assertEquals("Invalid response code", HttpStatus.NO_CONTENT, entity.getStatusCode());
assertNull("Invalid content", entity.getBody());
}
@Test
public void getNotModified() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
responseFuture = template.getForEntity(baseUrl + "/status/notmodified",
String.class);
public void getNotModified() throws Exception {
Future<ResponseEntity<String>> responseFuture = template.getForEntity(baseUrl + "/status/notmodified", String.class);
ResponseEntity<String> entity = responseFuture.get();
assertEquals("Invalid response code", HttpStatus.NOT_MODIFIED, entity.getStatusCode());
assertNull("Invalid content", entity.getBody());
}
@Test
public void headForHeaders() throws ExecutionException, InterruptedException {
public void headForHeaders() throws Exception {
Future<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
HttpHeaders headers = headersFuture.get();
assertTrue("No Content-Type header", headers.containsKey("Content-Type"));
}
@Test
public void headForHeadersCallback() throws ExecutionException, InterruptedException {
public void headForHeadersCallback() throws Exception {
ListenableFuture<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
headersFuture.addCallback(new ListenableFutureCallback<HttpHeaders>() {
@Override
public void onSuccess(HttpHeaders result) {
assertTrue("No Content-Type header", result.containsKey("Content-Type"));
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!headersFuture.isDone()) {
@@ -181,46 +169,39 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void headForHeadersCallbackWithLambdas() throws ExecutionException, InterruptedException {
public void headForHeadersCallbackWithLambdas() throws Exception {
ListenableFuture<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
headersFuture.addCallback(result -> assertTrue("No Content-Type header",
result.containsKey("Content-Type")), t -> fail(t.getMessage()));
result.containsKey("Content-Type")), ex -> fail(ex.getMessage()));
while (!headersFuture.isDone()) {
}
}
@Test
public void postForLocation()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForLocation() throws Exception {
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
Future<URI>
locationFuture = template.postForLocation(baseUrl + "/{method}", entity,
"post");
Future<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", entity, "post");
URI location = locationFuture.get();
assertEquals("Invalid location", new URI(baseUrl + "/post/1"), location);
}
@Test
public void postForLocationCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForLocationCallback() throws Exception {
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
final URI expected = new URI(baseUrl + "/post/1");
ListenableFuture<URI>
locationFuture = template.postForLocation(baseUrl + "/{method}", entity,
"post");
ListenableFuture<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", entity, "post");
locationFuture.addCallback(new ListenableFutureCallback<URI>() {
@Override
public void onSuccess(URI result) {
assertEquals("Invalid location", expected, result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!locationFuture.isDone()) {
@@ -228,48 +209,40 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void postForLocationCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForLocationCallbackWithLambdas() throws Exception {
HttpHeaders entityHeaders = new HttpHeaders();
entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
HttpEntity<String> entity = new HttpEntity<String>(helloWorld, entityHeaders);
final URI expected = new URI(baseUrl + "/post/1");
ListenableFuture<URI>
locationFuture = template.postForLocation(baseUrl + "/{method}", entity,
"post");
locationFuture.addCallback(result -> assertEquals("Invalid location", expected, result)
, t -> fail(t.getMessage()));
ListenableFuture<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", entity, "post");
locationFuture.addCallback(result -> assertEquals("Invalid location", expected, result),
ex -> fail(ex.getMessage()));
while (!locationFuture.isDone()) {
}
}
@Test
public void postForEntity()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForEntity() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
Future<ResponseEntity<String>>
responseEntityFuture = template.postForEntity(baseUrl + "/{method}", requestEntity,
String.class, "post");
Future<ResponseEntity<String>> responseEntityFuture =
template.postForEntity(baseUrl + "/{method}", requestEntity, String.class, "post");
ResponseEntity<String> responseEntity = responseEntityFuture.get();
assertEquals("Invalid content", helloWorld, responseEntity.getBody());
}
@Test
public void postForEntityCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForEntityCallback() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
ListenableFuture<ResponseEntity<String>>
responseEntityFuture = template.postForEntity(baseUrl + "/{method}", requestEntity,
String.class, "post");
ListenableFuture<ResponseEntity<String>> responseEntityFuture =
template.postForEntity(baseUrl + "/{method}", requestEntity, String.class, "post");
responseEntityFuture.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
@Override
public void onSuccess(ResponseEntity<String> result) {
assertEquals("Invalid content", helloWorld, result.getBody());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!responseEntityFuture.isDone()) {
@@ -277,44 +250,35 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void postForEntityCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
public void postForEntityCallbackWithLambdas() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
ListenableFuture<ResponseEntity<String>>
responseEntityFuture = template.postForEntity(baseUrl + "/{method}", requestEntity,
String.class, "post");
responseEntityFuture.addCallback(result -> assertEquals("Invalid content", helloWorld, result.getBody())
, t -> fail(t.getMessage()));
ListenableFuture<ResponseEntity<String>> responseEntityFuture =
template.postForEntity(baseUrl + "/{method}", requestEntity, String.class, "post");
responseEntityFuture.addCallback(result -> assertEquals("Invalid content", helloWorld, result.getBody()),
ex -> fail(ex.getMessage()));
while (!responseEntityFuture.isDone()) {
}
}
@Test
public void put()
throws URISyntaxException, ExecutionException, InterruptedException {
public void put() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
Future<?>
responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity,
"put");
Future<?> responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity, "put");
responseEntityFuture.get();
}
@Test
public void putCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void putCallback() throws Exception {
HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
ListenableFuture<?>
responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity,
"put");
ListenableFuture<?> responseEntityFuture = template.put(baseUrl + "/{method}", requestEntity, "put");
responseEntityFuture.addCallback(new ListenableFutureCallback<Object>() {
@Override
public void onSuccess(Object result) {
assertNull(result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!responseEntityFuture.isDone()) {
@@ -322,26 +286,22 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void delete()
throws URISyntaxException, ExecutionException, InterruptedException {
public void delete() throws Exception {
Future<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.get();
}
@Test
public void deleteCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
public void deleteCallback() throws Exception {
ListenableFuture<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.addCallback(new ListenableFutureCallback<Object>() {
@Override
public void onSuccess(Object result) {
assertNull(result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!deletedFuture.isDone()) {
@@ -349,16 +309,15 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void deleteCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
public void deleteCallbackWithLambdas() throws Exception {
ListenableFuture<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.addCallback(result -> assertNull(result), t -> fail(t.getMessage()));
deletedFuture.addCallback(result -> assertNull(result), ex -> fail(ex.getMessage()));
while (!deletedFuture.isDone()) {
}
}
@Test
public void notFound() throws ExecutionException, InterruptedException {
public void notFound() throws Exception {
try {
Future<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
future.get();
@@ -372,16 +331,13 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void notFoundCallback() throws ExecutionException, InterruptedException {
ListenableFuture<?> future =
template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null,
null);
public void notFoundCallback() throws Exception {
ListenableFuture<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
future.addCallback(new ListenableFutureCallback<Object>() {
@Override
public void onSuccess(Object result) {
fail("onSuccess not expected");
}
@Override
public void onFailure(Throwable t) {
assertTrue(t instanceof HttpClientErrorException);
@@ -396,23 +352,21 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void notFoundCallbackWithLambdas() throws ExecutionException, InterruptedException {
ListenableFuture<?> future =
template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null,
null);
future.addCallback(result -> fail("onSuccess not expected"), t -> {
assertTrue(t instanceof HttpClientErrorException);
HttpClientErrorException ex = (HttpClientErrorException) t;
assertEquals(HttpStatus.NOT_FOUND, ex.getStatusCode());
assertNotNull(ex.getStatusText());
assertNotNull(ex.getResponseBodyAsString());
public void notFoundCallbackWithLambdas() throws Exception {
ListenableFuture<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
future.addCallback(result -> fail("onSuccess not expected"), ex -> {
assertTrue(ex instanceof HttpClientErrorException);
HttpClientErrorException hcex = (HttpClientErrorException) ex;
assertEquals(HttpStatus.NOT_FOUND, hcex.getStatusCode());
assertNotNull(hcex.getStatusText());
assertNotNull(hcex.getResponseBodyAsString());
});
while (!future.isDone()) {
}
}
@Test
public void serverError() throws ExecutionException, InterruptedException {
public void serverError() throws Exception {
try {
Future<Void> future = template.execute(baseUrl + "/status/server", HttpMethod.GET, null, null);
future.get();
@@ -426,21 +380,20 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void serverErrorCallback() throws ExecutionException, InterruptedException {
public void serverErrorCallback() throws Exception {
ListenableFuture<Void> future = template.execute(baseUrl + "/status/server", HttpMethod.GET, null, null);
future.addCallback(new ListenableFutureCallback<Void>() {
@Override
public void onSuccess(Void result) {
fail("onSuccess not expected");
}
@Override
public void onFailure(Throwable t) {
assertTrue(t instanceof HttpServerErrorException);
HttpServerErrorException ex = (HttpServerErrorException) t;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, ex.getStatusCode());
assertNotNull(ex.getStatusText());
assertNotNull(ex.getResponseBodyAsString());
public void onFailure(Throwable ex) {
assertTrue(ex instanceof HttpServerErrorException);
HttpServerErrorException hsex = (HttpServerErrorException) ex;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, hsex.getStatusCode());
assertNotNull(hsex.getStatusText());
assertNotNull(hsex.getResponseBodyAsString());
}
});
while (!future.isDone()) {
@@ -448,44 +401,39 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void serverErrorCallbackWithLambdas() throws ExecutionException, InterruptedException {
public void serverErrorCallbackWithLambdas() throws Exception {
ListenableFuture<Void> future = template.execute(baseUrl + "/status/server", HttpMethod.GET, null, null);
future.addCallback(result -> fail("onSuccess not expected"), t -> {
assertTrue(t instanceof HttpServerErrorException);
HttpServerErrorException ex = (HttpServerErrorException) t;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, ex.getStatusCode());
assertNotNull(ex.getStatusText());
assertNotNull(ex.getResponseBodyAsString());
future.addCallback(result -> fail("onSuccess not expected"), ex -> {
assertTrue(ex instanceof HttpServerErrorException);
HttpServerErrorException hsex = (HttpServerErrorException) ex;
assertEquals(HttpStatus.INTERNAL_SERVER_ERROR, hsex.getStatusCode());
assertNotNull(hsex.getStatusText());
assertNotNull(hsex.getResponseBodyAsString());
});
while (!future.isDone()) {
}
}
@Test
public void optionsForAllow()
throws URISyntaxException, ExecutionException, InterruptedException {
Future<Set<HttpMethod>>
allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
public void optionsForAllow() throws Exception {
Future<Set<HttpMethod>> allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
Set<HttpMethod> allowed = allowedFuture.get();
assertEquals("Invalid response",
EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS, HttpMethod.HEAD, HttpMethod.TRACE), allowed);
}
@Test
public void optionsForAllowCallback()
throws URISyntaxException, ExecutionException, InterruptedException {
ListenableFuture<Set<HttpMethod>>
allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
public void optionsForAllowCallback() throws Exception {
ListenableFuture<Set<HttpMethod>> allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
allowedFuture.addCallback(new ListenableFutureCallback<Set<HttpMethod>>() {
@Override
public void onSuccess(Set<HttpMethod> result) {
assertEquals("Invalid response", EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS,
HttpMethod.HEAD, HttpMethod.TRACE), result);
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!allowedFuture.isDone()) {
@@ -493,13 +441,11 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
@Test
public void optionsForAllowCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
ListenableFuture<Set<HttpMethod>>
allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
public void optionsForAllowCallbackWithLambdas() throws Exception{
ListenableFuture<Set<HttpMethod>> allowedFuture = template.optionsForAllow(new URI(baseUrl + "/get"));
allowedFuture.addCallback(result -> assertEquals("Invalid response",
EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS, HttpMethod.HEAD,HttpMethod.TRACE), result),
t-> fail(t.getMessage()));
ex -> fail(ex.getMessage()));
while (!allowedFuture.isDone()) {
}
}
@@ -511,8 +457,7 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
Future<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
ResponseEntity<String> response = responseFuture.get();
assertEquals("Invalid content", helloWorld, response.getBody());
}
@@ -524,17 +469,15 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
ListenableFuture<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
responseFuture.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
@Override
public void onSuccess(ResponseEntity<String> result) {
assertEquals("Invalid content", helloWorld, result.getBody());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!responseFuture.isDone()) {
@@ -548,10 +491,9 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
ListenableFuture<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity, String.class, "get");
responseFuture.addCallback(result -> assertEquals("Invalid content", helloWorld,
result.getBody()), t -> fail(t.getMessage()));
result.getBody()), ex -> fail(ex.getMessage()));
while (!responseFuture.isDone()) {
}
}
@@ -562,9 +504,8 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
requestHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
Future<ResponseEntity<Void>>
resultFuture = template.exchange(baseUrl + "/{method}", HttpMethod.POST,
requestEntity, Void.class, "post");
Future<ResponseEntity<Void>> resultFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, Void.class, "post");
ResponseEntity<Void> result = resultFuture.get();
assertEquals("Invalid location", new URI(baseUrl + "/post/1"),
result.getHeaders().getLocation());
@@ -577,21 +518,18 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
requestHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
ListenableFuture<ResponseEntity<Void>>
resultFuture = template.exchange(baseUrl + "/{method}", HttpMethod.POST,
requestEntity, Void.class, "post");
ListenableFuture<ResponseEntity<Void>> resultFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, Void.class, "post");
final URI expected =new URI(baseUrl + "/post/1");
resultFuture.addCallback(new ListenableFutureCallback<ResponseEntity<Void>>() {
@Override
public void onSuccess(ResponseEntity<Void> result) {
assertEquals("Invalid location", expected,
result.getHeaders().getLocation());
assertEquals("Invalid location", expected, result.getHeaders().getLocation());
assertFalse(result.hasBody());
}
@Override
public void onFailure(Throwable t) {
fail(t.getMessage());
public void onFailure(Throwable ex) {
fail(ex.getMessage());
}
});
while (!resultFuture.isDone()) {
@@ -604,21 +542,19 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
requestHeaders.set("MyHeader", "MyValue");
requestHeaders.setContentType(MediaType.TEXT_PLAIN);
HttpEntity<String> requestEntity = new HttpEntity<String>(helloWorld, requestHeaders);
ListenableFuture<ResponseEntity<Void>>
resultFuture = template.exchange(baseUrl + "/{method}", HttpMethod.POST,
requestEntity, Void.class, "post");
ListenableFuture<ResponseEntity<Void>> resultFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.POST, requestEntity, Void.class, "post");
final URI expected =new URI(baseUrl + "/post/1");
resultFuture.addCallback(result -> {
assertEquals("Invalid location", expected, result.getHeaders().getLocation());
assertFalse(result.hasBody());
}, t -> fail(t.getMessage()));
assertEquals("Invalid location", expected, result.getHeaders().getLocation());
assertFalse(result.hasBody());
}, ex -> fail(ex.getMessage()));
while (!resultFuture.isDone()) {
}
}
@Test
public void multipart() throws UnsupportedEncodingException, ExecutionException,
InterruptedException {
public void multipart() throws Exception {
MultiValueMap<String, Object> parts = new LinkedMultiValueMap<String, Object>();
parts.add("name 1", "value 1");
parts.add("name 2", "value 2+1");
@@ -627,8 +563,7 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
parts.add("logo", logo);
HttpEntity<MultiValueMap<String, Object>> requestBody = new HttpEntity<>(parts);
Future<URI> future =
template.postForLocation(baseUrl + "/multipart", requestBody);
Future<URI> future = template.postForLocation(baseUrl + "/multipart", requestBody);
future.get();
}