Make ListenableFuture compliant with Java 8 lambda

spring-context/src/main/java/org/springframework/scheduling/annotation/AsyncResult.java

@@ -18,8 +18,10 @@
 
 import java.util.concurrent.TimeUnit;
 
+import org.springframework.util.concurrent.FailureCallback;
 import org.springframework.util.concurrent.ListenableFuture;
 import org.springframework.util.concurrent.ListenableFutureCallback;
+import org.springframework.util.concurrent.SuccessCallback;
 
 /**
  * A pass-through {@code Future} handle that can be used for method signatures
@@ -74,7 +76,15 @@ public V get(long timeout, TimeUnit unit) {
 
 	@Override
 	public void addCallback(ListenableFutureCallback<? super V> callback) {
-		callback.onSuccess(this.value);
+		addCallback(callback, callback);
 	}
 
+	@Override
+	public void addCallback(SuccessCallback<? super V> successCallback, FailureCallback failureCallback) {
+		try {
+			successCallback.onSuccess(this.value);
+		} catch(Throwable t) {
+			failureCallback.onFailure(t);
+		}
+	}
 }

spring-core/src/main/java/org/springframework/util/concurrent/FailureCallback.java

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://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.util.concurrent;
+
+/**
+ * Defines the contract for failure callbacks that accept the result of a
+ * {@link ListenableFuture}.
+ *
+ * @author Sebastien Deleuze
+ * @since 4.1
+ */
+public interface FailureCallback {
+
+	/**
+	 * Called when the {@link ListenableFuture} fails to complete.
+	 * @param t the exception that triggered the failure
+	 */
+	void onFailure(Throwable t);
+
+}

spring-core/src/main/java/org/springframework/util/concurrent/ListenableFuture.java

@@ -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.
@@ -25,6 +25,7 @@
  * <p>Inspired by {@code com.google.common.util.concurrent.ListenableFuture}.
 
  * @author Arjen Poutsma
+ * @author Sebastien Deleuze
  * @since 4.0
  */
 public interface ListenableFuture<T> extends Future<T> {
@@ -37,4 +38,15 @@ public interface ListenableFuture<T> extends Future<T> {
 	 */
 	void addCallback(ListenableFutureCallback<? super T> callback);
 
+	/**
+	 * Registers the given success and failure callbacks to this {@code ListenableFuture}.
+	 * The callback will be triggered when this {@code Future} is complete or, if it is
+	 * already complete immediately. This is a Java 8 lambdas compliant alternative to
+	 * {@link #addCallback(ListenableFutureCallback)}.
+	 * @param successCallback the success callback to register
+	 * @param failureCallback the failure callback to register
+	 * @since 4.1
+	 */
+	void addCallback(SuccessCallback<? super T> successCallback, FailureCallback failureCallback);
+
 }

spring-core/src/main/java/org/springframework/util/concurrent/ListenableFutureAdapter.java

@@ -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,12 +44,18 @@ protected ListenableFutureAdapter(ListenableFuture<S> adaptee) {
 
 	@Override
 	public void addCallback(final ListenableFutureCallback<? super T> callback) {
+		addCallback(callback, callback);
+	}
+
+	@Override
+	public void addCallback(final SuccessCallback<? super T> successCallback,
+							final FailureCallback failureCallback) {
 		ListenableFuture<S> listenableAdaptee = (ListenableFuture<S>) getAdaptee();
 		listenableAdaptee.addCallback(new ListenableFutureCallback<S>() {
 			@Override
 			public void onSuccess(S result) {
 				try {
-					callback.onSuccess(adaptInternal(result));
+					successCallback.onSuccess(adaptInternal(result));
 				}
 				catch (ExecutionException ex) {
 					Throwable cause = ex.getCause();
@@ -62,8 +68,9 @@ public void onSuccess(S result) {
 
 			@Override
 			public void onFailure(Throwable t) {
-				callback.onFailure(t);
+				failureCallback.onFailure(t);
 			}
 		});
 	}
+
 }

spring-core/src/main/java/org/springframework/util/concurrent/ListenableFutureCallback.java

@@ -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.
@@ -21,20 +21,9 @@
  * {@link ListenableFuture}.
  *
  * @author Arjen Poutsma
+ * @author Sebastien Deleuze
  * @since 4.0
  */
-public interface ListenableFutureCallback<T> {
-
-	/**
-	 * Called when the {@link ListenableFuture} successfully completes.
-	 * @param result the result
-	 */
-	void onSuccess(T result);
-
-	/**
-	 * Called when the {@link ListenableFuture} fails to complete.
-	 * @param t the exception that triggered the failure
-	 */
-	void onFailure(Throwable t);
+public interface ListenableFutureCallback<T> extends SuccessCallback<T>, FailureCallback {
 
 }

spring-core/src/main/java/org/springframework/util/concurrent/ListenableFutureCallbackRegistry.java

@@ -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.
@@ -27,12 +27,16 @@
  * <p>Inspired by {@code com.google.common.util.concurrent.ExecutionList}.
  *
  * @author Arjen Poutsma
+ * @author Sebastien Deleuze
  * @since 4.0
  */
 public class ListenableFutureCallbackRegistry<T> {
 
-	private final Queue<ListenableFutureCallback<? super T>> callbacks =
-			new LinkedList<ListenableFutureCallback<? super T>>();
+	private final Queue<SuccessCallback<? super T>> successCallbacks =
+			new LinkedList<SuccessCallback<? super T>>();
+
+	private final Queue<FailureCallback> failureCallbacks =
+			new LinkedList<FailureCallback>();
 
 	private State state = State.NEW;
 
@@ -52,7 +56,8 @@ public void addCallback(ListenableFutureCallback<? super T> callback) {
 		synchronized (mutex) {
 			switch (state) {
 				case NEW:
-					callbacks.add(callback);
+					successCallbacks.add(callback);
+					failureCallbacks.add(callback);
 					break;
 				case SUCCESS:
 					callback.onSuccess((T)result);
@@ -64,6 +69,50 @@ public void addCallback(ListenableFutureCallback<? super T> callback) {
 		}
 	}
 
+	/**
+	 * Adds the given success callback to this registry.
+	 * @param callback the success callback to add
+	 *
+	 * @since 4.1
+	 */
+	@SuppressWarnings("unchecked")
+	public void addSuccessCallback(SuccessCallback<? super T> callback) {
+		Assert.notNull(callback, "'callback' must not be null");
+
+		synchronized (mutex) {
+			switch (state) {
+				case NEW:
+					successCallbacks.add(callback);
+					break;
+				case SUCCESS:
+					callback.onSuccess((T)result);
+					break;
+			}
+		}
+	}
+
+	/**
+	 * Adds the given failure callback to this registry.
+	 * @param callback the failure callback to add
+	 *
+	 * @since 4.1
+	 */
+	@SuppressWarnings("unchecked")
+	public void addFailureCallback(FailureCallback callback) {
+		Assert.notNull(callback, "'callback' must not be null");
+
+		synchronized (mutex) {
+			switch (state) {
+				case NEW:
+					failureCallbacks.add(callback);
+					break;
+				case FAILURE:
+					callback.onFailure((Throwable) result);
+					break;
+			}
+		}
+	}
+
 	/**
 	 * Triggers a {@link ListenableFutureCallback#onSuccess(Object)} call on all added
 	 * callbacks with the given result
@@ -74,8 +123,8 @@ public void success(T result) {
 			state = State.SUCCESS;
 			this.result = result;
 
-			while (!callbacks.isEmpty()) {
-				callbacks.poll().onSuccess(result);
+			while (!successCallbacks.isEmpty()) {
+				successCallbacks.poll().onSuccess(result);
 			}
 		}
 	}
@@ -90,8 +139,8 @@ public void failure(Throwable t) {
 			state = State.FAILURE;
 			this.result = t;
 
-			while (!callbacks.isEmpty()) {
-				callbacks.poll().onFailure(t);
+			while (!failureCallbacks.isEmpty()) {
+				failureCallbacks.poll().onFailure(t);
 			}
 		}
 	}

spring-core/src/main/java/org/springframework/util/concurrent/ListenableFutureTask.java

@@ -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.
@@ -57,6 +57,12 @@ public void addCallback(ListenableFutureCallback<? super T> callback) {
 		this.callbacks.addCallback(callback);
 	}
 
+	@Override
+	public void addCallback(SuccessCallback<? super T> successCallback, FailureCallback failureCallback) {
+		this.callbacks.addSuccessCallback(successCallback);
+		this.callbacks.addFailureCallback(failureCallback);
+	}
+
 	@Override
 	protected final void done() {
 		Throwable cause;

spring-core/src/main/java/org/springframework/util/concurrent/SettableListenableFuture.java

@@ -84,6 +84,11 @@ public void addCallback(ListenableFutureCallback<? super T> callback) {
 		this.listenableFuture.addCallback(callback);
 	}
 
+	@Override
+	public void addCallback(SuccessCallback<? super T> successCallback, FailureCallback failureCallback) {
+		this.listenableFuture.addCallback(successCallback, failureCallback);
+	}
+
 	@Override
 	public boolean cancel(boolean mayInterruptIfRunning) {
 		this.settableTask.setCancelled();

spring-core/src/main/java/org/springframework/util/concurrent/SuccessCallback.java

@@ -0,0 +1,34 @@
+/*
+ * 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.
+ * You may obtain a copy of the License at
+ *
+ *      http://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.util.concurrent;
+
+/**
+ * Defines the contract for success callbacks that accept the result of a
+ * {@link ListenableFuture}.
+ *
+ * @author Sebastien Deleuze
+ * @since 4.1
+ */
+public interface SuccessCallback<T> {
+
+	/**
+	 * Called when the {@link ListenableFuture} successfully completes.
+	 * @param result the result
+	 */
+	void onSuccess(T result);
+
+}

spring-core/src/test/java/org/springframework/util/concurrent/ListenableFutureTaskTests.java

@@ -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.
@@ -24,8 +24,13 @@
 import static org.junit.Assert.fail;
 import org.junit.Test;
 
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.verifyZeroInteractions;
+
 /**
  * @author Arjen Poutsma
+ * @author Sebastien Deleuze
  */
 public class ListenableFutureTaskTests {
 
@@ -77,6 +82,33 @@ public void onFailure(Throwable t) {
 		task.run();
 	}
 
+	@Test
+	public void successWithLambdas() throws ExecutionException, InterruptedException {
+		final String s = "Hello World";
+		Callable<String> callable = () -> s;
+		SuccessCallback<String> successCallback = mock(SuccessCallback.class);
+		FailureCallback failureCallback = mock(FailureCallback.class);
+		ListenableFutureTask<String> task = new ListenableFutureTask<>(callable);
+		task.addCallback(successCallback, failureCallback);
+		task.run();
+		verify(successCallback).onSuccess(s);
+		verifyZeroInteractions(failureCallback);
+	}
 
+	@Test
+	public void failureWithLambdas() throws ExecutionException, InterruptedException {
+		final String s = "Hello World";
+		IOException ex = new IOException(s);
+		Callable<String> callable = () -> {
+			throw ex;
+		};
+		SuccessCallback<String> successCallback = mock(SuccessCallback.class);
+		FailureCallback failureCallback = mock(FailureCallback.class);
+		ListenableFutureTask<String> task = new ListenableFutureTask<>(callable);
+		task.addCallback(successCallback, failureCallback);
+		task.run();
+		verify(failureCallback).onFailure(ex);
+		verifyZeroInteractions(successCallback);
+	}
 
 }