Disable requiresReply for Transformer (#10749)

* Disable `requiresReply` for Transformer

The Transformer pattern was never about letting the null result pass down into a reply message.
Or perform filter-like logic via transformation.
The service activator was always advertised for a logic to deal with a null result.
Plus, after adopting NullAway, the `AbstractMessageProcessingTransformer`
now throws `MessageTransformationException` when the processing result is null.

* Fix `MessageTransformingHandler` to disallow changing `requiresReply`
to avoid a false impression that a null result could lead to something but an exception.

More info in: https://stackoverflow.com/questions/79871975/best-practices-for-error-handling-in-synchronous-spring-integration-flows

* Add `@since 7.1` to the overridden method in the MTH

* Replace `Its` with `The service activator's` in the `transformer.adoc`

Author: artembilan

spring-integration-core/src/main/java/org/springframework/integration/config/TransformerFactoryBean.java

@@ -39,41 +39,36 @@
  */
 public class TransformerFactoryBean extends AbstractStandardMessageHandlerFactoryBean {
 
-	@SuppressWarnings("this-escape")
-	public TransformerFactoryBean() {
-		setRequiresReply(true);
-	}
-
 	@Override
 	protected MessageHandler createMethodInvokingHandler(Object targetObject, @Nullable String targetMethodName) {
 		Assert.notNull(targetObject, "targetObject must not be null");
-		Transformer transformer = null;
+		Transformer transformer;
 		if (targetObject instanceof Transformer castTransformer) {
 			transformer = castTransformer;
 		}
 		else {
-			this.checkForIllegalTarget(targetObject, targetMethodName);
+			checkForIllegalTarget(targetObject, targetMethodName);
 			if (StringUtils.hasText(targetMethodName)) {
 				transformer = new MethodInvokingTransformer(targetObject, targetMethodName);
 			}
 			else {
 				transformer = new MethodInvokingTransformer(targetObject);
 			}
 		}
-		return this.createHandler(transformer);
+		return createHandler(transformer);
 	}
 
 	@Override
 	protected MessageHandler createExpressionEvaluatingHandler(Expression expression) {
 		Transformer transformer = new ExpressionEvaluatingTransformer(expression);
-		MessageTransformingHandler handler = this.createHandler(transformer);
+		MessageTransformingHandler handler = createHandler(transformer);
 		handler.setPrimaryExpression(expression);
 		return handler;
 	}
 
 	protected MessageTransformingHandler createHandler(Transformer transformer) {
 		MessageTransformingHandler handler = new MessageTransformingHandler(transformer);
-		this.postProcessReplyProducer(handler);
+		postProcessReplyProducer(handler);
 		return handler;
 	}
 

spring-integration-core/src/main/java/org/springframework/integration/transformer/MessageTransformingHandler.java

@@ -52,7 +52,7 @@ public class MessageTransformingHandler extends AbstractReplyProducingMessageHan
 	 */
 	@SuppressWarnings("this-escape")
 	public MessageTransformingHandler() {
-		setRequiresReply(true);
+		super.setRequiresReply(true);
 	}
 
 	/**
@@ -76,6 +76,17 @@ public void setTransformer(Transformer transformer) {
 		this.transformer = transformer;
 	}
 
+	/**
+	 * Overridden to throw an {@link UnsupportedOperationException} since transformer must never return null
+	 * and {@code requiresReply == true} by default.
+	 * @param requiresReply never used.
+	 * @since 7.1
+	 */
+	@Override
+	public void setRequiresReply(boolean requiresReply) {
+		throw new UnsupportedOperationException("Transformer always requires a non-null reply payload.");
+	}
+
 	@Override
 	public String getComponentType() {
 		return (this.transformer instanceof NamedComponent namedComponent)

src/reference/antora/modules/ROOT/pages/transformer.adoc

@@ -124,7 +124,8 @@ As of Spring Integration 2.0, a message transformer's transformation method can
 Returning `null` results in an exception (a `MessageTransformationException` to be precise), because a message transformer should always be expected to transform each source message into a valid target message.
 In other words, a message transformer should not be used as a message filter, because there is a dedicated `<filter>` option for that.
 However, if you do need this type of behavior (where a component might return `null` and that should not be considered an error), you could use a service activator.
-Its `requires-reply` value is `false` by default, but that can be set to `true` in order to have exceptions thrown for `null` return values, as with the transformer.
+The service activator's `requiresReply` value is `false` by default, but that can be set to `true` in order to have exceptions thrown for `null` return values, as with the transformer.
+The transformer's `requiresReply` property cannot be modified: it is always `true` since the transformer pattern definition does not allow nulls for replies.
 
 [[transformers-and-spring-expression-language-spel]]
 == Transformers and Spring Expression Language (SpEL)

src/reference/antora/modules/ROOT/pages/whats-new.adoc

@@ -14,7 +14,13 @@ For more details, see the https://github.com/spring-projects/spring-integration/
 In general, the project has been moved to the latest dependency versions.
 Java 17 is still the baseline, but Java 25 is supported.
 
-[[x7.0-web-services-changes]]
+[[x7.1-general-changes]]
+=== General Changes
+
+The `MessageTransformingHandler.requiresReply` flag cannot be modified: an `UnsupportedOperationException` is thrown from the overridden `setRequiresReply()` method to indicate the transformer pattern cannot produce nulls for replies.
+See xref:transformer.adoc[] for more information.
+
+[[x7.1-web-services-changes]]
 === Web Services Support Changes
 
 The Web Services Outbound Gateway now can rely on the provided `WebServiceTemplate.defaultUri`.