org.springframework.integration.dsl.BaseIntegrationFlowDefinition

Type Parameters:: B - the BaseIntegrationFlowDefinition implementation type.

Direct Known Subclasses:: IntegrationFlowDefinition

@IntegrationDsl
public abstract class BaseIntegrationFlowDefinition<B extends BaseIntegrationFlowDefinition<B>>
extends Object

The Builder pattern implementation for the EIP-method chain. Provides a variety of methods to populate Spring Integration components to an IntegrationFlow for the future registration in the application context.

Since:: 5.2.1
Author:: Artem Bilan, Gary Russell, Gabriele Del Prete, Tim Feuerbach
See Also:: IntegrationFlowBeanPostProcessor

Nested Class Summary

Nested Classes

Modifier and Type Class Description

static class BaseIntegrationFlowDefinition.ReplyProducerCleaner
Field Summary

Fields

Modifier and Type Field Description

protected Map<Object,String> integrationComponents

protected static SpelExpressionParser PARSER
Constructor Summary

Constructors

Modifier Constructor Description

protected BaseIntegrationFlowDefinition()

Method Summary

Modifier and Type	Method	Description
`protected B`	`_this()`
`protected B`	`addComponent(Object component)`
`protected B`	`addComponent(Object component, String beanName)`
`protected B`	`addComponents(Map<Object,String> components)`
`B`	`aggregate()`	Populate the `AggregatingMessageHandler` with default options.
`B`	`aggregate(Object aggregatorProcessor)`	A short-cut for the `aggregate((aggregator) -> aggregator.processor(aggregatorProcessor))`.
`B`	`aggregate(Consumer<AggregatorSpec> aggregator)`	Populate the `AggregatingMessageHandler` with provided options from `AggregatorSpec`.
`B`	`barrier(long timeout)`	Populate a `BarrierMessageHandler` instance for provided timeout.
`B`	`barrier(long timeout, Consumer<BarrierSpec> barrierConfigurer)`	Populate a `BarrierMessageHandler` instance for provided timeout and options from `BarrierSpec` and endpoint options from `GenericEndpointSpec`.
`B`	`bridge()`	Populate a `BridgeHandler` to the current integration flow position.
`B`	`bridge(Consumer<GenericEndpointSpec<BridgeHandler>> endpointConfigurer)`	Populate a `BridgeHandler` to the current integration flow position.
`B`	`channel(String messageChannelName)`	Populate a `MessageChannelReference` instance at the current `IntegrationFlow` chain position.
`B`	`channel(Function<Channels,MessageChannelSpec<?,?>> channels)`	Populate a `MessageChannel` instance at the current `IntegrationFlow` chain position using the `Channels` factory fluent API.
`B`	`channel(MessageChannelSpec<?,?> messageChannelSpec)`	Populate a `MessageChannel` instance at the current `IntegrationFlow` chain position using the `MessageChannelSpec` fluent API.
`B`	`channel(MessageChannel messageChannel)`	Populate the provided `MessageChannel` instance at the current `IntegrationFlow` chain position.
`protected void`	`checkReuse(MessageProducer replyHandler)`
`B`	`claimCheckIn(MessageStore messageStore)`	Populate the `MessageTransformingHandler` for the `ClaimCheckInTransformer` with provided `MessageStore`.
`B`	`claimCheckIn(MessageStore messageStore, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `MessageTransformingHandler` for the `ClaimCheckInTransformer` with provided `MessageStore`.
`B`	`claimCheckOut(MessageStore messageStore)`	Populate the `MessageTransformingHandler` for the `ClaimCheckOutTransformer` with provided `MessageStore`.
`B`	`claimCheckOut(MessageStore messageStore, boolean removeMessage)`	Populate the `MessageTransformingHandler` for the `ClaimCheckOutTransformer` with provided `MessageStore` and `removeMessage` flag.
`B`	`claimCheckOut(MessageStore messageStore, boolean removeMessage, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `MessageTransformingHandler` for the `ClaimCheckOutTransformer` with provided `MessageStore` and `removeMessage` flag.
`B`	`controlBus()`	Populate the `Control Bus` EI Pattern specific `MessageHandler` implementation at the current `IntegrationFlow` chain position.
`B`	`controlBus(Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate the `Control Bus` EI Pattern specific `MessageHandler` implementation at the current `IntegrationFlow` chain position.
`<P> B`	`convert(Class<P> payloadType)`	Populate the `MessageTransformingHandler` instance for the provided `payloadType` to convert at runtime.
`<P> B`	`convert(Class<P> payloadType, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `MessageTransformingHandler` instance for the provided `payloadType` to convert at runtime.
`protected B`	`currentComponent(Object component)`
`protected InterceptableChannel`	`currentInterceptableChannel()`	Return the current channel if it is an `InterceptableChannel`, otherwise register a new implicit `DirectChannel` in the flow and return that one.
`protected B`	`currentMessageChannel(MessageChannel currentMessageChannel)`
`B`	`delay(String groupId)`	Populate a `DelayHandler` to the current integration flow position with default options.
`B`	`delay(String groupId, Consumer<DelayerEndpointSpec> endpointConfigurer)`	Populate a `DelayHandler` to the current integration flow position.
`B`	`enrich(Consumer<EnricherSpec> enricherConfigurer)`	Populate a `ContentEnricher` to the current integration flow position with provided options.
`B`	`enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer)`	Populate a `MessageTransformingHandler` for a `HeaderEnricher` as the result of provided `Consumer`.
`B`	`enrichHeaders(Map<String,Object> headers)`	Accept a `Map` of values to be used for the `Message` header enrichment.
`B`	`enrichHeaders(Map<String,Object> headers, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Accept a `Map` of values to be used for the `Message` header enrichment.
`B`	`enrichHeaders(MapBuilder<?,String,Object> headers)`	Populate a `MessageTransformingHandler` for a `HeaderEnricher` using header values from provided `MapBuilder`.
`B`	`enrichHeaders(MapBuilder<?,String,Object> headers, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate a `MessageTransformingHandler` for a `HeaderEnricher` using header values from provided `MapBuilder`.
`protected static Object`	`extractProxyTarget(Object target)`
`<P> B`	`filter(Class<P> expectedType, GenericSelector<P> genericSelector)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the provided `GenericSelector`.
`<P> B`	`filter(Class<P> expectedType, GenericSelector<P> genericSelector, Consumer<FilterEndpointSpec> endpointConfigurer)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the provided `GenericSelector`.
`B`	`filter(Object service)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the discovered method of the provided service.
`B`	`filter(Object service, String methodName)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the method of the provided service.
`B`	`filter(Object service, String methodName, Consumer<FilterEndpointSpec> endpointConfigurer)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the method of the provided service.
`B`	`filter(String expression)`	Populate a `MessageFilter` with `MessageSelector` for the provided SpEL expression.
`B`	`filter(String expression, Consumer<FilterEndpointSpec> endpointConfigurer)`	Populate a `MessageFilter` with `MessageSelector` for the provided SpEL expression.
`B`	`filter(MessageProcessorSpec<?> messageProcessorSpec)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the `MessageProcessor` from the provided `MessageProcessorSpec`.
`B`	`filter(MessageProcessorSpec<?> messageProcessorSpec, Consumer<FilterEndpointSpec> endpointConfigurer)`	Populate a `MessageFilter` with `MethodInvokingSelector` for the `MessageProcessor` from the provided `MessageProcessorSpec`.
`B`	`fixedSubscriberChannel()`	Populate an `FixedSubscriberChannel` instance at the current `IntegrationFlow` chain position.
`B`	`fixedSubscriberChannel(String messageChannelName)`	Populate an `FixedSubscriberChannel` instance at the current `IntegrationFlow` chain position.
`<I, O> B`	`fluxTransform(Function<? super reactor.core.publisher.Flux<Message<I>>,? extends org.reactivestreams.Publisher<O>> fluxFunction)`	Populate a `FluxMessageChannel` to start a reactive processing for upstream data, wrap it to a `Flux`, apply provided `Function` via `Flux.transform(Function)` and emit the result to one more `FluxMessageChannel`, subscribed in the downstream flow.
`B`	`gateway(String requestChannel)`	Populate the "artificial" `GatewayMessageHandler` for the provided `requestChannel` to send a request with default options.
`B`	`gateway(String requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer)`	Populate the "artificial" `GatewayMessageHandler` for the provided `requestChannel` to send a request with options from `GatewayEndpointSpec`.
`B`	`gateway(IntegrationFlow flow)`	Populate the "artificial" `GatewayMessageHandler` for the provided `subflow`.
`B`	`gateway(IntegrationFlow flow, Consumer<GatewayEndpointSpec> endpointConfigurer)`	Populate the "artificial" `GatewayMessageHandler` for the provided `subflow` with options from `GatewayEndpointSpec`.
`B`	`gateway(MessageChannel requestChannel)`	Populate the "artificial" `GatewayMessageHandler` for the provided `requestChannel` to send a request with default options.
`B`	`gateway(MessageChannel requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer)`	Populate the "artificial" `GatewayMessageHandler` for the provided `requestChannel` to send a request with options from `GatewayEndpointSpec`.
`protected StandardIntegrationFlow`	`get()`
`protected Object`	`getCurrentComponent()`
`protected MessageChannel`	`getCurrentMessageChannel()`
`protected Map<Object,String>`	`getIntegrationComponents()`
`<H extends MessageHandler> B`	`handle(H messageHandler, Consumer<GenericEndpointSpec<H>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` for the provided `MessageHandler` implementation.
`<P> B`	`handle(Class<P> expectedType, GenericHandler<P> handler)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the provided `GenericHandler` at runtime.
`<P> B`	`handle(Class<P> expectedType, GenericHandler<P> handler, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the provided `GenericHandler` at runtime.
`B`	`handle(Object service)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the discovered `method` for provided `service` at runtime.
`B`	`handle(Object service, String methodName)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the `method` for provided `bean` at runtime.
`B`	`handle(Object service, String methodName, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the `method` for provided `bean` at runtime.
`B`	`handle(String beanName, String methodName)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the `method` for provided `bean` at runtime.
`B`	`handle(String beanName, String methodName, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` for the `MethodInvokingMessageProcessor` to invoke the `method` for provided `bean` at runtime.
`<H extends MessageHandler> B`	`handle(MessageHandlerSpec<?,H> messageHandlerSpec)`	Populate a `ServiceActivatingHandler` for the selected protocol specific `MessageHandler` implementation from `Namespace Factory`:
`<H extends MessageHandler> B`	`handle(MessageHandlerSpec<?,H> messageHandlerSpec, Consumer<GenericEndpointSpec<H>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` for the selected protocol specific `MessageHandler` implementation from `Namespace Factory`: In addition accept options for the integration endpoint using `GenericEndpointSpec`.
`B`	`handle(MessageProcessorSpec<?> messageProcessorSpec)`	Populate a `ServiceActivatingHandler` for the `MessageProcessor` from the provided `MessageProcessorSpec`.
`B`	`handle(MessageProcessorSpec<?> messageProcessorSpec, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` for the `MessageProcessor` from the provided `MessageProcessorSpec`.
`B`	`handle(MessageHandler messageHandler)`	Populate a `ServiceActivatingHandler` for the provided `MessageHandler` implementation.
`B`	`headerFilter(String... headersToRemove)`	Provide the `HeaderFilter` to the current `StandardIntegrationFlow`.
`B`	`headerFilter(String headersToRemove, boolean patternMatch)`	Provide the `HeaderFilter` to the current `StandardIntegrationFlow`.
`B`	`headerFilter(HeaderFilter headerFilter, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the provided `MessageTransformingHandler` for the provided `HeaderFilter`.
`B`	`intercept(ChannelInterceptor... interceptorArray)`	Add one or more `ChannelInterceptor` implementations to the current `currentMessageChannel`, in the given order, after any interceptors already registered.
`protected boolean`	`isImplicitChannel()`
`protected boolean`	`isOutputChannelRequired()`
`B`	`log()`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` logging level and `org.springframework.integration.handler.LoggingHandler` as a default logging category.
`B`	`log(String category)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided logging category and `INFO` logging level.
`<P> B`	`log(String category, Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, the provided logging category and `Function` for the log message.
`B`	`log(String category, Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` `LoggingHandler.Level` logging level, the provided logging category and SpEL expression to evaluate logger message at runtime against the request `Message`.
`<P> B`	`log(Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and `Function` for the log message.
`B`	`log(Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and SpEL expression to evaluate logger message at runtime against the request `Message`.
`B`	`log(LoggingHandler.Level level)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for provided `LoggingHandler.Level` logging level and `org.springframework.integration.handler.LoggingHandler` as a default logging category.
`B`	`log(LoggingHandler.Level level, String category)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level and logging category.
`B`	`log(LoggingHandler.Level level, String category, String logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, logging category and SpEL expression for the log message.
`<P> B`	`log(LoggingHandler.Level level, String category, Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, logging category and `Function` for the log message.
`B`	`log(LoggingHandler.Level level, String category, Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, logging category and SpEL expression for the log message.
`<P> B`	`log(LoggingHandler.Level level, Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and `Function` for the log message.
`B`	`log(LoggingHandler.Level level, Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and SpEL expression to evaluate logger message at runtime against the request `Message`.
`IntegrationFlow`	`logAndReply()`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` logging level and `org.springframework.integration.handler.LoggingHandler` as a default logging category.
`IntegrationFlow`	`logAndReply(String category)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided logging category and `INFO` logging level.
`<P> IntegrationFlow`	`logAndReply(String category, Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, the provided logging category and `Function` for the log message.
`IntegrationFlow`	`logAndReply(String category, Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` `LoggingHandler.Level` logging level, the provided logging category and SpEL expression to evaluate logger message at runtime against the request `Message`.
`<P> IntegrationFlow`	`logAndReply(Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and `Function` for the log message.
`IntegrationFlow`	`logAndReply(Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the `INFO` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and SpEL expression to evaluate logger message at runtime against the request `Message`.
`IntegrationFlow`	`logAndReply(LoggingHandler.Level level)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for provided `LoggingHandler.Level` logging level and `org.springframework.integration.handler.LoggingHandler` as a default logging category.
`IntegrationFlow`	`logAndReply(LoggingHandler.Level level, String category)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level and logging category.
`IntegrationFlow`	`logAndReply(LoggingHandler.Level level, String category, String logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, logging category and SpEL expression for the log message.
`<P> IntegrationFlow`	`logAndReply(LoggingHandler.Level level, String category, Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, logging category and `Function` for the log message.
`IntegrationFlow`	`logAndReply(LoggingHandler.Level level, String category, Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, logging category and SpEL expression for the log message.
`<P> IntegrationFlow`	`logAndReply(LoggingHandler.Level level, Function<Message<P>,Object> function)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and `Function` for the log message.
`IntegrationFlow`	`logAndReply(LoggingHandler.Level level, Expression logExpression)`	Populate a `WireTap` for the `currentMessageChannel` with the `LoggingHandler` subscriber for the provided `LoggingHandler.Level` logging level, the `org.springframework.integration.handler.LoggingHandler` as a default logging category and SpEL expression to evaluate logger message at runtime against the request `Message`.
`IntegrationFlow`	`nullChannel()`	Add a "nullChannel" bean into this flow definition as a terminal operator.
`protected MessageChannel`	`obtainInputChannelFromFlow(IntegrationFlow flow)`
`B`	`publishSubscribeChannel(Executor executor, Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)`	The `PublishSubscribeChannel` `channel(java.lang.String)` method specific implementation to allow the use of the 'subflow' subscriber capability.
`B`	`publishSubscribeChannel(Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)`	The `PublishSubscribeChannel` `channel(java.lang.String)` method specific implementation to allow the use of the 'subflow' subscriber capability.
`B`	`publishSubscribeChannel(BroadcastCapableChannel broadcastCapableChannel, Consumer<BroadcastPublishSubscribeSpec> publishSubscribeChannelConfigurer)`	The `BroadcastCapableChannel` `channel(java.lang.String)` method specific implementation to allow the use of the 'subflow' subscriber capability.
`protected <S extends ConsumerEndpointSpec<? super S, ? extends MessageHandler>> B`	`register(S endpointSpec, Consumer<S> endpointConfigurer)`
`protected B`	`registerOutputChannelIfCan(MessageChannel outputChannel)`
`B`	`resequence()`	Populate the `ResequencingMessageHandler` with default options.
`B`	`resequence(Consumer<ResequencerSpec> resequencer)`	Populate the `ResequencingMessageHandler` with provided options from `ResequencerSpec`.
`<P, T> B`	`route(Class<P> expectedType, Function<P,T> router, Consumer<RouterSpec<T,MethodInvokingRouter>> routerConfigurer)`	Populate the `MethodInvokingRouter` for provided `Function` and payload type and options from `RouterSpec`.
`<S, T> B`	`route(Class<S> expectedType, Function<S,T> router)`	Populate the `MethodInvokingRouter` for provided `Function` and payload type with default options.
`B`	`route(Object service)`	Populate the `MethodInvokingRouter` for the discovered method of the provided service and its method with default options.
`B`	`route(Object service, String methodName)`	Populate the `MethodInvokingRouter` for the method of the provided service and its method with default options.
`B`	`route(Object service, String methodName, Consumer<RouterSpec<Object,MethodInvokingRouter>> routerConfigurer)`	Populate the `MethodInvokingRouter` for the method of the provided service and its method with provided options from `RouterSpec`.
`B`	`route(String expression)`	Populate the `ExpressionEvaluatingRouter` for provided SpEL expression with default options.
`B`	`route(String beanName, String method)`	Populate the `MethodInvokingRouter` for provided bean and its method with default options.
`B`	`route(String beanName, String method, Consumer<RouterSpec<Object,MethodInvokingRouter>> routerConfigurer)`	Populate the `MethodInvokingRouter` for provided bean and its method with provided options from `RouterSpec`.
`<T> B`	`route(String expression, Consumer<RouterSpec<T,ExpressionEvaluatingRouter>> routerConfigurer)`	Populate the `ExpressionEvaluatingRouter` for provided SpEL expression with provided options from `RouterSpec`.
`B`	`route(MessageProcessorSpec<?> messageProcessorSpec)`	Populate the `MethodInvokingRouter` for the `MessageProcessor` from the provided `MessageProcessorSpec` with default options.
`B`	`route(MessageProcessorSpec<?> messageProcessorSpec, Consumer<RouterSpec<Object,MethodInvokingRouter>> routerConfigurer)`	Populate the `MethodInvokingRouter` for the `MessageProcessor` from the provided `MessageProcessorSpec` with default options.
`B`	`route(AbstractMessageRouter router)`	Populate the provided `AbstractMessageRouter` implementation to the current integration flow position.
`<R extends AbstractMessageRouter> B`	`route(R router, Consumer<GenericEndpointSpec<R>> endpointConfigurer)`	Populate the provided `AbstractMessageRouter` implementation to the current integration flow position.
`protected <R extends AbstractMessageRouter, S extends AbstractRouterSpec<? super S, R>> B`	`route(S routerSpec, Consumer<S> routerConfigurer)`
`B`	`routeByException(Consumer<RouterSpec<Class<? extends Throwable>,ErrorMessageExceptionTypeRouter>> routerConfigurer)`	Populate the `ErrorMessageExceptionTypeRouter` with options from the `RouterSpec`.
`B`	`routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer)`	Populate the `RecipientListRouter` with options from the `RecipientListRouterSpec`.
`B`	`scatterGather(Consumer<RecipientListRouterSpec> scatterer)`	Populate a `ScatterGatherHandler` to the current integration flow position based on the provided `RecipientListRouterSpec` for scattering function and default `AggregatorSpec` for gathering function.
`B`	`scatterGather(Consumer<RecipientListRouterSpec> scatterer, Consumer<AggregatorSpec> gatherer)`	Populate a `ScatterGatherHandler` to the current integration flow position based on the provided `RecipientListRouterSpec` for scattering function and `AggregatorSpec` for gathering function.
`B`	`scatterGather(Consumer<RecipientListRouterSpec> scatterer, Consumer<AggregatorSpec> gatherer, Consumer<ScatterGatherSpec> scatterGather)`	Populate a `ScatterGatherHandler` to the current integration flow position based on the provided `RecipientListRouterSpec` for scattering function and `AggregatorSpec` for gathering function.
`B`	`scatterGather(MessageChannel scatterChannel)`	Populate a `ScatterGatherHandler` to the current integration flow position based on the provided `MessageChannel` for scattering function and default `AggregatorSpec` for gathering function.
`B`	`scatterGather(MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer)`	Populate a `ScatterGatherHandler` to the current integration flow position based on the provided `MessageChannel` for scattering function and `AggregatorSpec` for gathering function.
`B`	`scatterGather(MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer, Consumer<ScatterGatherSpec> scatterGather)`	Populate a `ScatterGatherHandler` to the current integration flow position based on the provided `MessageChannel` for scattering function and `AggregatorSpec` for gathering function.
`protected void`	`setImplicitChannel(boolean implicitChannel)`
`B`	`split()`	Populate the `DefaultMessageSplitter` with default options to the current integration flow position.
`<P> B`	`split(Class<P> expectedType, Function<P,?> splitter)`	Populate the `MethodInvokingSplitter` to evaluate the provided `Function` at runtime.
`<P> B`	`split(Class<P> expectedType, Function<P,?> splitter, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)`	Populate the `MethodInvokingSplitter` to evaluate the provided `Function` at runtime.
`B`	`split(Object service)`	Populate the `MethodInvokingSplitter` to evaluate the discovered `method` of the `service` at runtime.
`B`	`split(Object service, String methodName)`	Populate the `MethodInvokingSplitter` to evaluate the provided `method` of the `service` at runtime.
`B`	`split(Object service, String methodName, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)`	Populate the `MethodInvokingSplitter` to evaluate the provided `method` of the `bean` at runtime.
`B`	`split(String expression)`	Populate the `ExpressionEvaluatingSplitter` with provided SpEL expression.
`B`	`split(String beanName, String methodName)`	Populate the `MethodInvokingSplitter` to evaluate the provided `method` of the `bean` at runtime.
`B`	`split(String beanName, String methodName, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)`	Populate the `MethodInvokingSplitter` to evaluate the provided `method` of the `bean` at runtime.
`B`	`split(String expression, Consumer<SplitterEndpointSpec<ExpressionEvaluatingSplitter>> endpointConfigurer)`	Populate the `ExpressionEvaluatingSplitter` with provided SpEL expression.
`B`	`split(Consumer<SplitterEndpointSpec<DefaultMessageSplitter>> endpointConfigurer)`	Populate the `DefaultMessageSplitter` with provided options to the current integration flow position.
`<S extends AbstractMessageSplitter> B`	`split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec)`	Populate the provided `AbstractMessageSplitter` to the current integration flow position.
`<S extends AbstractMessageSplitter> B`	`split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec, Consumer<SplitterEndpointSpec<S>> endpointConfigurer)`	Populate the provided `AbstractMessageSplitter` to the current integration flow position.
`B`	`split(MessageProcessorSpec<?> messageProcessorSpec)`	Populate the `MethodInvokingSplitter` to evaluate the `MessageProcessor` at runtime from provided `MessageProcessorSpec`.
`B`	`split(MessageProcessorSpec<?> messageProcessorSpec, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)`	Populate the `MethodInvokingSplitter` to evaluate the `MessageProcessor` at runtime from provided `MessageProcessorSpec`.
`B`	`split(AbstractMessageSplitter splitter)`	Populate the provided `AbstractMessageSplitter` to the current integration flow position.
`<S extends AbstractMessageSplitter> B`	`split(S splitter, Consumer<SplitterEndpointSpec<S>> endpointConfigurer)`	Populate the provided `AbstractMessageSplitter` to the current integration flow position.
`IntegrationFlow`	`to(IntegrationFlow other)`	Finish this flow with delegation to other `IntegrationFlow` instance.
`protected <T> org.reactivestreams.Publisher<Message<T>>`	`toReactivePublisher()`	Represent an Integration Flow as a Reactive Streams `Publisher` bean.
`protected <T> org.reactivestreams.Publisher<Message<T>>`	`toReactivePublisher(boolean autoStartOnSubscribe)`	Represent an Integration Flow as a Reactive Streams `Publisher` bean.
`<P, T> B`	`transform(Class<P> expectedType, GenericTransformer<P,T> genericTransformer)`	Populate the `MessageTransformingHandler` instance for the provided `GenericTransformer` for the specific `expectedType` to convert at runtime.
`<P, T> B`	`transform(Class<P> expectedType, GenericTransformer<P,T> genericTransformer, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `MessageTransformingHandler` instance for the provided `GenericTransformer` for the specific `expectedType` to convert at runtime.
`B`	`transform(Object service)`	Populate the `MessageTransformingHandler` for the `MethodInvokingTransformer` to invoke the discovered service method at runtime.
`B`	`transform(Object service, String methodName)`	Populate the `MessageTransformingHandler` for the `MethodInvokingTransformer` to invoke the service method at runtime.
`B`	`transform(Object service, String methodName, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `MessageTransformingHandler` for the `MethodInvokingTransformer` to invoke the service method at runtime.
`B`	`transform(String expression)`	Populate the `Transformer` EI Pattern specific `MessageHandler` implementation for the SpEL `Expression`.
`B`	`transform(String expression, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `Transformer` EI Pattern specific `MessageHandler` implementation for the SpEL `Expression`.
`B`	`transform(MessageProcessorSpec<?> messageProcessorSpec)`	Populate the `MessageTransformingHandler` instance for the `MessageProcessor` from provided `MessageProcessorSpec`.
`B`	`transform(MessageProcessorSpec<?> messageProcessorSpec, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)`	Populate the `MessageTransformingHandler` instance for the `MessageProcessor` from provided `MessageProcessorSpec`.
`B`	`trigger(String triggerActionId)`	Populate a `ServiceActivatingHandler` instance to perform `MessageTriggerAction`.
`B`	`trigger(String triggerActionId, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` instance to perform `MessageTriggerAction` and endpoint options from `GenericEndpointSpec`.
`B`	`trigger(MessageTriggerAction triggerAction)`	Populate a `ServiceActivatingHandler` instance to perform `MessageTriggerAction`.
`B`	`trigger(MessageTriggerAction triggerAction, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)`	Populate a `ServiceActivatingHandler` instance to perform `MessageTriggerAction` and endpoint options from `GenericEndpointSpec`.
`B`	`wireTap(String wireTapChannel)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.
`B`	`wireTap(String wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.
`B`	`wireTap(IntegrationFlow flow)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.
`B`	`wireTap(IntegrationFlow flow, Consumer<WireTapSpec> wireTapConfigurer)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.
`B`	`wireTap(WireTapSpec wireTapSpec)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.
`B`	`wireTap(MessageChannel wireTapChannel)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.
`B`	`wireTap(MessageChannel wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer)`	Populate the `Wire Tap` EI Pattern specific `ChannelInterceptor` implementation to the current `currentMessageChannel`.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Field Details
- PARSER
 
 protected static final SpelExpressionParser PARSER
- integrationComponents
 
 protected final Map<Object,String> integrationComponents
Constructor Details
- BaseIntegrationFlowDefinition
  
  protected BaseIntegrationFlowDefinition()
Method Details
- addComponent
 
 protected B addComponent(Object component)
- addComponent
 
 protected B addComponent(Object component, @Nullable String beanName)
- addComponents
 
 protected B addComponents(Map<Object,String> components)
- getIntegrationComponents
 
 protected Map<Object,String> getIntegrationComponents()
- currentComponent
 
 protected B currentComponent(@Nullable Object component)
- getCurrentComponent
 
 @Nullable protected Object getCurrentComponent()
- currentMessageChannel
 
 protected B currentMessageChannel(@Nullable MessageChannel currentMessageChannel)
- getCurrentMessageChannel
 
 @Nullable protected MessageChannel getCurrentMessageChannel()
- currentInterceptableChannel
 
 protected InterceptableChannel currentInterceptableChannel()
 
 Return the current channel if it is an InterceptableChannel, otherwise register a new implicit DirectChannel in the flow and return that one.
 
 Returns:
 
 the current channel after the operation
- setImplicitChannel
 
 protected void setImplicitChannel(boolean implicitChannel)
- isImplicitChannel
 
 protected boolean isImplicitChannel()
- fixedSubscriberChannel
 
 public B fixedSubscriberChannel()
 
 Populate an FixedSubscriberChannel instance at the current IntegrationFlow chain position. The 'bean name' will be generated during the bean registration phase.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- fixedSubscriberChannel
 
 public B fixedSubscriberChannel(String messageChannelName)
 
 Populate an FixedSubscriberChannel instance at the current IntegrationFlow chain position. The provided messageChannelName is used for the bean registration.
 
 Parameters:
 
 messageChannelName - the bean name to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- channel
 
 public B channel(String messageChannelName)
 
 Populate a MessageChannelReference instance at the current IntegrationFlow chain position. The provided messageChannelName is used for the bean registration (DirectChannel), if there is no such a bean in the application context. Otherwise the existing MessageChannel bean is used to wire integration endpoints.
 
 Parameters:
 
 messageChannelName - the bean name to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- channel
 
 public B channel(MessageChannelSpec<?,?> messageChannelSpec)
 
 Populate a MessageChannel instance at the current IntegrationFlow chain position using the MessageChannelSpec fluent API.
 
 Parameters:
 
 messageChannelSpec - the MessageChannelSpec to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MessageChannels
- channel
 
 public B channel(MessageChannel messageChannel)
 
 Populate the provided MessageChannel instance at the current IntegrationFlow chain position. The messageChannel can be an existing bean, or fresh instance, in which case the IntegrationFlowBeanPostProcessor will populate it as a bean with a generated name.
 
 Parameters:
 
 messageChannel - the MessageChannel to populate.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- channel
 
 public B channel(Function<Channels,MessageChannelSpec<?,?>> channels)
 
 Populate a MessageChannel instance at the current IntegrationFlow chain position using the Channels factory fluent API.
 
 Parameters:
 
 channels - the Function to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- publishSubscribeChannel
 
 public B publishSubscribeChannel(Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)
 
 The PublishSubscribeChannel channel(java.lang.String) method specific implementation to allow the use of the 'subflow' subscriber capability.
 
 Parameters:
 
 publishSubscribeChannelConfigurer - the Consumer to specify PublishSubscribeSpec options including 'subflow' definition.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- publishSubscribeChannel
 
 public B publishSubscribeChannel(Executor executor, Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)
 
 The PublishSubscribeChannel channel(java.lang.String) method specific implementation to allow the use of the 'subflow' subscriber capability. Use the provided Executor for the target subscribers.
 
 Parameters:
 
 executor - the Executor to use.
 
 publishSubscribeChannelConfigurer - the Consumer to specify PublishSubscribeSpec options including 'subflow' definition.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- publishSubscribeChannel
 
 public B publishSubscribeChannel(BroadcastCapableChannel broadcastCapableChannel, Consumer<BroadcastPublishSubscribeSpec> publishSubscribeChannelConfigurer)
 
 The BroadcastCapableChannel channel(java.lang.String) method specific implementation to allow the use of the 'subflow' subscriber capability.
 
 Parameters:
 
 broadcastCapableChannel - the BroadcastCapableChannel to subscriber sub-flows to.
 
 publishSubscribeChannelConfigurer - the Consumer to specify BroadcastPublishSubscribeSpec 'subflow' definitions.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 Since:
 
 5.3
- wireTap
 
 public B wireTap(IntegrationFlow flow)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel. It is useful when an implicit MessageChannel is used between endpoints:
 .filter("World"::equals) .wireTap(sf -> sf.<String, String>transform(String::toUpperCase)) .handle(p -> process(p))
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 flow - the IntegrationFlow for wire-tap subflow as an alternative to the wireTapChannel.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- wireTap
 
 public B wireTap(String wireTapChannel)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel. It is useful when an implicit MessageChannel is used between endpoints:
 f -> f.wireTap("tapChannel") .handle(p -> process(p))
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 wireTapChannel - the MessageChannel bean name to wire-tap.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- wireTap
 
 public B wireTap(MessageChannel wireTapChannel)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel. It is useful when an implicit MessageChannel is used between endpoints:
 .transform("payload") .wireTap(tapChannel()) .channel("foo")
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 wireTapChannel - the MessageChannel to wire-tap.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- wireTap
 
 public B wireTap(IntegrationFlow flow, Consumer<WireTapSpec> wireTapConfigurer)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel. It is useful when an implicit MessageChannel is used between endpoints:
 .transform("payload") .wireTap(sf -> sf.<String, String>transform(String::toUpperCase), wt -> wt.selector("payload == 'foo'")) .channel("foo")
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 flow - the IntegrationFlow for wire-tap subflow as an alternative to the wireTapChannel.
 
 wireTapConfigurer - the Consumer to accept options for the WireTap.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- obtainInputChannelFromFlow
 
 protected MessageChannel obtainInputChannelFromFlow(IntegrationFlow flow)
- wireTap
 
 public B wireTap(String wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel. It is useful when an implicit MessageChannel is used between endpoints:
 .transform("payload") .wireTap("tapChannel", wt -> wt.selector(m -> m.getPayload().equals("foo"))) .channel("foo")
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 wireTapChannel - the MessageChannel bean name to wire-tap.
 
 wireTapConfigurer - the Consumer to accept options for the WireTap.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- wireTap
 
 public B wireTap(MessageChannel wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel. It is useful when an implicit MessageChannel is used between endpoints:
 .transform("payload") .wireTap(tapChannel(), wt -> wt.selector(m -> m.getPayload().equals("foo"))) .channel("foo")
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 wireTapChannel - the MessageChannel to wire-tap.
 
 wireTapConfigurer - the Consumer to accept options for the WireTap.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- wireTap
 
 public B wireTap(WireTapSpec wireTapSpec)
 Populate the Wire Tap EI Pattern specific ChannelInterceptor implementation to the current currentMessageChannel.
 It is useful when an implicit MessageChannel is used between endpoints:
 .transform("payload") .wireTap(new WireTap(tapChannel()).selector(m -> m.getPayload().equals("foo"))) .channel("foo")
 This method can be used after any channel(java.lang.String) for explicit MessageChannel, but with the caution do not impact existing ChannelInterceptors.
 Parameters:
 
 wireTapSpec - the WireTapSpec to use.
 When this EIP-method is used in the end of flow, it appends nullChannel to terminate flow properly, Otherwise Dispatcher has no subscribers exception is thrown for implicit DirectChannel.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- controlBus
 
 public B controlBus()
 
 Populate the Control Bus EI Pattern specific MessageHandler implementation at the current IntegrationFlow chain position.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ExpressionCommandMessageProcessor
- controlBus
 
 public B controlBus(Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 
 Populate the Control Bus EI Pattern specific MessageHandler implementation at the current IntegrationFlow chain position.
 
 Parameters:
 
 endpointConfigurer - the Consumer to accept integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ExpressionCommandMessageProcessor, GenericEndpointSpec
- transform
 
 public B transform(String expression)
 
 Populate the Transformer EI Pattern specific MessageHandler implementation for the SpEL Expression.
 
 Parameters:
 
 expression - the Transformer Expression.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ExpressionEvaluatingTransformer
- transform
 
 public B transform(String expression, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the Transformer EI Pattern specific MessageHandler implementation for the SpEL Expression.
 
 Parameters:
 
 expression - the Transformer Expression.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ExpressionEvaluatingTransformer
- transform
 
 public B transform(Object service)
 
 Populate the MessageTransformingHandler for the MethodInvokingTransformer to invoke the discovered service method at runtime.
 
 Parameters:
 
 service - the service to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ExpressionEvaluatingTransformer
- transform
 
 public B transform(Object service, String methodName)
 
 Populate the MessageTransformingHandler for the MethodInvokingTransformer to invoke the service method at runtime.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingTransformer
- transform
 
 public B transform(Object service, String methodName, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the MessageTransformingHandler for the MethodInvokingTransformer to invoke the service method at runtime.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ExpressionEvaluatingTransformer
- transform
 
 public B transform(MessageProcessorSpec<?> messageProcessorSpec)
 Populate the MessageTransformingHandler instance for the MessageProcessor from provided MessageProcessorSpec.
 .transform(Scripts.script("classpath:myScript.py").variable("foo", bar()))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingTransformer
- transform
 
 public B transform(MessageProcessorSpec<?> messageProcessorSpec, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 Populate the MessageTransformingHandler instance for the MessageProcessor from provided MessageProcessorSpec. In addition accept options for the integration endpoint using GenericEndpointSpec.
 .transform(Scripts.script("classpath:myScript.py").variable("foo", bar()), e -> e.autoStartup(false))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingTransformer
- convert
 
 public B convert(Class payloadType)
 
 Populate the MessageTransformingHandler instance for the provided payloadType to convert at runtime.
 
 Type Parameters:
 
 P - the payload type - 'convert to'.
 
 Parameters:
 
 payloadType - the Class for expected payload type.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 Since:
 
 5.1
 
 See Also:
 
 MethodInvokingTransformer, LambdaMessageProcessor
- transform
 
 public <P, T> B transform(Class expectedType, GenericTransformer<P,T> genericTransformer)
 
 Populate the MessageTransformingHandler instance for the provided GenericTransformer for the specific expectedType to convert at runtime.
 
 Type Parameters:
 
 P - the payload type - 'transform from' or Message.class.
 
 T - the target type - 'transform to'.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the transformer. Conversion to this type will be attempted, if necessary.
 
 genericTransformer - the GenericTransformer to populate.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingTransformer, LambdaMessageProcessor
- convert
 
 public B convert(Class payloadType, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the MessageTransformingHandler instance for the provided payloadType to convert at runtime. In addition, accept options for the integration endpoint using GenericEndpointSpec.
 
 Type Parameters:
 
 P - the payload type - 'transform to'.
 
 Parameters:
 
 payloadType - the Class for expected payload type.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 Since:
 
 5.1
 
 See Also:
 
 MethodInvokingTransformer, LambdaMessageProcessor, GenericEndpointSpec
- transform
 
 public <P, T> B transform(Class expectedType, GenericTransformer<P,T> genericTransformer, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the MessageTransformingHandler instance for the provided GenericTransformer for the specific expectedType to convert at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Type Parameters:
 
 P - the payload type - 'transform from', or Message.class.
 
 T - the target type - 'transform to'.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the transformer. Conversion to this type will be attempted, if necessary.
 
 genericTransformer - the GenericTransformer to populate.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingTransformer, LambdaMessageProcessor, GenericEndpointSpec
- filter
 
 public B filter(String expression)
 
 Populate a MessageFilter with MessageSelector for the provided SpEL expression.
 
 Parameters:
 
 expression - the SpEL expression.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- filter
 
 public B filter(String expression, Consumer<FilterEndpointSpec> endpointConfigurer)
 Populate a MessageFilter with MessageSelector for the provided SpEL expression. In addition accept options for the integration endpoint using FilterEndpointSpec:
 .filter("payload.hot"), e -> e.autoStartup(false))
 Parameters:
 
 expression - the SpEL expression.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 FilterEndpointSpec
- filter
 
 public B filter(Object service)
 
 Populate a MessageFilter with MethodInvokingSelector for the discovered method of the provided service.
 
 Parameters:
 
 service - the service to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingSelector
- filter
 
 public B filter(Object service, String methodName)
 
 Populate a MessageFilter with MethodInvokingSelector for the method of the provided service.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingSelector
- filter
 
 public B filter(Object service, String methodName, Consumer<FilterEndpointSpec> endpointConfigurer)
 
 Populate a MessageFilter with MethodInvokingSelector for the method of the provided service.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingSelector
- filter
 
 public B filter(MessageProcessorSpec<?> messageProcessorSpec)
 Populate a MessageFilter with MethodInvokingSelector for the MessageProcessor from the provided MessageProcessorSpec.
 .filter(Scripts.script(scriptResource).lang("ruby"))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- filter
 
 public B filter(MessageProcessorSpec<?> messageProcessorSpec, Consumer<FilterEndpointSpec> endpointConfigurer)
 Populate a MessageFilter with MethodInvokingSelector for the MessageProcessor from the provided MessageProcessorSpec. In addition accept options for the integration endpoint using FilterEndpointSpec.
 .filter(Scripts.script(scriptResource).lang("ruby"), e -> e.autoStartup(false))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- filter
 
 public B filter(Class expectedType, GenericSelector genericSelector)
 Populate a MessageFilter with MethodInvokingSelector for the provided GenericSelector. Typically, used with a Java 8 Lambda expression:
 .filter(Date.class, p -> p.after(new Date()))
 Type Parameters:
 
 P - the source payload type or Message.class.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the selector. Conversion to this type will be attempted, if necessary.
 
 genericSelector - the GenericSelector to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor
- filter
 
 public B filter(Class expectedType, GenericSelector genericSelector, Consumer<FilterEndpointSpec> endpointConfigurer)
 Populate a MessageFilter with MethodInvokingSelector for the provided GenericSelector. In addition, accept options for the integration endpoint using FilterEndpointSpec. Typically, used with a Java 8 Lambda expression:
 .filter(Date.class, p -> p.after(new Date()), e -> e.autoStartup(false))
 Type Parameters:
 
 P - the source payload type or Message.class.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the selector. Conversion to this type will be attempted, if necessary.
 
 genericSelector - the GenericSelector to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor, FilterEndpointSpec
- handle
 
 public <H extends MessageHandler> B handle(MessageHandlerSpec<?,H> messageHandlerSpec)
 Populate a ServiceActivatingHandler for the selected protocol specific MessageHandler implementation from Namespace Factory:
 .handle(Amqp.outboundAdapter(this.amqpTemplate).routingKeyExpression("headers.routingKey"))
 .
 Type Parameters:
 
 H - the target MessageHandler type.
 
 Parameters:
 
 messageHandlerSpec - the MessageHandlerSpec to configure protocol specific MessageHandler.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(MessageHandler messageHandler)
 Populate a ServiceActivatingHandler for the provided MessageHandler implementation. Can be used as Java 8 Lambda expression:
 .handle(m -> logger.info(m.getPayload())
 Parameters:
 
 messageHandler - the MessageHandler to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(String beanName, String methodName)
 
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the method for provided bean at runtime.
 
 Parameters:
 
 beanName - the bean name to use.
 
 methodName - the method to invoke.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(String beanName, String methodName, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the method for provided bean at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 beanName - the bean name to use.
 
 methodName - the method to invoke.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(Object service)
 
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the discovered method for provided service at runtime.
 
 Parameters:
 
 service - the service object to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(Object service, String methodName)
 
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the method for provided bean at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 service - the service object to use.
 
 methodName - the method to invoke.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(Object service, String methodName, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the method for provided bean at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 service - the service object to use.
 
 methodName - the method to invoke.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(Class expectedType, GenericHandler handler)
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the provided GenericHandler at runtime. Typically, used with a Java 8 Lambda expression:
 .handle(Integer.class, (p, h) -> p / 2)
 Type Parameters:
 
 P - the payload type to expect, or Message.class.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the handler. Conversion to this type will be attempted, if necessary.
 
 handler - the handler to invoke.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor
- handle
 
 public B handle(Class expectedType, GenericHandler handler, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 Populate a ServiceActivatingHandler for the MethodInvokingMessageProcessor to invoke the provided GenericHandler at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec. Typically used with a Java 8 Lambda expression:
 .handle(Integer.class, (p, h) -> p / 2, e -> e.autoStartup(false))
 Type Parameters:
 
 P - the payload type to expect or Message.class.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the handler. Conversion to this type will be attempted, if necessary.
 
 handler - the handler to invoke.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor
- handle
 
 public B handle(MessageProcessorSpec<?> messageProcessorSpec)
 Populate a ServiceActivatingHandler for the MessageProcessor from the provided MessageProcessorSpec.
 .handle(Scripts.script("classpath:myScript.ruby"))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public B handle(MessageProcessorSpec<?> messageProcessorSpec, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 Populate a ServiceActivatingHandler for the MessageProcessor from the provided MessageProcessorSpec. In addition accept options for the integration endpoint using GenericEndpointSpec.
 .handle(Scripts.script("classpath:myScript.ruby"), e -> e.autoStartup(false))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public <H extends MessageHandler> B handle(MessageHandlerSpec<?,H> messageHandlerSpec, Consumer<GenericEndpointSpec<H>> endpointConfigurer)
 Populate a ServiceActivatingHandler for the selected protocol specific MessageHandler implementation from Namespace Factory: In addition accept options for the integration endpoint using GenericEndpointSpec. Typically used with a Java 8 Lambda expression:
 .handle(Amqp.outboundAdapter(this.amqpTemplate).routingKeyExpression("headers.routingKey"), e -> e.autoStartup(false))
 Type Parameters:
 
 H - the MessageHandler type.
 
 Parameters:
 
 messageHandlerSpec - the MessageHandlerSpec to configure protocol specific MessageHandler.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- handle
 
 public <H extends MessageHandler> B handle(H messageHandler, Consumer<GenericEndpointSpec<H>> endpointConfigurer)
 Populate a ServiceActivatingHandler for the provided MessageHandler implementation. In addition accept options for the integration endpoint using GenericEndpointSpec. Can be used as Java 8 Lambda expression:
 .handle(m -> logger.info(m.getPayload()), e -> e.autoStartup(false))
 Type Parameters:
 
 H - the MessageHandler type.
 
 Parameters:
 
 messageHandler - the MessageHandler to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- bridge
 
 public B bridge()
 
 Populate a BridgeHandler to the current integration flow position.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 bridge(Consumer)
- bridge
 
 public B bridge(Consumer<GenericEndpointSpec<BridgeHandler>> endpointConfigurer)
 Populate a BridgeHandler to the current integration flow position. Typically used with a Java 8 Lambda expression:
 .bridge(s -> s.poller(Pollers.fixedDelay(100)) .autoStartup(false) .id("priorityChannelBridge"))
 Parameters:
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 GenericEndpointSpec
- delay
 
 public B delay(String groupId)
 
 Populate a DelayHandler to the current integration flow position with default options.
 
 Parameters:
 
 groupId - the groupId for delayed messages in the MessageGroupStore.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- delay
 
 public B delay(String groupId, Consumer<DelayerEndpointSpec> endpointConfigurer)
 
 Populate a DelayHandler to the current integration flow position.
 
 Parameters:
 
 groupId - the groupId for delayed messages in the MessageGroupStore.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 DelayerEndpointSpec
- enrich
 
 public B enrich(Consumer<EnricherSpec> enricherConfigurer)
 Populate a ContentEnricher to the current integration flow position with provided options. Typically used with a Java 8 Lambda expression:
 .enrich(e -> e.requestChannel("enrichChannel") .requestPayload(Message::getPayload) .shouldClonePayload(false) .autoStartup(false) .<Map<String, String>>headerFunction("foo", m -> m.getPayload().get("name")))
 Parameters:
 
 enricherConfigurer - the Consumer to provide ContentEnricher options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 EnricherSpec
- enrichHeaders
 
 public B enrichHeaders(MapBuilder<?,String,Object> headers)
 Populate a MessageTransformingHandler for a HeaderEnricher using header values from provided MapBuilder. Can be used together with Namespace Factory:
 .enrichHeaders(Mail.headers() .subjectFunction(m -> "foo") .from("foo@bar") .toFunction(m -> new String[] {"bar@baz"}))
 Parameters:
 
 headers - the MapBuilder to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- enrichHeaders
 
 public B enrichHeaders(MapBuilder<?,String,Object> headers, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 Populate a MessageTransformingHandler for a HeaderEnricher using header values from provided MapBuilder. In addition accept options for the integration endpoint using GenericEndpointSpec. Can be used together with Namespace Factory:
 .enrichHeaders(Mail.headers() .subjectFunction(m -> "foo") .from("foo@bar") .toFunction(m -> new String[] {"bar@baz"}), e -> e.autoStartup(false))
 Parameters:
 
 headers - the MapBuilder to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 GenericEndpointSpec
- enrichHeaders
 
 public B enrichHeaders(Map<String,Object> headers)
 
 Accept a Map of values to be used for the Message header enrichment. values can apply an Expression to be evaluated against a request Message.
 
 Parameters:
 
 headers - the Map of headers to enrich.
 
 Returns:
 
 the current IntegrationFlowDefinition.
- enrichHeaders
 
 public B enrichHeaders(Map<String,Object> headers, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Accept a Map of values to be used for the Message header enrichment. values can apply an Expression to be evaluated against a request Message.
 
 Parameters:
 
 headers - the Map of headers to enrich.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 GenericEndpointSpec
- enrichHeaders
 
 public B enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer)
 Populate a MessageTransformingHandler for a HeaderEnricher as the result of provided Consumer. Typically used with a Java 8 Lambda expression:
 .enrichHeaders(h -> h.header(FileHeaders.FILENAME, "foo.sitest") .header("directory", new File(tmpDir, "fileWritingFlow")))
 Parameters:
 
 headerEnricherConfigurer - the Consumer to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 HeaderEnricherSpec
- split
 
 public B split()
 
 Populate the DefaultMessageSplitter with default options to the current integration flow position.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- split
 
 public B split(Consumer<SplitterEndpointSpec<DefaultMessageSplitter>> endpointConfigurer)
 Populate the DefaultMessageSplitter with provided options to the current integration flow position. Typically used with a Java 8 Lambda expression:
 .split(s -> s.applySequence(false).delimiters(","))
 Parameters:
 
 endpointConfigurer - the Consumer to provide integration endpoint options and for DefaultMessageSplitter.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(String expression)
 
 Populate the ExpressionEvaluatingSplitter with provided SpEL expression.
 
 Parameters:
 
 expression - the splitter SpEL expression. and for ExpressionEvaluatingSplitter.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(String expression, Consumer<SplitterEndpointSpec<ExpressionEvaluatingSplitter>> endpointConfigurer)
 
 Populate the ExpressionEvaluatingSplitter with provided SpEL expression.
 
 Parameters:
 
 expression - the splitter SpEL expression.
 
 endpointConfigurer - the Consumer to provide integration endpoint options and for ExpressionEvaluatingSplitter.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(Object service)
 
 Populate the MethodInvokingSplitter to evaluate the discovered method of the service at runtime.
 
 Parameters:
 
 service - the service to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingSplitter
- split
 
 public B split(Object service, String methodName)
 
 Populate the MethodInvokingSplitter to evaluate the provided method of the service at runtime.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingSplitter
- split
 
 public B split(Object service, String methodName, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)
 
 Populate the MethodInvokingSplitter to evaluate the provided method of the bean at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke.
 
 endpointConfigurer - the Consumer to provide integration endpoint options and for MethodInvokingSplitter.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec, MethodInvokingSplitter
- split
 
 public B split(String beanName, String methodName)
 
 Populate the MethodInvokingSplitter to evaluate the provided method of the bean at runtime.
 
 Parameters:
 
 beanName - the bean name to use.
 
 methodName - the method to invoke at runtime.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- split
 
 public B split(String beanName, String methodName, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)
 
 Populate the MethodInvokingSplitter to evaluate the provided method of the bean at runtime. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 beanName - the bean name to use.
 
 methodName - the method to invoke at runtime.
 
 endpointConfigurer - the Consumer to provide integration endpoint options and for MethodInvokingSplitter.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(MessageProcessorSpec<?> messageProcessorSpec)
 Populate the MethodInvokingSplitter to evaluate the MessageProcessor at runtime from provided MessageProcessorSpec.
 .split(Scripts.script("classpath:myScript.ruby"))
 Parameters:
 
 messageProcessorSpec - the splitter MessageProcessorSpec.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(MessageProcessorSpec<?> messageProcessorSpec, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)
 Populate the MethodInvokingSplitter to evaluate the MessageProcessor at runtime from provided MessageProcessorSpec. In addition accept options for the integration endpoint using GenericEndpointSpec.
 .split(Scripts.script(myScriptResource).lang("groovy").refreshCheckDelay(1000), , e -> e.applySequence(false))
 Parameters:
 
 messageProcessorSpec - the splitter MessageProcessorSpec.
 
 endpointConfigurer - the Consumer to provide integration endpoint options and for MethodInvokingSplitter.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(Class expectedType, Function<P,?> splitter)
 Populate the MethodInvokingSplitter to evaluate the provided Function at runtime. Typically, used with a Java 8 Lambda expression:
 .split(String.class, p -> jdbcTemplate.execute("SELECT * from FOO", (PreparedStatement ps) -> new ResultSetIterator<Foo>(ps.executeQuery(), (rs, rowNum) -> new Foo(rs.getInt(1), rs.getString(2)))))
 Type Parameters:
 
 P - the payload type or Message.class.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the splitter. Conversion to this type will be attempted, if necessary.
 
 splitter - the splitter Function.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor
- split
 
 public B split(Class expectedType, Function<P,?> splitter, Consumer<SplitterEndpointSpec<MethodInvokingSplitter>> endpointConfigurer)
 Populate the MethodInvokingSplitter to evaluate the provided Function at runtime. In addition, accept options for the integration endpoint using GenericEndpointSpec. Typically, used with a Java 8 Lambda expression:
 .split(String.class, p -> jdbcTemplate.execute("SELECT * from FOO", (PreparedStatement ps) -> new ResultSetIterator<Foo>(ps.executeQuery(), (rs, rowNum) -> new Foo(rs.getInt(1), rs.getString(2)))) , e -> e.applySequence(false))
 Type Parameters:
 
 P - the payload type or Message.class.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the splitter. Conversion to this type will be attempted, if necessary.
 
 splitter - the splitter Function.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor, SplitterEndpointSpec
- split
 
 public <S extends AbstractMessageSplitter> B split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec)
 
 Populate the provided AbstractMessageSplitter to the current integration flow position.
 
 Type Parameters:
 
 S - the AbstractMessageSplitter
 
 Parameters:
 
 splitterMessageHandlerSpec - the MessageHandlerSpec to populate.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public <S extends AbstractMessageSplitter> B split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec, Consumer<SplitterEndpointSpec<S>> endpointConfigurer)
 
 Populate the provided AbstractMessageSplitter to the current integration flow position.
 
 Type Parameters:
 
 S - the AbstractMessageSplitter
 
 Parameters:
 
 splitterMessageHandlerSpec - the MessageHandlerSpec to populate.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public B split(AbstractMessageSplitter splitter)
 
 Populate the provided AbstractMessageSplitter to the current integration flow position.
 
 Parameters:
 
 splitter - the AbstractMessageSplitter to populate.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- split
 
 public <S extends AbstractMessageSplitter> B split(S splitter, Consumer<SplitterEndpointSpec<S>> endpointConfigurer)
 
 Populate the provided AbstractMessageSplitter to the current integration flow position.
 
 Type Parameters:
 
 S - the AbstractMessageSplitter
 
 Parameters:
 
 splitter - the AbstractMessageSplitter to populate.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 SplitterEndpointSpec
- headerFilter
 
 public B headerFilter(String... headersToRemove)
 
 Provide the HeaderFilter to the current StandardIntegrationFlow.
 
 Parameters:
 
 headersToRemove - the array of headers (or patterns) to remove from MessageHeaders.
 
 Returns:
 
 this BaseIntegrationFlowDefinition.
- headerFilter
 
 public B headerFilter(String headersToRemove, boolean patternMatch)
 
 Provide the HeaderFilter to the current StandardIntegrationFlow.
 
 Parameters:
 
 headersToRemove - the comma separated headers (or patterns) to remove from MessageHeaders.
 
 patternMatch - the boolean flag to indicate if headersToRemove should be interpreted as patterns or direct header names.
 
 Returns:
 
 this BaseIntegrationFlowDefinition.
- headerFilter
 
 public B headerFilter(HeaderFilter headerFilter, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the provided MessageTransformingHandler for the provided HeaderFilter.
 
 Parameters:
 
 headerFilter - the HeaderFilter to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 GenericEndpointSpec
- claimCheckIn
 
 public B claimCheckIn(MessageStore messageStore)
 
 Populate the MessageTransformingHandler for the ClaimCheckInTransformer with provided MessageStore.
 
 Parameters:
 
 messageStore - the MessageStore to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- claimCheckIn
 
 public B claimCheckIn(MessageStore messageStore, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the MessageTransformingHandler for the ClaimCheckInTransformer with provided MessageStore. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 messageStore - the MessageStore to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 GenericEndpointSpec
- claimCheckOut
 
 public B claimCheckOut(MessageStore messageStore)
 
 Populate the MessageTransformingHandler for the ClaimCheckOutTransformer with provided MessageStore. The removeMessage option of ClaimCheckOutTransformer is to false.
 
 Parameters:
 
 messageStore - the MessageStore to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- claimCheckOut
 
 public B claimCheckOut(MessageStore messageStore, boolean removeMessage)
 
 Populate the MessageTransformingHandler for the ClaimCheckOutTransformer with provided MessageStore and removeMessage flag.
 
 Parameters:
 
 messageStore - the MessageStore to use.
 
 removeMessage - the removeMessage boolean flag.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ClaimCheckOutTransformer.setRemoveMessage(boolean)
- claimCheckOut
 
 public B claimCheckOut(MessageStore messageStore, boolean removeMessage, Consumer<GenericEndpointSpec<MessageTransformingHandler>> endpointConfigurer)
 
 Populate the MessageTransformingHandler for the ClaimCheckOutTransformer with provided MessageStore and removeMessage flag. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Parameters:
 
 messageStore - the MessageStore to use.
 
 removeMessage - the removeMessage boolean flag.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 GenericEndpointSpec, ClaimCheckOutTransformer.setRemoveMessage(boolean)
- resequence
 
 public B resequence()
 
 Populate the ResequencingMessageHandler with default options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- resequence
 
 public B resequence(Consumer<ResequencerSpec> resequencer)
 Populate the ResequencingMessageHandler with provided options from ResequencerSpec. In addition, accept options for the integration endpoint using GenericEndpointSpec. Typically used with a Java 8 Lambda expression:
 .resequence(r -> r.releasePartialSequences(true) .correlationExpression("'foo'") .phase(100))
 Parameters:
 
 resequencer - the Consumer to provide ResequencingMessageHandler options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ResequencerSpec
- aggregate
 
 public B aggregate()
 
 Populate the AggregatingMessageHandler with default options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- aggregate
 
 public B aggregate(Object aggregatorProcessor)
 
 A short-cut for the aggregate((aggregator) -> aggregator.processor(aggregatorProcessor)).
 
 Parameters:
 
 aggregatorProcessor - the POJO representing aggregation strategies.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 Since:
 
 5.5
 
 See Also:
 
 AggregatorSpec
- aggregate
 
 public B aggregate(Consumer<AggregatorSpec> aggregator)
 Populate the AggregatingMessageHandler with provided options from AggregatorSpec. In addition, accept options for the integration endpoint using GenericEndpointSpec. Typically used with a Java 8 Lambda expression:
 .aggregate(a -> a.correlationExpression("1") .releaseStrategy(g -> g.size() == 25) .phase(100))
 Parameters:
 
 aggregator - the Consumer to provide AggregatingMessageHandler options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 AggregatorSpec
- route
 
 public B route(String beanName, String method)
 
 Populate the MethodInvokingRouter for provided bean and its method with default options.
 
 Parameters:
 
 beanName - the bean to use.
 
 method - the method to invoke at runtime.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 public B route(String beanName, String method, Consumer<RouterSpec<Object,MethodInvokingRouter>> routerConfigurer)
 
 Populate the MethodInvokingRouter for provided bean and its method with provided options from RouterSpec.
 
 Parameters:
 
 beanName - the bean to use.
 
 method - the method to invoke at runtime.
 
 routerConfigurer - the Consumer to provide MethodInvokingRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 public B route(Object service)
 
 Populate the MethodInvokingRouter for the discovered method of the provided service and its method with default options.
 
 Parameters:
 
 service - the bean to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingRouter
- route
 
 public B route(Object service, String methodName)
 
 Populate the MethodInvokingRouter for the method of the provided service and its method with default options.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingRouter
- route
 
 public B route(Object service, String methodName, Consumer<RouterSpec<Object,MethodInvokingRouter>> routerConfigurer)
 
 Populate the MethodInvokingRouter for the method of the provided service and its method with provided options from RouterSpec.
 
 Parameters:
 
 service - the service to use.
 
 methodName - the method to invoke.
 
 routerConfigurer - the Consumer to provide MethodInvokingRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 MethodInvokingRouter
- route
 
 public B route(String expression)
 
 Populate the ExpressionEvaluatingRouter for provided SpEL expression with default options.
 
 Parameters:
 
 expression - the expression to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 public <T> B route(String expression, Consumer<RouterSpec<T,ExpressionEvaluatingRouter>> routerConfigurer)
 
 Populate the ExpressionEvaluatingRouter for provided SpEL expression with provided options from RouterSpec.
 
 Type Parameters:
 
 T - the target result type.
 
 Parameters:
 
 expression - the expression to use.
 
 routerConfigurer - the Consumer to provide ExpressionEvaluatingRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 public <S, T> B route(Class<S> expectedType, Function<S,T> router)
 Populate the MethodInvokingRouter for provided Function and payload type with default options. Typically used with a Java 8 Lambda expression:
 .route(Integer.class, p -> p % 2 == 0)
 Type Parameters:
 
 S - the source payload type or Message.class.
 
 T - the target result type.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the router. Conversion to this type will be attempted, if necessary.
 
 router - the Function to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor
- route
 
 public <P, T> B route(Class expectedType, Function<P,T> router, Consumer<RouterSpec<T,MethodInvokingRouter>> routerConfigurer)
 Populate the MethodInvokingRouter for provided Function and payload type and options from RouterSpec. In addition, accept options for the integration endpoint using GenericEndpointSpec. Typically, used with a Java 8 Lambda expression:
 .route(Integer.class, p -> p % 2 == 0, m -> m.channelMapping("true", "evenChannel") .subFlowMapping("false", f -> f.<Integer>handle((p, h) -> p * 3)) .applySequence(false))
 Type Parameters:
 
 P - the source payload type or Message.class.
 
 T - the target result type.
 
 Parameters:
 
 expectedType - the Class for expected payload type. It can also be Message.class if you wish to access the entire message in the router. Conversion to this type will be attempted, if necessary.
 
 router - the Function to use.
 
 routerConfigurer - the Consumer to provide MethodInvokingRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 LambdaMessageProcessor
- route
 
 public B route(MessageProcessorSpec<?> messageProcessorSpec)
 Populate the MethodInvokingRouter for the MessageProcessor from the provided MessageProcessorSpec with default options.
 .route(Scripts.script(myScriptResource).lang("groovy").refreshCheckDelay(1000))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 public B route(MessageProcessorSpec<?> messageProcessorSpec, Consumer<RouterSpec<Object,MethodInvokingRouter>> routerConfigurer)
 Populate the MethodInvokingRouter for the MessageProcessor from the provided MessageProcessorSpec with default options.
 .route(Scripts.script(myScriptResource).lang("groovy").refreshCheckDelay(1000), m -> m.channelMapping("true", "evenChannel") .subFlowMapping("false", f -> f.<Integer>handle((p, h) -> p * 3)))
 Parameters:
 
 messageProcessorSpec - the MessageProcessorSpec to use.
 
 routerConfigurer - the Consumer to provide MethodInvokingRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 protected <R extends AbstractMessageRouter, S extends AbstractRouterSpec<? super S, R>> B route(S routerSpec, Consumer<S> routerConfigurer)
- routeToRecipients
 
 public B routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer)
 Populate the RecipientListRouter with options from the RecipientListRouterSpec. Typically used with a Java 8 Lambda expression:
 .routeToRecipients(r -> r .recipient("bar-channel", m -> m.getHeaders().containsKey("recipient") && (boolean) m.getHeaders().get("recipient")) .recipientFlow("'foo' == payload or 'bar' == payload or 'baz' == payload", f -> f.transform(String.class, p -> p.toUpperCase()) .channel(c -> c.queue("recipientListSubFlow1Result"))))
 Parameters:
 
 routerConfigurer - the Consumer to provide RecipientListRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- routeByException
 
 public B routeByException(Consumer<RouterSpec<Class<? extends Throwable>,ErrorMessageExceptionTypeRouter>> routerConfigurer)
 Populate the ErrorMessageExceptionTypeRouter with options from the RouterSpec. Typically used with a Java 8 Lambda expression:
 .routeByException(r -> r .channelMapping(IllegalArgumentException.class, "illegalArgumentChannel") .subFlowMapping(MessageHandlingException.class, sf -> sf.handle(...)) )
 Parameters:
 
 routerConfigurer - the Consumer to provide ErrorMessageExceptionTypeRouter options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 ErrorMessageExceptionTypeRouter
- route
 
 public B route(AbstractMessageRouter router)
 
 Populate the provided AbstractMessageRouter implementation to the current integration flow position.
 
 Parameters:
 
 router - the AbstractMessageRouter to populate.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- route
 
 public <R extends AbstractMessageRouter> B route(R router, Consumer<GenericEndpointSpec<R>> endpointConfigurer)
 
 Populate the provided AbstractMessageRouter implementation to the current integration flow position. In addition accept options for the integration endpoint using GenericEndpointSpec.
 
 Type Parameters:
 
 R - the AbstractMessageRouter type.
 
 Parameters:
 
 router - the AbstractMessageRouter to populate.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- gateway
 
 public B gateway(String requestChannel)
 
 Populate the "artificial" GatewayMessageHandler for the provided requestChannel to send a request with default options. Uses RequestReplyExchanger Proxy on the background.
 
 Parameters:
 
 requestChannel - the MessageChannel bean name.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- gateway
 
 public B gateway(String requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer)
 
 Populate the "artificial" GatewayMessageHandler for the provided requestChannel to send a request with options from GatewayEndpointSpec. Uses RequestReplyExchanger Proxy on the background.
 
 Parameters:
 
 requestChannel - the MessageChannel bean name.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- gateway
 
 public B gateway(MessageChannel requestChannel)
 
 Populate the "artificial" GatewayMessageHandler for the provided requestChannel to send a request with default options. Uses RequestReplyExchanger Proxy on the background.
 
 Parameters:
 
 requestChannel - the MessageChannel to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- gateway
 
 public B gateway(MessageChannel requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer)
 
 Populate the "artificial" GatewayMessageHandler for the provided requestChannel to send a request with options from GatewayEndpointSpec. Uses RequestReplyExchanger Proxy on the background.
 
 Parameters:
 
 requestChannel - the MessageChannel to use.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- gateway
 
 public B gateway(IntegrationFlow flow)
 Populate the "artificial" GatewayMessageHandler for the provided subflow. Typically used with a Java 8 Lambda expression:
 .gateway(f -> f.transform("From Gateway SubFlow: "::concat))
 Parameters:
 
 flow - the IntegrationFlow to to send a request message and wait for reply.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- gateway
 
 public B gateway(IntegrationFlow flow, Consumer<GatewayEndpointSpec> endpointConfigurer)
 Populate the "artificial" GatewayMessageHandler for the provided subflow with options from GatewayEndpointSpec. Typically used with a Java 8 Lambda expression:
 .gateway(f -> f.transform("From Gateway SubFlow: "::concat), e -> e.replyTimeout(100L))
 Parameters:
 
 flow - the IntegrationFlow to to send a request message and wait for reply.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- log
 
 public B log()
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO logging level and org.springframework.integration.handler.LoggingHandler as a default logging category.
 The full request Message will be logged.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for provided LoggingHandler.Level logging level and org.springframework.integration.handler.LoggingHandler as a default logging category.
 The full request Message will be logged.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(String category)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided logging category and INFO logging level.
 The full request Message will be logged.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 category - the logging category to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level, String category)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level and logging category.
 The full request Message will be logged.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category to use.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level, String category, String logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, logging category and SpEL expression for the log message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category.
 
 logExpression - the SpEL expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and Function for the log message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and SpEL expression to evaluate logger message at runtime against the request Message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level, Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and SpEL expression to evaluate logger message at runtime against the request Message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(String category, Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO LoggingHandler.Level logging level, the provided logging category and SpEL expression to evaluate logger message at runtime against the request Message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 category - the logging category.
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level, Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and Function for the log message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(String category, Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, the provided logging category and Function for the log message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 category - the logging category.
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level, String category, Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, logging category and Function for the log message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category.
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- log
 
 public B log(LoggingHandler.Level level, String category, Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, logging category and SpEL expression for the log message.
 When this operator is used in the end of flow, it is treated as one-way handler without any replies to continue. The logAndReply() should be used for request-reply configuration.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category.
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 See Also:
 
 wireTap(WireTapSpec)
- logAndReply
 
 public IntegrationFlow logAndReply()
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO logging level and org.springframework.integration.handler.LoggingHandler as a default logging category.
 The full request Message will be logged.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for provided LoggingHandler.Level logging level and org.springframework.integration.handler.LoggingHandler as a default logging category.
 The full request Message will be logged.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(String category)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided logging category and INFO logging level.
 The full request Message will be logged.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 category - the logging category to use.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level, String category)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level and logging category.
 The full request Message will be logged.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category to use.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level, String category, String logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, logging category and SpEL expression for the log message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category.
 
 logExpression - the SpEL expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and Function for the log message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and SpEL expression to evaluate logger message at runtime against the request Message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level, Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and SpEL expression to evaluate logger message at runtime against the request Message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(String category, Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the INFO LoggingHandler.Level logging level, the provided logging category and SpEL expression to evaluate logger message at runtime against the request Message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 category - the logging category.
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level, Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, the org.springframework.integration.handler.LoggingHandler as a default logging category and Function for the log message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(String category, Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, the provided logging category and Function for the log message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 category - the logging category.
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level, String category, Function<Message,Object> function)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, logging category and Function for the log message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Type Parameters:
 
 P - the expected payload type. against the request Message.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category.
 
 function - the function to evaluate logger message at runtime
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- logAndReply
 
 public IntegrationFlow logAndReply(LoggingHandler.Level level, String category, Expression logExpression)
 
 Populate a WireTap for the currentMessageChannel with the LoggingHandler subscriber for the provided LoggingHandler.Level logging level, logging category and SpEL expression for the log message.
 A bridge() is added after this operator to make the flow reply-producing if the replyChannel header is present.
 This operator can be used only in the end of flow.
 
 Parameters:
 
 level - the LoggingHandler.Level.
 
 category - the logging category.
 
 logExpression - the Expression to evaluate logger message at runtime against the request Message.
 
 Returns:
 
 an IntegrationFlow instance based on this builder.
 
 See Also:
 
 log(), bridge()
- scatterGather
 
 public B scatterGather(MessageChannel scatterChannel)
 
 Populate a ScatterGatherHandler to the current integration flow position based on the provided MessageChannel for scattering function and default AggregatorSpec for gathering function.
 
 Parameters:
 
 scatterChannel - the MessageChannel for scatting requests.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- scatterGather
 
 public B scatterGather(MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer)
 
 Populate a ScatterGatherHandler to the current integration flow position based on the provided MessageChannel for scattering function and AggregatorSpec for gathering function.
 
 Parameters:
 
 scatterChannel - the MessageChannel for scatting requests.
 
 gatherer - the Consumer for AggregatorSpec to configure gatherer. Can be null.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- scatterGather
 
 public B scatterGather(MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer, Consumer<ScatterGatherSpec> scatterGather)
 
 Populate a ScatterGatherHandler to the current integration flow position based on the provided MessageChannel for scattering function and AggregatorSpec for gathering function.
 
 Parameters:
 
 scatterChannel - the MessageChannel for scatting requests.
 
 gatherer - the Consumer for AggregatorSpec to configure gatherer. Can be null.
 
 scatterGather - the Consumer for ScatterGatherSpec to configure ScatterGatherHandler and its endpoint. Can be null.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- scatterGather
 
 public B scatterGather(Consumer<RecipientListRouterSpec> scatterer)
 
 Populate a ScatterGatherHandler to the current integration flow position based on the provided RecipientListRouterSpec for scattering function and default AggregatorSpec for gathering function.
 
 Parameters:
 
 scatterer - the Consumer for RecipientListRouterSpec to configure scatterer.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- scatterGather
 
 public B scatterGather(Consumer<RecipientListRouterSpec> scatterer, @Nullable Consumer<AggregatorSpec> gatherer)
 
 Populate a ScatterGatherHandler to the current integration flow position based on the provided RecipientListRouterSpec for scattering function and AggregatorSpec for gathering function.
 
 Parameters:
 
 scatterer - the Consumer for RecipientListRouterSpec to configure scatterer. Can be null.
 
 gatherer - the Consumer for AggregatorSpec to configure gatherer. Can be null.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- scatterGather
 
 public B scatterGather(Consumer<RecipientListRouterSpec> scatterer, @Nullable Consumer<AggregatorSpec> gatherer, @Nullable Consumer<ScatterGatherSpec> scatterGather)
 
 Populate a ScatterGatherHandler to the current integration flow position based on the provided RecipientListRouterSpec for scattering function and AggregatorSpec for gathering function.
 
 Parameters:
 
 scatterer - the Consumer for RecipientListRouterSpec to configure scatterer.
 
 gatherer - the Consumer for AggregatorSpec to configure gatherer.
 
 scatterGather - the Consumer for ScatterGatherSpec to configure ScatterGatherHandler and its endpoint. Can be null.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- barrier
 
 public B barrier(long timeout)
 
 Populate a BarrierMessageHandler instance for provided timeout.
 
 Parameters:
 
 timeout - the timeout in milliseconds.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- barrier
 
 public B barrier(long timeout, Consumer<BarrierSpec> barrierConfigurer)
 
 Populate a BarrierMessageHandler instance for provided timeout and options from BarrierSpec and endpoint options from GenericEndpointSpec.
 
 Parameters:
 
 timeout - the timeout in milliseconds.
 
 barrierConfigurer - the Consumer to provide BarrierMessageHandler options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- trigger
 
 public B trigger(String triggerActionId)
 
 Populate a ServiceActivatingHandler instance to perform MessageTriggerAction.
 
 Parameters:
 
 triggerActionId - the MessageTriggerAction bean id.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- trigger
 
 public B trigger(String triggerActionId, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 
 Populate a ServiceActivatingHandler instance to perform MessageTriggerAction and endpoint options from GenericEndpointSpec.
 
 Parameters:
 
 triggerActionId - the MessageTriggerAction bean id.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- trigger
 
 public B trigger(MessageTriggerAction triggerAction)
 
 Populate a ServiceActivatingHandler instance to perform MessageTriggerAction.
 
 Parameters:
 
 triggerAction - the MessageTriggerAction.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- trigger
 
 public B trigger(MessageTriggerAction triggerAction, Consumer<GenericEndpointSpec<ServiceActivatingHandler>> endpointConfigurer)
 
 Populate a ServiceActivatingHandler instance to perform MessageTriggerAction and endpoint options from GenericEndpointSpec.
 
 Parameters:
 
 triggerAction - the MessageTriggerAction.
 
 endpointConfigurer - the Consumer to provide integration endpoint options.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- intercept
 
 public B intercept(ChannelInterceptor... interceptorArray)
 
 Add one or more ChannelInterceptor implementations to the current currentMessageChannel, in the given order, after any interceptors already registered.
 
 Parameters:
 
 interceptorArray - one or more ChannelInterceptors.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
 
 Throws:
 
 IllegalArgumentException - if one or more null arguments are provided
 
 Since:
 
 5.3
- fluxTransform
 
 public <I, O> B fluxTransform(Function<? super reactor.core.publisher.Flux<Message>,? extends org.reactivestreams.Publisher<O>> fluxFunction)
 
 Populate a FluxMessageChannel to start a reactive processing for upstream data, wrap it to a Flux, apply provided Function via Flux.transform(Function) and emit the result to one more FluxMessageChannel, subscribed in the downstream flow.
 
 Type Parameters:
 
 I - the input payload type.
 
 O - the output type.
 
 Parameters:
 
 fluxFunction - the Function to process data reactive manner.
 
 Returns:
 
 the current BaseIntegrationFlowDefinition.
- nullChannel
 
 public IntegrationFlow nullChannel()
 
 Add a "nullChannel" bean into this flow definition as a terminal operator.
 
 Returns:
 
 The IntegrationFlow instance based on this definition.
 
 Since:
 
 5.1
- to
 
 public IntegrationFlow to(IntegrationFlow other)
 
 Finish this flow with delegation to other IntegrationFlow instance.
 
 Parameters:
 
 other - the IntegrationFlow to compose with.
 
 Returns:
 
 The IntegrationFlow instance based on this definition.
 
 Since:
 
 5.5.4
- toReactivePublisher
 
 protected <T> org.reactivestreams.Publisher<Message<T>> toReactivePublisher()
 
 Represent an Integration Flow as a Reactive Streams Publisher bean.
 
 Type Parameters:
 
 T - the expected payload type
 
 Returns:
 
 the Reactive Streams Publisher
- toReactivePublisher
 
 protected <T> org.reactivestreams.Publisher<Message<T>> toReactivePublisher(boolean autoStartOnSubscribe)
 
 Represent an Integration Flow as a Reactive Streams Publisher bean.
 
 Type Parameters:
 
 T - the expected payload type
 
 Parameters:
 
 autoStartOnSubscribe - start message production and consumption in the flow, when a subscription to the publisher is initiated. If this set to true, the flow is marked to not start automatically by the application context.
 
 Returns:
 
 the Reactive Streams Publisher
 
 Since:
 
 5.5.6
- register
 
 protected <S extends ConsumerEndpointSpec<? super S, ? extends MessageHandler>> B register(S endpointSpec, Consumer<S> endpointConfigurer)
- registerOutputChannelIfCan
 
 protected B registerOutputChannelIfCan(MessageChannel outputChannel)
- isOutputChannelRequired
 
 protected boolean isOutputChannelRequired()
- _this
 
 protected final B _this()
- get
 
 protected StandardIntegrationFlow get()
- checkReuse
 
 protected void checkReuse(MessageProducer replyHandler)
- extractProxyTarget
 
 protected static Object extractProxyTarget(Object target)

Modifier and Type	Field	Description
`protected Map<Object,String>`	`integrationComponents`
`protected static SpelExpressionParser`	`PARSER`

Class BaseIntegrationFlowDefinition<B extends BaseIntegrationFlowDefinition<B>>

Nested Class Summary

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Details

Constructor Details

Method Details