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

Make ListenableFuture compliant with Java 8 lambda

Browse Source 
Make it possible to use a ListenableFuture with Java 8
lambda expressions, using a syntax like
listenableFuture.addCallback(() -> ..., () -> ...);

Issue: SPR-11820
This commit is contained in:
Sebastien Deleuze
2014-05-27 17:03:48 +02:00
parent 89b202029a
commit 86e8bdab6b
14 changed files with 392 additions and 41 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
spring-web/src/main/java/org/springframework/http/client/HttpComponentsAsyncClientHttpRequest.java
View File

@@ -29,12 +29,15 @@ import org.apache.http.nio.client.HttpAsyncClient;
import org.apache.http.nio.entity.NByteArrayEntity;
import org.apache.http.protocol.HttpContext;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
import org.springframework.util.concurrent.FailureCallback;
import org.springframework.util.concurrent.FutureAdapter;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.util.concurrent.ListenableFutureCallbackRegistry;
import org.springframework.util.concurrent.SuccessCallback;
import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpMethod;
/**
* {@link ClientHttpRequest} implementation that uses Apache HttpComponents HttpClient to
@@ -101,6 +104,14 @@ final class HttpComponentsAsyncClientHttpRequest extends AbstractBufferingAsyncC
this.callbacks.addCallback(callback);
}
public void addSuccessCallback(SuccessCallback<? super ClientHttpResponse> callback) {
this.callbacks.addSuccessCallback(callback);
}
public void addFailureCallback(FailureCallback callback) {
this.callbacks.addFailureCallback(callback);
}
@Override
public void completed(HttpResponse result) {
this.callbacks.success(new HttpComponentsAsyncClientHttpResponse(result));
@@ -136,6 +147,12 @@ final class HttpComponentsAsyncClientHttpRequest extends AbstractBufferingAsyncC
public void addCallback(ListenableFutureCallback<? super ClientHttpResponse> callback) {
this.callback.addCallback(callback);
}
@Override
public void addCallback(SuccessCallback<? super ClientHttpResponse> successCallback, FailureCallback failureCallback) {
this.callback.addSuccessCallback(successCallback);
this.callback.addFailureCallback(failureCallback);
}
}

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

@@ -1,5 +1,5 @@
/*
* Copyright 2002-2013 the original author or authors.
* Copyright 2002-2014 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.
@@ -44,9 +44,11 @@ import org.springframework.http.client.SimpleClientHttpRequestFactory;
import org.springframework.http.client.support.AsyncHttpAccessor;
import org.springframework.http.converter.HttpMessageConverter;
import org.springframework.util.Assert;
import org.springframework.util.concurrent.FailureCallback;
import org.springframework.util.concurrent.ListenableFuture;
import org.springframework.util.concurrent.ListenableFutureAdapter;
import org.springframework.util.concurrent.ListenableFutureCallback;
import org.springframework.util.concurrent.SuccessCallback;
import org.springframework.web.util.UriTemplate;
/**
@@ -254,15 +256,21 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
@Override
public void addCallback(final ListenableFutureCallback<? super URI> callback) {
addCallback(callback, callback);
}
@Override
public void addCallback(final SuccessCallback<? super URI> successCallback,
final FailureCallback failureCallback) {
headersFuture.addCallback(new ListenableFutureCallback<HttpHeaders>() {
@Override
public void onSuccess(HttpHeaders result) {
callback.onSuccess(result.getLocation());
successCallback.onSuccess(result.getLocation());
}
@Override
public void onFailure(Throwable t) {
callback.onFailure(t);
failureCallback.onFailure(t);
}
});
}
@@ -391,17 +399,21 @@ public class AsyncRestTemplate extends AsyncHttpAccessor implements AsyncRestOpe
return new ListenableFuture<Set<HttpMethod>>() {
@Override
public void addCallback(
final ListenableFutureCallback<? super Set<HttpMethod>> callback) {
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>() {
@Override
public void onSuccess(HttpHeaders result) {
callback.onSuccess(result.getAllow());
successCallback.onSuccess(result.getAllow());
}
@Override
public void onFailure(Throwable t) {
callback.onFailure(t);
failureCallback.onFailure(t);
}
});
}

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

@@ -45,6 +45,7 @@ import org.springframework.util.concurrent.ListenableFutureCallback;
/**
* @author Arjen Poutsma
* @author Sebastien Deleuze
*/
public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCase {
@@ -98,6 +99,21 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void getEntityCallbackWithLambdas() throws ExecutionException, InterruptedException {
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()));
// wait till done
while (!futureEntity.isDone()) {
}
}
@Test
public void getNoResponse() throws ExecutionException, InterruptedException {
Future<ResponseEntity<String>>
@@ -164,6 +180,15 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void headForHeadersCallbackWithLambdas() throws ExecutionException, InterruptedException {
ListenableFuture<HttpHeaders> headersFuture = template.headForHeaders(baseUrl + "/get");
headersFuture.addCallback(result -> assertTrue("No Content-Type header",
result.containsKey("Content-Type")), t -> fail(t.getMessage()));
while (!headersFuture.isDone()) {
}
}
@Test
public void postForLocation()
throws URISyntaxException, ExecutionException, InterruptedException {
@@ -202,6 +227,22 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void postForLocationCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
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()));
while (!locationFuture.isDone()) {
}
}
@Test
public void postForEntity()
throws URISyntaxException, ExecutionException, InterruptedException {
@@ -235,6 +276,19 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void postForEntityCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
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()));
while (!responseEntityFuture.isDone()) {
}
}
@Test
public void put()
throws URISyntaxException, ExecutionException, InterruptedException {
@@ -294,6 +348,15 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void deleteCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
ListenableFuture<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
deletedFuture.addCallback(result -> assertNull(result), t -> fail(t.getMessage()));
while (!deletedFuture.isDone()) {
}
}
@Test
public void notFound() throws ExecutionException, InterruptedException {
try {
@@ -332,6 +395,22 @@ 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());
});
while (!future.isDone()) {
}
}
@Test
public void serverError() throws ExecutionException, InterruptedException {
try {
@@ -368,6 +447,20 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void serverErrorCallbackWithLambdas() throws ExecutionException, InterruptedException {
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());
});
while (!future.isDone()) {
}
}
@Test
public void optionsForAllow()
throws URISyntaxException, ExecutionException, InterruptedException {
@@ -386,8 +479,8 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
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);
assertEquals("Invalid response", EnumSet.of(HttpMethod.GET, HttpMethod.OPTIONS,
HttpMethod.HEAD, HttpMethod.TRACE), result);
}
@Override
@@ -399,6 +492,18 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
public void optionsForAllowCallbackWithLambdas()
throws URISyntaxException, ExecutionException, InterruptedException {
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()));
while (!allowedFuture.isDone()) {
}
}
@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void exchangeGet() throws Exception {
@@ -436,6 +541,21 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
}
}
@Test
@SuppressWarnings({ "unchecked", "rawtypes" })
public void exchangeGetCallbackWithLambdas() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
requestHeaders.set("MyHeader", "MyValue");
HttpEntity<?> requestEntity = new HttpEntity(requestHeaders);
ListenableFuture<ResponseEntity<String>> responseFuture =
template.exchange(baseUrl + "/{method}", HttpMethod.GET, requestEntity,
String.class, "get");
responseFuture.addCallback(result -> assertEquals("Invalid content", helloWorld,
result.getBody()), t -> fail(t.getMessage()));
while (!responseFuture.isDone()) {
}
}
@Test
public void exchangePost() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
@@ -476,7 +596,24 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
});
while (!resultFuture.isDone()) {
}
}
@Test
public void exchangePostCallbackWithLambdas() throws Exception {
HttpHeaders requestHeaders = new HttpHeaders();
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");
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()));
while (!resultFuture.isDone()) {
}
}
@Test