* Use new transformWith() in tests where a deprecated API still used

* Add JavaDocs to `TransformerSpec`
* Fix generic types for `BaseIntegrationFlowDefinition.transformWith()` -
they make sense exactly on the `TransformerSpec.transformer()` only
* Apply `transformWith()` for Groovy DSL
* Introduce a new `ClassUtils.isLambda(Object candidate)`
and add a check for Groovy `Closure`
* Fix `GroovyIntegrationFlowDefinition.createConfigurerIfAny()` to propagate a `Consumer` argument
down to the `Closure`

Author: artembilan

spring-integration-core/src/main/java/org/springframework/integration/dsl/BaseIntegrationFlowDefinition.java

@@ -783,8 +783,6 @@ public <P, T> B transform(@Nullable Class<P> expectedType, GenericTransformer<P,
 	/**
 	 * Populate a {@link MessageTransformingHandler} into the endpoint with provided {@link TransformerSpec} options.
 	 * One of the 'expression', 'ref', 'refName', 'processor' or 'function' must be provided.
-	 * @param <P> the payload type - 'transform from', or {@code Message.class}.
-	 * @param <T> the target type - 'transform to'.
 	 * @return the current {@link BaseIntegrationFlowDefinition}.
 	 * @since 6.2
 	 */

spring-integration-core/src/main/java/org/springframework/integration/dsl/TransformerSpec.java

@@ -65,33 +65,67 @@ protected TransformerSpec() {
 		super(new MessageTransformingHandler());
 	}
 
+	/**
+	 * Provide an expression to use an {@link ExpressionEvaluatingTransformer} for the target handler.
+	 * @param expression the SpEL expression to use.
+	 * @return the TransformerSpec
+	 */
 	public TransformerSpec expression(String expression) {
 		return expression(PARSER.parseExpression(expression));
 	}
 
+	/**
+	 * Provide an expression to use an {@link ExpressionEvaluatingTransformer} for the target handler.
+	 * @param expression the SpEL expression to use.
+	 * @return the TransformerSpec
+	 */
 	public TransformerSpec expression(Expression expression) {
 		assertTransformerSet();
 		this.expression = expression;
 		return this;
 	}
 
+	/**
+	 * Provide a service to use a {@link MethodInvokingTransformer} for the target handler.
+	 * @param ref the service to call as a transformer POJO.
+	 * @return the TransformerSpec
+	 */
 	public TransformerSpec ref(Object ref) {
 		assertTransformerSet();
 		this.ref = ref;
 		return this;
 	}
 
+	/**
+	 * Provide a bean name to use a {@link MethodInvokingTransformer}
+	 * (based on {@link BeanNameMessageProcessor})for the target handler.
+	 * @param refName the bean name for service to call as a transformer POJO.
+	 * @return the TransformerSpec
+	 */
 	public TransformerSpec refName(String refName) {
 		assertTransformerSet();
 		this.refName = refName;
 		return this;
 	}
 
+	/**
+	 * Provide a service method name to call. Optional.
+	 * Use only together with {@link #ref(Object)} or {@link #refName(String)}.
+	 * @param method the service method name to call.
+	 * @return the TransformerSpec
+	 */
 	public TransformerSpec method(@Nullable String method) {
 		this.method = method;
 		return this;
 	}
 
+	/**
+	 * Provide a {@link GenericTransformer} as a direct delegate for {@link MessageTransformingHandler}.
+	 * @param transformer the {@link GenericTransformer} instance to use.
+	 * @param <P> the input type.
+	 * @param <T> the output type.
+	 * @return the TransformerSpec
+	 */
 	public <P, T> TransformerSpec transformer(GenericTransformer<P, T> transformer) {
 		assertTransformerSet();
 		this.transformer = transformer;
@@ -111,6 +145,11 @@ public <P> TransformerSpec expectedType(@Nullable Class<P> expectedType) {
 		return this;
 	}
 
+	/**
+	 * Provide a {@link MessageProcessorSpec} as a factory for {@link MethodInvokingTransformer} delegate.
+	 * @param processor the {@link MessageProcessorSpec} to use.
+	 * @return the TransformerSpec
+	 */
 	public TransformerSpec processor(MessageProcessorSpec<?> processor) {
 		assertTransformerSet();
 		this.processor = processor;
@@ -180,7 +219,7 @@ else if (this.transformer != null) {
 
 	private Transformer wrapToTransformerIfAny() {
 		return this.transformer instanceof Transformer ? (Transformer) this.transformer :
-				(ClassUtils.isLambda(this.transformer.getClass())
+				(ClassUtils.isLambda(this.transformer)
 						? new MethodInvokingTransformer(new LambdaMessageProcessor(this.transformer, this.expectedType))
 						: new MethodInvokingTransformer(this.transformer, ClassUtils.TRANSFORMER_TRANSFORM_METHOD));
 	}

spring-integration-core/src/main/java/org/springframework/integration/util/ClassUtils.java

@@ -1,5 +1,5 @@
 /*
- * Copyright 2002-2022 the original author or authors.
+ * Copyright 2002-2023 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.
@@ -17,6 +17,7 @@
 package org.springframework.integration.util;
 
 import java.lang.reflect.Method;
+import java.lang.reflect.Proxy;
 import java.util.HashMap;
 import java.util.Map;
 import java.util.Set;
@@ -223,6 +224,19 @@ public static Class<?> resolvePrimitiveType(Class<?> clazz) {
 		return PRIMITIVE_WRAPPER_TYPE_MAP.get(clazz);
 	}
 
+	/**
+	 * Check if object is Java, Kotlin or Groovy lambda.
+	 * @param candidate the {@link Object} to check.
+	 * @return true if object is a Java, Kotlin or Groovy lambda.
+	 * @since 6.2
+	 */
+	public static boolean isLambda(Object candidate) {
+		Class<?> aClass = candidate.getClass();
+		return isLambda(aClass) ||
+				(Proxy.isProxyClass(aClass)  // Groovy Closure is a Lambda in Java terms
+						&& Proxy.getInvocationHandler(candidate).getClass().getSimpleName().equals("ConvertedClosure"));
+	}
+
 	/**
 	 * Check if class is Java or Kotlin lambda.
 	 * @param aClass the {@link Class} to check.

spring-integration-file/src/test/java/org/springframework/integration/file/dsl/FileTests.java

@@ -448,8 +448,9 @@ void pollDirectories(File... directories) {
 						.from(Files.inboundAdapter(directory).recursive(true),
 								e -> e.poller(p -> p.fixedDelay(1000))
 										.id(directory.getName() + ".adapter"))
-						.transform(Files.toStringTransformer(),
-								e -> e.id(directory.getName() + ".transformer"))
+						.transformWith(t -> t
+								.transformer(Files.toStringTransformer())
+								.id(directory.getName() + ".transformer"))
 						.channel(this.dynamicAdaptersResult)
 						.get();
 				this.beanFactory.initializeBean(integrationFlow, directory.getName());

spring-integration-groovy/src/main/groovy/org/springframework/integration/groovy/dsl/GroovyIntegrationFlowDefinition.groovy

@@ -47,6 +47,7 @@ import org.springframework.integration.dsl.ResequencerSpec
 import org.springframework.integration.dsl.RouterSpec
 import org.springframework.integration.dsl.ScatterGatherSpec
 import org.springframework.integration.dsl.SplitterEndpointSpec
+import org.springframework.integration.dsl.TransformerSpec
 import org.springframework.integration.dsl.WireTapSpec
 import org.springframework.integration.filter.MethodInvokingSelector
 import org.springframework.integration.handler.BridgeHandler
@@ -289,8 +290,10 @@ class GroovyIntegrationFlowDefinition {
 	 * for the SpEL {@link org.springframework.expression.Expression}.
 	 * @param expression the {@code Transformer} {@link org.springframework.expression.Expression}.
 	 * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options.
+	 * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options.
 	 * @see org.springframework.integration.transformer.ExpressionEvaluatingTransformer
 	 */
+	@Deprecated(since = '6.2', forRemoval = true)
 	GroovyIntegrationFlowDefinition transform(
 			String expression,
 			@DelegatesTo(value = GenericEndpointSpec<MessageTransformingHandler>, strategy = Closure.DELEGATE_FIRST)
@@ -308,8 +311,10 @@ class GroovyIntegrationFlowDefinition {
 	 * @param service the service to use.
 	 * @param methodName the method to invoke.
 	 * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options.
+	 * @deprecated since 6.2 in favor of {@link #transform(Closure)}
 	 * @see ExpressionEvaluatingTransformer
 	 */
+	@Deprecated(since = '6.2', forRemoval = true)
 	GroovyIntegrationFlowDefinition transform(
 			Object service, String methodName = null,
 			@DelegatesTo(value = GenericEndpointSpec<MessageTransformingHandler>, strategy = Closure.DELEGATE_FIRST)
@@ -326,8 +331,10 @@ class GroovyIntegrationFlowDefinition {
 	 * In addition accept options for the integration endpoint using {@link GenericEndpointSpec}.
 	 * @param messageProcessorSpec the {@link MessageProcessorSpec} to use.
 	 * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options.
+	 * @deprecated since 6.2 in favor of {@link #transform(Closure)}
 	 * @see MethodInvokingTransformer
 	 */
+	@Deprecated(since = '6.2', forRemoval = true)
 	GroovyIntegrationFlowDefinition transform(
 			MessageProcessorSpec<?> messageProcessorSpec,
 			@DelegatesTo(value = GenericEndpointSpec<MessageTransformingHandler>, strategy = Closure.DELEGATE_FIRST)
@@ -338,6 +345,24 @@ class GroovyIntegrationFlowDefinition {
 		this
 	}
 
+	/**
+	 * Populate the {@link MessageTransformingHandler} instance for the
+	 * {@link org.springframework.integration.handler.MessageProcessor} from provided {@link MessageProcessorSpec}.
+	 * In addition accept options for the integration endpoint using {@link GenericEndpointSpec}.
+	 * @param messageProcessorSpec the {@link MessageProcessorSpec} to use.
+	 * @param transformerConfigurer the {@link Consumer} to provide integration endpoint options.
+	 * @see MethodInvokingTransformer
+	 * @since 6.2
+	 */
+	GroovyIntegrationFlowDefinition transform(
+			@DelegatesTo(value = TransformerSpec, strategy = Closure.DELEGATE_FIRST)
+			@ClosureParams(value = SimpleType.class, options = 'org.springframework.integration.dsl.TransformerSpec')
+					Closure<?> transformerConfigurer) {
+
+		this.delegate.transformWith createConfigurerIfAny(transformerConfigurer)
+		this
+	}
+
 	/**
 	 * Populate the {@link MessageTransformingHandler} instance
 	 * for the provided {@code payloadType} to convert at runtime.
@@ -367,7 +392,9 @@ class GroovyIntegrationFlowDefinition {
 	 * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options.
 	 * @param < P >                                                  the payload type - 'transform from', or {@code Message.class}.
 	 * @param < T >                                                  the target type - 'transform to'.
+	 * @deprecated since 6.2 in favor of {@link #transform(Closure)}
 	 */
+	@Deprecated(since = '6.2', forRemoval = true)
 	<P, T> GroovyIntegrationFlowDefinition transform(
 			GenericTransformer<P, T> genericTransformer,
 			@DelegatesTo(value = GenericEndpointSpec<MessageTransformingHandler>, strategy = Closure.DELEGATE_FIRST)
@@ -389,7 +416,9 @@ class GroovyIntegrationFlowDefinition {
 	 * @param endpointConfigurer the {@link Consumer} to provide integration endpoint options.
 	 * @param < P >                                                  the payload type - 'transform from', or {@code Message.class}.
 	 * @param < T >                                                  the target type - 'transform to'.
+	 * @deprecated since 6.2 in favor of {@link #transform(Closure)}
 	 */
+	@Deprecated(since = '6.2', forRemoval = true)
 	<P, T> GroovyIntegrationFlowDefinition transform(
 			Class<P> expectedType,
 			GenericTransformer<P, T> genericTransformer,
@@ -1336,7 +1365,7 @@ class GroovyIntegrationFlowDefinition {
 			return {
 				closure.delegate = it
 				closure.resolveStrategy = Closure.DELEGATE_FIRST
-				closure()
+				closure(it)
 			} as Consumer<T>
 		}
 		null

spring-integration-groovy/src/test/groovy/org/springframework/integration/groovy/dsl/test/GroovyDslTests.groovy

@@ -1,5 +1,5 @@
 /*
- * Copyright 2022 the original author or authors.
+ * Copyright 2022-2023 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.
@@ -130,11 +130,14 @@ class GroovyDslTests {
 		def publisher = Flux.just(2, 3).map { new GenericMessage<>(it) }
 
 		def integrationFlow =
-				integrationFlow(publisher)
-						{
-							transform Message<Integer>, { it.payload * 2 }, { id 'foo' }
-							channel fluxChannel
-						}
+				integrationFlow(publisher) {
+					transform {
+						it.<Message<Integer>, Integer>transformer { it.payload * 2 }
+						expectedType Message<Integer>
+						id 'foo'
+					}
+					channel fluxChannel
+				}
 
 		def registration = this.integrationFlowContext.registration(integrationFlow).register()
 
@@ -217,7 +220,7 @@ class GroovyDslTests {
 		assert groovyTestService.result.get() == 'TEST'
 	}
 
-	@Configuration
+	@Configuration(proxyBeanMethods = false)
 	@EnableIntegration
 	static class Config {
 
@@ -240,7 +243,9 @@ class GroovyDslTests {
 		requestReplyFlow() {
 			integrationFlow {
 				fluxTransform { it.map { it } }
-				transform String, { it.toUpperCase() }
+				transform {
+					transformer { it.toUpperCase() }
+				}
 			}
 		}
 
@@ -257,8 +262,13 @@ class GroovyDslTests {
 			integrationFlow Function<byte[], String>,
 					{ beanName 'functionGateway' },
 					{
-						transform Transformers.objectToString(), { id 'objectToStringTransformer' }
-						transform String, { it.toUpperCase() }
+						transform {
+							transformer Transformers.objectToString()
+							id 'objectToStringTransformer'
+						}
+						transform {
+							transformer { it.toUpperCase() }
+						}
 						split Message<?>, { it.payload }
 						split Object, { it }, { id 'splitterEndpoint' }
 						resequence()
@@ -314,11 +324,13 @@ class GroovyDslTests {
 				wireTap integrationFlow {
 					channel { queue 'wireTapChannel' }
 				}
-				delay  {
+				delay {
 					messageGroupId 'delayGroup'
 					defaultDelay 100
 				}
-				transform String, { it.toUpperCase() }
+				transform {
+					transformer { it.toUpperCase() }
+				}
 			}
 		}
 

spring-integration-webflux/src/test/java/org/springframework/integration/webflux/observation/WebFluxObservationPropagationTests.java

@@ -212,7 +212,9 @@ IntegrationFlow webFluxRequestReplyFlow(
 							.payloadExpression("#requestParams.name[0]")
 							.requestChannel(webFluxRequestChannel)
 							.id("webFluxGateway"))
-					.<String, String>transform(String::toLowerCase, e -> e.id("testTransformer"))
+					.transformWith(t -> t
+							.<String, String>transformer(String::toLowerCase)
+							.id("testTransformer"))
 					.get();
 		}