Added ListenableFuture interface

Added extension to Future with capabilities for registering callbacks
when the future is complete.

- Added ListenableFuture, ListenableFutureCallback,
  ListenableFutureCallbackRegistry, and ListenableFutureTask.
- Using ListenableFuture in AsyncRestOperations/AsyncRestTemplate.
- Added AsyncListenableTaskExecutor, implemented in
  SimpleAsyncTaskExecutor.
- Added FutureAdapter and ListenableFutureAdapter.

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

@@ -34,6 +34,8 @@ import org.springframework.http.HttpStatus;
 import org.springframework.http.StreamingHttpOutputMessage;
 import org.springframework.util.FileCopyUtils;
 import org.springframework.util.StreamUtils;
+import org.springframework.util.concurrent.ListenableFuture;
+import org.springframework.util.concurrent.ListenableFutureCallback;
 
 public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
 		AbstractJettyServerTestCase {
@@ -62,6 +64,47 @@ public abstract class AbstractAsyncHttpRequestFactoryTestCase extends
 				response.getStatusCode());
 	}
 
+	@Test
+	public void statusCallback() throws Exception {
+		URI uri = new URI(baseUrl + "/status/notfound");
+		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.
+					}
+				}
+
+				@Override
+				public void onFailure(Throwable t) {
+					System.out.println("FAILURE: " + t);
+				}
+			});
+
+		}
+		ClientHttpResponse response = futureResponse.get();
+		System.out.println("Main thread: " + System.currentTimeMillis());
+		assertEquals("Invalid status code", HttpStatus.NOT_FOUND,
+				response.getStatusCode());
+		System.out.println(Thread.currentThread().getId());
+	}
+
 	@Test
 	public void echo() throws Exception {
 		AsyncClientHttpRequest

spring-web/src/test/java/org/springframework/http/client/BufferedSimpleAsyncHttpRequestFactoryTests.java

@@ -20,7 +20,7 @@ import java.net.ProtocolException;
 
 import org.junit.Test;
 
-import org.springframework.core.task.AsyncTaskExecutor;
+import org.springframework.core.task.AsyncListenableTaskExecutor;
 import org.springframework.core.task.SimpleAsyncTaskExecutor;
 import org.springframework.http.HttpMethod;
 
@@ -29,7 +29,7 @@ public class BufferedSimpleAsyncHttpRequestFactoryTests extends AbstractAsyncHtt
 	@Override
 	protected AsyncClientHttpRequestFactory createRequestFactory() {
 		SimpleClientHttpRequestFactory requestFactory = new SimpleClientHttpRequestFactory();
-		AsyncTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
+		AsyncListenableTaskExecutor taskExecutor = new SimpleAsyncTaskExecutor();
 		requestFactory.setTaskExecutor(taskExecutor);
 		return requestFactory;
 	}

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

@@ -40,6 +40,8 @@ import org.springframework.http.ResponseEntity;
 import org.springframework.http.client.HttpComponentsAsyncClientHttpRequestFactory;
 import org.springframework.util.LinkedMultiValueMap;
 import org.springframework.util.MultiValueMap;
+import org.springframework.util.concurrent.ListenableFuture;
+import org.springframework.util.concurrent.ListenableFutureCallback;
 
 /** @author Arjen Poutsma */
 public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCase {
@@ -63,6 +65,37 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
 	}
 
+	@Test
+	public void multipleFutureGets() throws ExecutionException, InterruptedException {
+		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");
+		futureEntity.addCallback(new ListenableFutureCallback<ResponseEntity<String>>() {
+			@Override
+			public void onSuccess(ResponseEntity<String> entity) {
+				assertEquals("Invalid content", helloWorld, entity.getBody());
+				assertFalse("No headers", entity.getHeaders().isEmpty());
+				assertEquals("Invalid content-type", contentType, entity.getHeaders().getContentType());
+				assertEquals("Invalid status code", HttpStatus.OK, entity.getStatusCode());
+			}
+
+			@Override
+			public void onFailure(Throwable t) {
+				fail(t.getMessage());
+			}
+		});
+		// wait till done
+		while (!futureEntity.isDone()) {
+		}
+	}
+
 	@Test
 	public void getNoResponse() throws ExecutionException, InterruptedException {
 		Future<ResponseEntity<String>>
@@ -112,17 +145,25 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 	}
 
 	@Test
-	public void postForLocation()
-			throws URISyntaxException, ExecutionException, InterruptedException {
-		HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
-		Future<URI> locationFuture = template.postForLocation(baseUrl + "/{method}", requestEntity,
-				"post");
-		URI location = locationFuture.get();
-		assertEquals("Invalid location", new URI(baseUrl + "/post/1"), location);
+	public void headForHeadersCallback() throws ExecutionException, InterruptedException {
+		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());
+			}
+		});
+		while (!headersFuture.isDone()) {
+		}
 	}
 
 	@Test
-	public void postForLocationEntity()
+	public void postForLocation()
 			throws URISyntaxException, ExecutionException, InterruptedException {
 		HttpHeaders entityHeaders = new HttpHeaders();
 		entityHeaders.setContentType(new MediaType("text", "plain", Charset.forName("ISO-8859-15")));
@@ -134,6 +175,31 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		assertEquals("Invalid location", new URI(baseUrl + "/post/1"), location);
 	}
 
+	@Test
+	public void postForLocationCallback()
+			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(new ListenableFutureCallback<URI>() {
+			@Override
+			public void onSuccess(URI result) {
+				assertEquals("Invalid location", expected, result);
+			}
+
+			@Override
+			public void onFailure(Throwable t) {
+				fail(t.getMessage());
+			}
+		});
+		while (!locationFuture.isDone()) {
+		}
+	}
+
 	@Test
 	public void postForEntity()
 			throws URISyntaxException, ExecutionException, InterruptedException {
@@ -145,6 +211,28 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		assertEquals("Invalid content", helloWorld, responseEntity.getBody());
 	}
 
+	@Test
+	public void postForEntityCallback()
+			throws URISyntaxException, ExecutionException, InterruptedException {
+		HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
+		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());
+			}
+		});
+		while (!responseEntityFuture.isDone()) {
+		}
+	}
+
 	@Test
 	public void put()
 			throws URISyntaxException, ExecutionException, InterruptedException {
@@ -155,17 +243,59 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		responseEntityFuture.get();
 	}
 
+	@Test
+	public void putCallback()
+			throws URISyntaxException, ExecutionException, InterruptedException {
+		HttpEntity<String> requestEntity = new HttpEntity<>(helloWorld);
+		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());
+			}
+		});
+		while (!responseEntityFuture.isDone()) {
+		}
+	}
+
 	@Test
 	public void delete()
 			throws URISyntaxException, ExecutionException, InterruptedException {
 		Future<?> deletedFuture = template.delete(new URI(baseUrl + "/delete"));
+
 		deletedFuture.get();
 	}
 
+	@Test
+	public void deleteCallback()
+			throws URISyntaxException, ExecutionException, InterruptedException {
+		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());
+			}
+		});
+		while (!deletedFuture.isDone()) {
+		}
+	}
+
 	@Test
 	public void notFound() throws ExecutionException, InterruptedException {
 		try {
-			Future<Void> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
+			Future<?> future = template.execute(baseUrl + "/status/notfound", HttpMethod.GET, null, null);
 			future.get();
 			fail("HttpClientErrorException expected");
 		}
@@ -176,6 +306,30 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		}
 	}
 
+	@Test
+	public void notFoundCallback() throws ExecutionException, InterruptedException {
+		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);
+				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 {
@@ -190,6 +344,28 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		}
 	}
 
+	@Test
+	public void serverErrorCallback() throws ExecutionException, InterruptedException {
+		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());
+			}
+		});
+		while (!future.isDone()) {
+		}
+	}
+
 	@Test
 	public void optionsForAllow()
 			throws URISyntaxException, ExecutionException, InterruptedException {
@@ -200,6 +376,27 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 				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"));
+		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());
+			}
+		});
+		while (!allowedFuture.isDone()) {
+		}
+	}
+
 	@Test
 	@SuppressWarnings("unchecked")
 	public void exchangeGet() throws Exception {
@@ -213,6 +410,30 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		assertEquals("Invalid content", helloWorld, response.getBody());
 	}
 
+	@Test
+	@SuppressWarnings("unchecked")
+	public void exchangeGetCallback() 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(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());
+			}
+		});
+		while (!responseFuture.isDone()) {
+		}
+	}
+
 	@Test
 	public void exchangePost() throws Exception {
 		HttpHeaders requestHeaders = new HttpHeaders();
@@ -228,6 +449,34 @@ public class AsyncRestTemplateIntegrationTests extends AbstractJettyServerTestCa
 		assertFalse(result.hasBody());
 	}
 
+	@Test
+	public void exchangePostCallback() 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(new ListenableFutureCallback<ResponseEntity<Void>>() {
+			@Override
+			public void onSuccess(ResponseEntity<Void> result) {
+				assertEquals("Invalid location", expected,
+						result.getHeaders().getLocation());
+				assertFalse(result.hasBody());
+			}
+
+			@Override
+			public void onFailure(Throwable t) {
+				fail(t.getMessage());
+			}
+		});
+		while (!resultFuture.isDone()) {
+		}
+
+	}
+
 	@Test
 	public void multipart() throws UnsupportedEncodingException, ExecutionException,
 			InterruptedException {