* Allow Future<Void> as a reply type of the gateway request-reply operation

Author: artembilan

spring-integration-core/src/main/java/org/springframework/integration/gateway/GatewayProxyFactoryBean.java

@@ -564,15 +564,16 @@ private Object invokeGatewayMethod(MethodInvocation invocation, boolean runningO
 		}
 		boolean shouldReturnMessage =
 				Message.class.isAssignableFrom(gateway.returnType) || (!runningOnCallerThread && gateway.expectMessage);
-		boolean shouldReply = !gateway.isVoidReturn;
+		boolean oneWay =
+				void.class.isAssignableFrom(gateway.returnType) || (gateway.isVoidReturn && !runningOnCallerThread);
 		int paramCount = method.getParameterTypes().length;
 		Object response;
 		boolean hasPayloadExpression = findPayloadExpression(method);
 		if (paramCount == 0 && !hasPayloadExpression) {
-			response = receive(gateway, method, shouldReply, shouldReturnMessage);
+			response = receive(gateway, method, !oneWay, shouldReturnMessage);
 		}
 		else {
-			response = sendOrSendAndReceive(invocation, gateway, shouldReturnMessage, shouldReply);
+			response = sendOrSendAndReceive(invocation, gateway, shouldReturnMessage, !oneWay);
 		}
 		return response(gateway.returnType, shouldReturnMessage, response);
 	}
@@ -1099,7 +1100,7 @@ private boolean isVoidReturnType(ResolvableType resolvableType) {
 			if (Future.class.isAssignableFrom(this.returnType) || Mono.class.isAssignableFrom(this.returnType)) {
 				returnTypeToCheck = resolvableType.getGeneric(0).resolve(Object.class);
 			}
-			return Void.class.isAssignableFrom(returnTypeToCheck) || void.class.isAssignableFrom(returnTypeToCheck);
+			return Void.class.isAssignableFrom(returnTypeToCheck);
 		}
 
 		private void setPollable() {

spring-integration-core/src/test/java/org/springframework/integration/gateway/AsyncGatewayTests.java

@@ -33,15 +33,18 @@
 import org.springframework.beans.DirectFieldAccessor;
 import org.springframework.beans.factory.BeanFactory;
 import org.springframework.integration.MessageDispatchingException;
+import org.springframework.integration.annotation.AnnotationConstants;
 import org.springframework.integration.annotation.Gateway;
 import org.springframework.integration.annotation.GatewayHeader;
+import org.springframework.integration.annotation.MessagingGateway;
 import org.springframework.integration.channel.DirectChannel;
 import org.springframework.integration.channel.NullChannel;
 import org.springframework.integration.channel.QueueChannel;
 import org.springframework.messaging.Message;
 import org.springframework.messaging.MessageChannel;
 import org.springframework.messaging.PollableChannel;
 import org.springframework.messaging.support.ChannelInterceptor;
+import org.springframework.messaging.support.GenericMessage;
 import org.springframework.messaging.support.MessageBuilder;
 
 import reactor.core.publisher.Mono;
@@ -233,6 +236,35 @@ public void futureVoid() throws Exception {
 				.withMessageContaining("intentional dispatcher error");
 	}
 
+	@Test
+	public void futureVoidReply() throws Exception {
+		QueueChannel requestChannel = new QueueChannel();
+		CountDownLatch readyForReplyLatch = new CountDownLatch(1);
+		new Thread(() -> {
+			try {
+				Message<?> input = requestChannel.receive();
+				CompletableFuture<Void> reply = new CompletableFuture<>();
+				((MessageChannel) input.getHeaders().getReplyChannel()).send(new GenericMessage<>(reply));
+				readyForReplyLatch.await(10, TimeUnit.SECONDS);
+				reply.complete(null);
+			}
+			catch (InterruptedException e) {
+				System.err.println(e);
+			}
+		}).start();
+		GatewayProxyFactoryBean proxyFactory = new GatewayProxyFactoryBean(TestEchoService.class);
+		proxyFactory.setDefaultRequestChannel(requestChannel);
+		proxyFactory.setBeanName("testGateway");
+		proxyFactory.setBeanFactory(mock(BeanFactory.class));
+		proxyFactory.setAsyncExecutor(null);
+		proxyFactory.afterPropertiesSet();
+		TestEchoService service = (TestEchoService) proxyFactory.getObject();
+		Future<Void> f = service.sendAndReceiveFutureVoid("test");
+		readyForReplyLatch.countDown();
+		Object result = f.get(10, TimeUnit.SECONDS);
+		assertThat(result).isNull();
+	}
+
 	@Test
 	public void monoWithMessageReturned() {
 		QueueChannel requestChannel = new QueueChannel();
@@ -375,6 +407,7 @@ private interface TestEchoService {
 
 		Future<Void> asyncSendAndForget(String s);
 
+		Future<Void> sendAndReceiveFutureVoid(String s);
 		Mono<Void> monoVoid(String s);
 
 	}

src/reference/asciidoc/gateway.adoc

@@ -801,9 +801,15 @@ public interface MyGateway {
 ====
 
 But downstream exceptions are not going to be propagated back to the caller.
-To ensure asynchronous behaviour for downstream flow invocation and exception propagation to the caller, starting with version 6.0, the framework provides support for the `Future<Void>` and `Mono<Void>` return types.
+To ensure asynchronous behavior for downstream flow invocation and exception propagation to the caller, starting with version 6.0, the framework provides support for the `Future<Void>` and `Mono<Void>` return types.
 The use-case is similar to send-and-forget behavior described before for plain `void` return type, but with a difference that flow execution happens asynchronously and returned `Future` (or `Mono`) is complete with a `null` or exceptionally according to the `send` operation result.
 
+NOTE: If the `Future<Void>` is exact downstream flow reply, then an `asyncExecutor` option of the gateway must be set to null (`AnnotationConstants.NULL` for a `@MessagingGateway` configuration) and the `send` part is performed on a producer thread.
+The reply one depends on the downstream flow configuration.
+This way it is up target application to produce a `Future<Void>` reply correctly.
+The `Mono` use-case is already out of the framework threading control, so setting `asyncExecutor` to null won't make sense.
+There `Mono<Void>` as a result of the request-reply gateway operation must be configured as a `Mono<?>` return type of the gateway method.
+
 [[gateway-no-response]]
 ==== Gateway Behavior When No response Arrives