B - the IntegrationFlowDefinition implementation type.public abstract class IntegrationFlowDefinition<B extends IntegrationFlowDefinition<B>>
extends java.lang.Object
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.IntegrationFlowBeanPostProcessor| Modifier and Type | Field and Description |
|---|---|
protected java.lang.Object |
currentComponent |
protected org.springframework.messaging.MessageChannel |
currentMessageChannel |
protected java.util.Set<java.lang.Object> |
integrationComponents |
| Modifier and Type | Method and Description |
|---|---|
protected B |
_this() |
B |
aggregate()
Populate the
AggregatingMessageHandler with default options. |
B |
aggregate(Consumer<AggregatorSpec> aggregator)
Populate the
AggregatingMessageHandler with provided options from AggregatorSpec. |
B |
aggregate(Consumer<AggregatorSpec> aggregatorConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.aggregator.AggregatingMessageHandler>> endpointConfigurer)
Deprecated.
since 1.1 in favor of
aggregate(Consumer) |
B |
bridge(Consumer<GenericEndpointSpec<org.springframework.integration.handler.BridgeHandler>> endpointConfigurer)
Populate a
BridgeHandler to the current integration flow 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(org.springframework.messaging.MessageChannel messageChannel)
Populate the provided
MessageChannel instance
at the current IntegrationFlow chain position. |
B |
channel(MessageChannelSpec<?,?> messageChannelSpec)
Populate a
MessageChannel instance
at the current IntegrationFlow chain position using the MessageChannelSpec
fluent API. |
B |
channel(java.lang.String messageChannelName)
Populate a
MessageChannelReference instance
at the current IntegrationFlow chain position. |
B |
claimCheckIn(org.springframework.integration.store.MessageStore messageStore)
Populate the
MessageTransformingHandler for the ClaimCheckInTransformer
with provided MessageStore. |
B |
claimCheckIn(org.springframework.integration.store.MessageStore messageStore,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the
MessageTransformingHandler for the ClaimCheckInTransformer
with provided MessageStore. |
B |
claimCheckOut(org.springframework.integration.store.MessageStore messageStore)
Populate the
MessageTransformingHandler for the ClaimCheckOutTransformer
with provided MessageStore. |
B |
claimCheckOut(org.springframework.integration.store.MessageStore messageStore,
boolean removeMessage)
Populate the
MessageTransformingHandler for the ClaimCheckOutTransformer
with provided MessageStore and removeMessage flag. |
B |
claimCheckOut(org.springframework.integration.store.MessageStore messageStore,
boolean removeMessage,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.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<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Populate the
Control Bus EI Pattern specific MessageHandler implementation
at the current IntegrationFlow chain position. |
B |
delay(java.lang.String groupId)
Populate a
DelayHandler to the current integration flow position
with default options. |
B |
delay(java.lang.String groupId,
Consumer<DelayerEndpointSpec> endpointConfigurer)
Populate a
DelayHandler to the current integration flow position
with provided options. |
<P> B |
delay(java.lang.String groupId,
Function<org.springframework.messaging.Message<P>,java.lang.Object> function)
Populate a
DelayHandler to the current integration flow position
with provided delayFunction. |
<P> B |
delay(java.lang.String groupId,
Function<org.springframework.messaging.Message<P>,java.lang.Object> function,
Consumer<DelayerEndpointSpec> endpointConfigurer)
Populate a
DelayHandler to the current integration flow position
with provided delayFunction. |
B |
delay(java.lang.String groupId,
java.lang.String expression)
Populate a
DelayHandler to the current integration flow position
with provided delayExpression. |
B |
delay(java.lang.String groupId,
java.lang.String expression,
Consumer<DelayerEndpointSpec> endpointConfigurer)
Populate a
DelayHandler to the current integration flow position
with provided delayExpression. |
B |
enrich(Consumer<EnricherSpec> enricherConfigurer)
Populate a
ContentEnricher to the current integration flow position
with provided options. |
B |
enrich(Consumer<EnricherSpec> enricherConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.ContentEnricher>> endpointConfigurer)
Populate a
ContentEnricher to the current integration flow position
with provided options. |
B |
enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer)
|
B |
enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
|
B |
enrichHeaders(java.util.Map<java.lang.String,java.lang.Object> headers)
Accept a
Map of values to be used for the
Message header enrichment. |
B |
enrichHeaders(java.util.Map<java.lang.String,java.lang.Object> headers,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Accept a
Map of values to be used for the
Message header enrichment. |
B |
enrichHeaders(MapBuilder<?,java.lang.String,java.lang.Object> headers)
Populate a
MessageTransformingHandler for
a HeaderEnricher
using header values from provided MapBuilder. |
B |
enrichHeaders(MapBuilder<?,java.lang.String,java.lang.Object> headers,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate a
MessageTransformingHandler for
a HeaderEnricher
using header values from provided MapBuilder. |
<P> B |
filter(java.lang.Class<P> payloadType,
org.springframework.integration.core.GenericSelector<P> genericSelector)
Populate a
MessageFilter with MethodInvokingSelector
for the provided GenericSelector. |
<P> B |
filter(java.lang.Class<P> payloadType,
org.springframework.integration.core.GenericSelector<P> genericSelector,
Consumer<FilterEndpointSpec> endpointConfigurer)
Populate a
MessageFilter with MethodInvokingSelector
for the provided GenericSelector. |
<P> B |
filter(org.springframework.integration.core.GenericSelector<P> genericSelector)
Populate a
MessageFilter with MethodInvokingSelector
for the provided GenericSelector. |
<P> B |
filter(org.springframework.integration.core.GenericSelector<P> genericSelector,
Consumer<FilterEndpointSpec> endpointConfigurer)
Populate a
MessageFilter with MethodInvokingSelector
for the provided GenericSelector. |
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 |
filter(java.lang.Object service)
Populate a
MessageFilter with MethodInvokingSelector for the
discovered method of the provided service. |
B |
filter(java.lang.Object service,
java.lang.String methodName)
Populate a
MessageFilter with MethodInvokingSelector for the
method of the provided service. |
B |
filter(java.lang.Object service,
java.lang.String methodName,
Consumer<FilterEndpointSpec> endpointConfigurer)
Populate a
MessageFilter with MethodInvokingSelector for the
method of the provided service. |
B |
filter(java.lang.String expression)
Populate a
MessageFilter with MessageSelector for the provided SpEL expression. |
B |
filter(java.lang.String expression,
Consumer<FilterEndpointSpec> endpointConfigurer)
Populate a
MessageFilter with MessageSelector for the provided SpEL expression. |
B |
fixedSubscriberChannel()
Populate an
FixedSubscriberChannel instance
at the current IntegrationFlow chain position. |
B |
fixedSubscriberChannel(java.lang.String messageChannelName)
Populate an
FixedSubscriberChannel instance
at the current IntegrationFlow chain position. |
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(org.springframework.messaging.MessageChannel requestChannel)
Populate the "artificial"
GatewayMessageHandler for the provided
requestChannel to send a request with default options. |
B |
gateway(org.springframework.messaging.MessageChannel requestChannel,
Consumer<GatewayEndpointSpec> endpointConfigurer)
Populate the "artificial"
GatewayMessageHandler for the provided
requestChannel to send a request with options from GatewayEndpointSpec. |
B |
gateway(java.lang.String requestChannel)
Populate the "artificial"
GatewayMessageHandler for the provided
requestChannel to send a request with default options. |
B |
gateway(java.lang.String requestChannel,
Consumer<GatewayEndpointSpec> endpointConfigurer)
Populate the "artificial"
GatewayMessageHandler for the provided
requestChannel to send a request with options from GatewayEndpointSpec. |
protected StandardIntegrationFlow |
get() |
<P> B |
handle(java.lang.Class<P> payloadType,
GenericHandler<P> handler)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the provided GenericHandler at runtime. |
<P> B |
handle(java.lang.Class<P> payloadType,
GenericHandler<P> handler,
Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the provided GenericHandler at runtime. |
<P> B |
handle(GenericHandler<P> handler)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the provided GenericHandler at runtime. |
<P> B |
handle(GenericHandler<P> handler,
Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the provided GenericHandler at runtime. |
<H extends org.springframework.messaging.MessageHandler> |
handle(H messageHandler,
Consumer<GenericEndpointSpec<H>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the provided
MessageHandler implementation. |
B |
handle(org.springframework.messaging.MessageHandler messageHandler)
Populate a
ServiceActivatingHandler for the provided
MessageHandler implementation. |
<H extends org.springframework.messaging.MessageHandler> |
handle(MessageHandlerSpec<?,H> messageHandlerSpec)
Populate a
ServiceActivatingHandler for the selected protocol specific
MessageHandler implementation from Namespace Factory:
|
<H extends org.springframework.messaging.MessageHandler> |
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<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the
MessageProcessor from the provided
MessageProcessorSpec. |
B |
handle(java.lang.Object service)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the discovered method for provided service at runtime. |
B |
handle(java.lang.Object service,
java.lang.String methodName)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime. |
B |
handle(java.lang.Object service,
java.lang.String methodName,
Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime. |
B |
handle(java.lang.String beanName,
java.lang.String methodName)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime. |
B |
handle(java.lang.String beanName,
java.lang.String methodName,
Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime. |
<H extends org.springframework.messaging.MessageHandler> |
handleWithAdapter(Function<Adapters,MessageHandlerSpec<?,H>> adapters)
Populate a
ServiceActivatingHandler for the selected protocol specific
MessageHandler implementation from Adapters factory. |
<H extends org.springframework.messaging.MessageHandler> |
handleWithAdapter(Function<Adapters,MessageHandlerSpec<?,H>> adapters,
Consumer<GenericEndpointSpec<H>> endpointConfigurer)
Populate a
ServiceActivatingHandler for the selected protocol specific
MessageHandler implementation from Adapters factory. |
B |
headerFilter(org.springframework.integration.transformer.HeaderFilter headerFilter,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the provided
MessageTransformingHandler for the provided
HeaderFilter. |
B |
headerFilter(java.lang.String... headersToRemove)
Provide the
HeaderFilter to the current StandardIntegrationFlow. |
B |
headerFilter(java.lang.String headersToRemove,
boolean patternMatch)
Provide the
HeaderFilter to the current StandardIntegrationFlow. |
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(org.springframework.expression.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. |
<P> B |
log(Function<org.springframework.messaging.Message<P>,java.lang.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(org.springframework.integration.handler.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(org.springframework.integration.handler.LoggingHandler.Level level,
org.springframework.expression.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. |
<P> B |
log(org.springframework.integration.handler.LoggingHandler.Level level,
Function<org.springframework.messaging.Message<P>,java.lang.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(org.springframework.integration.handler.LoggingHandler.Level level,
java.lang.String category)
Populate a
WireTap for the currentMessageChannel
with the LoggingHandler subscriber for the provided
LoggingHandler.Level logging level and logging category. |
B |
log(org.springframework.integration.handler.LoggingHandler.Level level,
java.lang.String category,
org.springframework.expression.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(org.springframework.integration.handler.LoggingHandler.Level level,
java.lang.String category,
Function<org.springframework.messaging.Message<P>,java.lang.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(org.springframework.integration.handler.LoggingHandler.Level level,
java.lang.String category,
java.lang.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. |
B |
log(java.lang.String category)
Populate a
WireTap for the currentMessageChannel
with the LoggingHandler subscriber for the provided logging category
and INFO logging level. |
B |
log(java.lang.String category,
org.springframework.expression.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(java.lang.String category,
Function<org.springframework.messaging.Message<P>,java.lang.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 |
publishSubscribeChannel(Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)
The
PublishSubscribeChannel channel(java.lang.String)
method specific implementation to allow the use of the 'subflow' subscriber capability. |
B |
publishSubscribeChannel(java.util.concurrent.Executor executor,
Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)
The
PublishSubscribeChannel channel(java.lang.String)
method specific implementation to allow the use of the 'subflow' subscriber capability. |
B |
resequence()
Populate the
ResequencingMessageHandler with default options. |
B |
resequence(Consumer<ResequencerSpec> resequencer)
Populate the
ResequencingMessageHandler with provided options from ResequencerSpec. |
B |
resequence(Consumer<ResequencerSpec> resequencerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.aggregator.ResequencingMessageHandler>> endpointConfigurer)
Deprecated.
since 1.1 in favor of
resequence(Consumer) |
B |
route(org.springframework.integration.router.AbstractMessageRouter router)
Populate the provided
AbstractMessageRouter implementation to the
current integration flow position. |
<P,T> B |
route(java.lang.Class<P> payloadType,
Function<P,T> router,
Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
Populate the
MethodInvokingRouter for provided Function
and payload type and options from RouterSpec. |
<S,T> B |
route(java.lang.Class<S> payloadType,
Function<S,T> router)
Populate the
MethodInvokingRouter for provided Function
and payload type with default options. |
<S,T> B |
route(java.lang.Class<S> payloadType,
Function<S,T> router,
Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
Populate the
MethodInvokingRouter for provided Function
and payload type and options from RouterSpec. |
<S,T> B |
route(Function<S,T> router)
Populate the
MethodInvokingRouter for provided Function
with default options. |
<S,T> B |
route(Function<S,T> router,
Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
|
<S,T> B |
route(Function<S,T> router,
Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
|
B |
route(MessageProcessorSpec<?> messageProcessorSpec)
Populate the
MethodInvokingRouter for the MessageProcessor
from the provided MessageProcessorSpec with default options. |
B |
route(MessageProcessorSpec<?> messageProcessorSpec,
Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
Populate the
MethodInvokingRouter for the MessageProcessor
from the provided MessageProcessorSpec with default options. |
B |
route(MessageProcessorSpec<?> messageProcessorSpec,
Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
Populate the
MethodInvokingRouter for the MessageProcessor
from the provided MessageProcessorSpec with default options. |
B |
route(java.lang.Object service)
Populate the
MethodInvokingRouter for the discovered method
of the provided service and its method with default options. |
B |
route(java.lang.Object service,
java.lang.String methodName)
Populate the
MethodInvokingRouter for the method
of the provided service and its method with default options. |
B |
route(java.lang.Object service,
java.lang.String methodName,
Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
Populate the
MethodInvokingRouter for the method
of the provided service and its method with provided options from RouterSpec. |
B |
route(java.lang.Object service,
java.lang.String methodName,
Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
Populate the
MethodInvokingRouter for the method
of the provided service and its method with provided options from RouterSpec. |
<R extends org.springframework.integration.router.AbstractMessageRouter> |
route(R router,
Consumer<GenericEndpointSpec<R>> endpointConfigurer)
Populate the provided
AbstractMessageRouter implementation to the
current integration flow position. |
<K,R extends org.springframework.integration.router.AbstractMappingMessageRouter> |
route(R router,
Consumer<RouterSpec<K,R>> routerConfigurer,
Consumer<GenericEndpointSpec<R>> endpointConfigurer)
Populate the provided
AbstractMappingMessageRouter implementation
with options from RouterSpec and endpoint options from GenericEndpointSpec. |
B |
route(java.lang.String expression)
Populate the
ExpressionEvaluatingRouter for provided SpEL expression
with default options. |
<T> B |
route(java.lang.String expression,
Consumer<RouterSpec<T,org.springframework.integration.router.ExpressionEvaluatingRouter>> routerConfigurer)
Populate the
ExpressionEvaluatingRouter for provided SpEL expression
with provided options from RouterSpec. |
<T> B |
route(java.lang.String expression,
Consumer<RouterSpec<T,org.springframework.integration.router.ExpressionEvaluatingRouter>> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.ExpressionEvaluatingRouter>> endpointConfigurer)
Populate the
ExpressionEvaluatingRouter for provided bean and its method
with provided options from RouterSpec. |
B |
route(java.lang.String beanName,
java.lang.String method)
Populate the
MethodInvokingRouter for provided bean and its method
with default options. |
B |
route(java.lang.String beanName,
java.lang.String method,
Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
Populate the
MethodInvokingRouter for provided bean and its method
with provided options from RouterSpec. |
B |
route(java.lang.String beanName,
java.lang.String method,
Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
Populate the
MethodInvokingRouter for provided bean and its method
with provided options from RouterSpec. |
B |
routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer)
Populate the
RecipientListRouter options from RecipientListRouterSpec. |
B |
routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer,
Consumer<GenericEndpointSpec<org.springframework.integration.router.RecipientListRouter>> endpointConfigurer)
Populate the
RecipientListRouter options from 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(org.springframework.messaging.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(org.springframework.messaging.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(org.springframework.messaging.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. |
B |
split()
Populate the
DefaultMessageSplitter with default options
to the current integration flow position. |
B |
split(org.springframework.integration.splitter.AbstractMessageSplitter splitter)
Populate the provided
AbstractMessageSplitter to the current integration
flow position. |
<P> B |
split(java.lang.Class<P> payloadType,
Function<P,?> splitter)
Populate the
MethodInvokingSplitter to evaluate the provided
Function at runtime. |
<P> B |
split(java.lang.Class<P> payloadType,
Function<P,?> splitter,
Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
Populate the
MethodInvokingSplitter to evaluate the provided
Function at runtime. |
B |
split(Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.DefaultMessageSplitter>> endpointConfigurer)
Populate the
DefaultMessageSplitter with provided options
to the current integration flow position. |
<P> B |
split(Function<P,?> splitter,
Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
Populate the
MethodInvokingSplitter to evaluate the provided
Function at runtime. |
<S extends org.springframework.integration.splitter.AbstractMessageSplitter> |
split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec)
Populate the provided
AbstractMessageSplitter to the current integration
flow position. |
<S extends org.springframework.integration.splitter.AbstractMessageSplitter> |
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<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
Populate the
MethodInvokingSplitter to evaluate the
MessageProcessor at runtime
from provided MessageProcessorSpec. |
B |
split(java.lang.Object service)
Populate the
MethodInvokingSplitter to evaluate the discovered
method of the service at runtime. |
B |
split(java.lang.Object service,
java.lang.String methodName)
Populate the
MethodInvokingSplitter to evaluate the provided
method of the service at runtime. |
B |
split(java.lang.Object service,
java.lang.String methodName,
Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
Populate the
MethodInvokingSplitter to evaluate the provided
method of the bean at runtime. |
<S extends org.springframework.integration.splitter.AbstractMessageSplitter> |
split(S splitter,
Consumer<SplitterEndpointSpec<S>> endpointConfigurer)
Populate the provided
AbstractMessageSplitter to the current integration
flow position. |
B |
split(java.lang.String expression)
Populate the
ExpressionEvaluatingSplitter with provided
SpEL expression. |
B |
split(java.lang.String expression,
Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.ExpressionEvaluatingSplitter>> endpointConfigurer)
Populate the
ExpressionEvaluatingSplitter with provided
SpEL expression. |
B |
split(java.lang.String beanName,
java.lang.String methodName)
Populate the
MethodInvokingSplitter to evaluate the provided
method of the bean at runtime. |
B |
split(java.lang.String beanName,
java.lang.String methodName,
Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
Populate the
MethodInvokingSplitter to evaluate the provided
method of the bean at runtime. |
<T> org.reactivestreams.Publisher<org.springframework.messaging.Message<T>> |
toReactivePublisher()
Represent an Integration Flow as a Reactive Streams
Publisher bean. |
<T> org.reactivestreams.Publisher<org.springframework.messaging.Message<T>> |
toReactivePublisher(java.util.concurrent.Executor executor)
Represent an Integration Flow as a Reactive Streams
Publisher bean. |
<P,T> B |
transform(java.lang.Class<P> payloadType,
org.springframework.integration.transformer.GenericTransformer<P,T> genericTransformer)
Populate the
MessageTransformingHandler instance for the provided GenericTransformer
for the specific payloadType to convert at runtime. |
<P,T> B |
transform(java.lang.Class<P> payloadType,
org.springframework.integration.transformer.GenericTransformer<P,T> genericTransformer,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the
MessageTransformingHandler instance for the provided GenericTransformer
for the specific payloadType to convert at runtime. |
<S,T> B |
transform(org.springframework.integration.transformer.GenericTransformer<S,T> genericTransformer)
Populate the
MessageTransformingHandler instance for the provided GenericTransformer. |
<S,T> B |
transform(org.springframework.integration.transformer.GenericTransformer<S,T> genericTransformer,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the
MessageTransformingHandler instance for the provided GenericTransformer. |
B |
transform(MessageProcessorSpec<?> messageProcessorSpec)
Populate the
MessageTransformingHandler instance for the
MessageProcessor from provided MessageProcessorSpec. |
B |
transform(MessageProcessorSpec<?> messageProcessorSpec,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the
MessageTransformingHandler instance for the
MessageProcessor from provided MessageProcessorSpec. |
B |
transform(java.lang.Object service)
Populate the
MessageTransformingHandler for the MethodInvokingTransformer
to invoke the discovered service method at runtime. |
B |
transform(java.lang.Object service,
java.lang.String methodName)
Populate the
MessageTransformingHandler for the MethodInvokingTransformer
to invoke the service method at runtime. |
B |
transform(java.lang.Object service,
java.lang.String methodName,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the
MessageTransformingHandler for the MethodInvokingTransformer
to invoke the service method at runtime. |
B |
transform(java.lang.String expression)
Populate the
Transformer EI Pattern specific MessageHandler implementation
for the SpEL Expression. |
B |
transform(java.lang.String expression,
Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Populate the
Transformer EI Pattern specific MessageHandler implementation
for the SpEL Expression. |
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(org.springframework.messaging.MessageChannel wireTapChannel)
Populate the
Wire Tap EI Pattern specific
ChannelInterceptor implementation
to the current currentMessageChannel. |
B |
wireTap(org.springframework.messaging.MessageChannel wireTapChannel,
Consumer<WireTapSpec> wireTapConfigurer)
Populate the
Wire Tap EI Pattern specific
ChannelInterceptor implementation
to the current currentMessageChannel. |
B |
wireTap(java.lang.String wireTapChannel)
Populate the
Wire Tap EI Pattern specific
ChannelInterceptor implementation
to the current currentMessageChannel. |
B |
wireTap(java.lang.String wireTapChannel,
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. |
protected final java.util.Set<java.lang.Object> integrationComponents
protected org.springframework.messaging.MessageChannel currentMessageChannel
protected java.lang.Object currentComponent
public B fixedSubscriberChannel()
FixedSubscriberChannel instance
at the current IntegrationFlow chain position.
The 'bean name' will be generated during the bean registration phase.IntegrationFlowDefinition.public B fixedSubscriberChannel(java.lang.String messageChannelName)
FixedSubscriberChannel instance
at the current IntegrationFlow chain position.
The provided messageChannelName is used for the bean registration.messageChannelName - the bean name to use.IntegrationFlowDefinition.public B channel(java.lang.String messageChannelName)
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.messageChannelName - the bean name to use.IntegrationFlowDefinition.public B channel(Function<Channels,MessageChannelSpec<?,?>> channels)
MessageChannel instance
at the current IntegrationFlow chain position using the Channels
factory fluent API.channels - the Function to use.IntegrationFlowDefinition.public B channel(MessageChannelSpec<?,?> messageChannelSpec)
MessageChannel instance
at the current IntegrationFlow chain position using the MessageChannelSpec
fluent API.messageChannelSpec - the MessageChannelSpec to use.IntegrationFlowDefinition.MessageChannelspublic B channel(org.springframework.messaging.MessageChannel messageChannel)
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.messageChannel - the MessageChannel to populate.IntegrationFlowDefinition.public B publishSubscribeChannel(Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)
PublishSubscribeChannel channel(java.lang.String)
method specific implementation to allow the use of the 'subflow' subscriber capability.publishSubscribeChannelConfigurer - the Consumer to specify
PublishSubscribeSpec options including 'subflow' definition.IntegrationFlowDefinition.public B publishSubscribeChannel(java.util.concurrent.Executor executor, Consumer<PublishSubscribeSpec> publishSubscribeChannelConfigurer)
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.executor - the Executor to use.publishSubscribeChannelConfigurer - the Consumer to specify
PublishSubscribeSpec options including 'subflow' definition.IntegrationFlowDefinition.public B wireTap(IntegrationFlow flow)
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.flow - the IntegrationFlow for wire-tap subflow as an alternative to the wireTapChannel.IntegrationFlowDefinition.public B wireTap(java.lang.String wireTapChannel)
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.wireTapChannel - the MessageChannel bean name to wire-tap.IntegrationFlowDefinition.public B wireTap(org.springframework.messaging.MessageChannel wireTapChannel)
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.wireTapChannel - the MessageChannel to wire-tap.IntegrationFlowDefinition.public B wireTap(IntegrationFlow flow, Consumer<WireTapSpec> wireTapConfigurer)
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.flow - the IntegrationFlow for wire-tap subflow as an alternative to the wireTapChannel.wireTapConfigurer - the Consumer to accept options for the WireTap.IntegrationFlowDefinition.public B wireTap(java.lang.String wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer)
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.wireTapChannel - the MessageChannel bean name to wire-tap.wireTapConfigurer - the Consumer to accept options for the WireTap.IntegrationFlowDefinition.public B wireTap(org.springframework.messaging.MessageChannel wireTapChannel, Consumer<WireTapSpec> wireTapConfigurer)
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.wireTapChannel - the MessageChannel to wire-tap.wireTapConfigurer - the Consumer to accept options for the WireTap.IntegrationFlowDefinition.public B wireTap(WireTapSpec wireTapSpec)
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.wireTapSpec - the WireTapSpec to use.IntegrationFlowDefinition.public B controlBus()
Control Bus EI Pattern specific MessageHandler implementation
at the current IntegrationFlow chain position.IntegrationFlowDefinition.ExpressionCommandMessageProcessorpublic B controlBus(Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
Control Bus EI Pattern specific MessageHandler implementation
at the current IntegrationFlow chain position.endpointConfigurer - the Consumer to accept integration endpoint options.IntegrationFlowDefinition.ExpressionCommandMessageProcessor,
GenericEndpointSpecpublic B transform(java.lang.String expression)
Transformer EI Pattern specific MessageHandler implementation
for the SpEL Expression.expression - the Transformer Expression.IntegrationFlowDefinition.ExpressionEvaluatingTransformerpublic B transform(java.lang.String expression, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Transformer EI Pattern specific MessageHandler implementation
for the SpEL Expression.expression - the Transformer Expression.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.ExpressionEvaluatingTransformerpublic B transform(java.lang.Object service)
MessageTransformingHandler for the MethodInvokingTransformer
to invoke the discovered service method at runtime.service - the service to use.IntegrationFlowDefinition.ExpressionEvaluatingTransformerpublic B transform(java.lang.Object service, java.lang.String methodName)
MessageTransformingHandler for the MethodInvokingTransformer
to invoke the service method at runtime.service - the service to use.methodName - the method to invoke.IntegrationFlowDefinition.MethodInvokingTransformerpublic B transform(java.lang.Object service, java.lang.String methodName, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler for the MethodInvokingTransformer
to invoke the service method at runtime.service - the service to use.methodName - the method to invoke.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.ExpressionEvaluatingTransformerpublic <S,T> B transform(org.springframework.integration.transformer.GenericTransformer<S,T> genericTransformer)
MessageTransformingHandler instance for the provided GenericTransformer.S - the source type - 'transform from'.T - the target type - 'transform to'.genericTransformer - the GenericTransformer to populate.IntegrationFlowDefinition.MethodInvokingTransformer,
LambdaMessageProcessorpublic B transform(MessageProcessorSpec<?> messageProcessorSpec)
MessageTransformingHandler instance for the
MessageProcessor from provided MessageProcessorSpec.
.transform(Scripts.script("classpath:myScript.py").valiable("foo", bar()))
messageProcessorSpec - the MessageProcessorSpec to use.IntegrationFlowDefinition.MethodInvokingTransformerpublic B transform(MessageProcessorSpec<?> messageProcessorSpec, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler instance for the
MessageProcessor from provided MessageProcessorSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.
.transform(Scripts.script("classpath:myScript.py").valiable("foo", bar()),
e -> e.autoStartup(false))
messageProcessorSpec - the MessageProcessorSpec to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.MethodInvokingTransformerpublic <P,T> B transform(java.lang.Class<P> payloadType, org.springframework.integration.transformer.GenericTransformer<P,T> genericTransformer)
MessageTransformingHandler instance for the provided GenericTransformer
for the specific payloadType to convert at runtime.P - the payload type - 'transform from'.T - the target type - 'transform to'.payloadType - the Class for expected payload type.genericTransformer - the GenericTransformer to populate.IntegrationFlowDefinition.MethodInvokingTransformer,
LambdaMessageProcessorpublic <S,T> B transform(org.springframework.integration.transformer.GenericTransformer<S,T> genericTransformer, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler instance for the provided GenericTransformer.
In addition accept options for the integration endpoint using GenericEndpointSpec.S - the source type - 'transform from'.T - the target type - 'transform to'.genericTransformer - the GenericTransformer to populate.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.MethodInvokingTransformer,
LambdaMessageProcessor,
GenericEndpointSpecpublic <P,T> B transform(java.lang.Class<P> payloadType, org.springframework.integration.transformer.GenericTransformer<P,T> genericTransformer, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler instance for the provided GenericTransformer
for the specific payloadType to convert at runtime.
In addition accept options for the integration endpoint using GenericEndpointSpec.P - the payload type - 'transform from'.T - the target type - 'transform to'.payloadType - the Class for expected payload type.genericTransformer - the GenericTransformer to populate.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.MethodInvokingTransformer,
LambdaMessageProcessor,
GenericEndpointSpecpublic B filter(java.lang.String expression)
MessageFilter with MessageSelector for the provided SpEL expression.expression - the SpEL expression.IntegrationFlowDefinition.public B filter(java.lang.String expression, Consumer<FilterEndpointSpec> endpointConfigurer)
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))
expression - the SpEL expression.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.FilterEndpointSpecpublic B filter(java.lang.Object service)
MessageFilter with MethodInvokingSelector for the
discovered method of the provided service.service - the service to use.IntegrationFlowDefinition.MethodInvokingSelectorpublic B filter(java.lang.Object service, java.lang.String methodName)
MessageFilter with MethodInvokingSelector for the
method of the provided service.service - the service to use.methodName - the method to invokeIntegrationFlowDefinition.MethodInvokingSelectorpublic B filter(java.lang.Object service, java.lang.String methodName, Consumer<FilterEndpointSpec> endpointConfigurer)
MessageFilter with MethodInvokingSelector for the
method of the provided service.service - the service to use.methodName - the method to invokeendpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.MethodInvokingSelectorpublic <P> B filter(org.springframework.integration.core.GenericSelector<P> genericSelector)
MessageFilter with MethodInvokingSelector
for the provided GenericSelector.
Typically used with a Java 8 Lambda expression:
.filter("World"::equals)
P - the source payload type.genericSelector - the GenericSelector to use.IntegrationFlowDefinition.public B filter(MessageProcessorSpec<?> messageProcessorSpec)
MessageFilter with MethodInvokingSelector
for the MessageProcessor from
the provided MessageProcessorSpec.
.filter(Scripts.script(scriptResource).lang("ruby"))
messageProcessorSpec - the MessageProcessorSpec to use.IntegrationFlowDefinition.public B filter(MessageProcessorSpec<?> messageProcessorSpec, Consumer<FilterEndpointSpec> endpointConfigurer)
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))
messageProcessorSpec - the MessageProcessorSpec to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <P> B filter(java.lang.Class<P> payloadType, org.springframework.integration.core.GenericSelector<P> genericSelector)
MessageFilter with MethodInvokingSelector
for the provided GenericSelector.
Typically used with a Java 8 Lambda expression:
.filter(Date.class, p -> p.after(new Date()))
P - the source payload type.payloadType - the Class for desired payload type.genericSelector - the GenericSelector to use.IntegrationFlowDefinition.LambdaMessageProcessorpublic <P> B filter(org.springframework.integration.core.GenericSelector<P> genericSelector, Consumer<FilterEndpointSpec> endpointConfigurer)
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("World"::equals, e -> e.autoStartup(false))
P - the source payload type.genericSelector - the GenericSelector to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.FilterEndpointSpecpublic <P> B filter(java.lang.Class<P> payloadType, org.springframework.integration.core.GenericSelector<P> genericSelector, Consumer<FilterEndpointSpec> endpointConfigurer)
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))
P - the source payload type.payloadType - the Class for desired payload type.genericSelector - the GenericSelector to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.LambdaMessageProcessor,
FilterEndpointSpecpublic <H extends org.springframework.messaging.MessageHandler> B handleWithAdapter(Function<Adapters,MessageHandlerSpec<?,H>> adapters)
ServiceActivatingHandler for the selected protocol specific
MessageHandler implementation from Adapters factory.
Typically used with a Java 8 Lambda expression:
.handleWithAdapter(a ->
a.jmsGateway(this.jmsConnectionFactory)
.replyContainer()
.requestDestination("fooQueue"))
H - the target MessageHandler type.adapters - the Function to select and configure protocol specific
MessageHandler.IntegrationFlowDefinition.MessageHandlerSpecpublic <H extends org.springframework.messaging.MessageHandler> B handleWithAdapter(Function<Adapters,MessageHandlerSpec<?,H>> adapters, Consumer<GenericEndpointSpec<H>> endpointConfigurer)
ServiceActivatingHandler for the selected protocol specific
MessageHandler implementation from Adapters factory.
In addition accept options for the integration endpoint using GenericEndpointSpec.
Typically used with a Java 8 Lambda expression:
.handleWithAdapter(a ->
a.jmsGateway(this.jmsConnectionFactory)
.replyContainer()
.requestDestination("fooQueue"),
e -> e.autoStartup(false))
H - the target MessageHandler type.adapters - the Function to select and configure protocol specific
MessageHandler.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.MessageHandlerSpec,
GenericEndpointSpecpublic <H extends org.springframework.messaging.MessageHandler> B handle(MessageHandlerSpec<?,H> messageHandlerSpec)
ServiceActivatingHandler for the selected protocol specific
MessageHandler implementation from Namespace Factory:
.handle(Amqp.outboundAdapter(this.amqpTemplate).routingKeyExpression("headers.routingKey"))
H - the target MessageHandler type.messageHandlerSpec - the MessageHandlerSpec to configure protocol specific
MessageHandler.IntegrationFlowDefinition.public B handle(org.springframework.messaging.MessageHandler messageHandler)
ServiceActivatingHandler for the provided
MessageHandler implementation.
Can be used as Java 8 Lambda expression:
.handle(m -> System.out.println(m.getPayload())
messageHandler - the MessageHandler to use.IntegrationFlowDefinition.public B handle(java.lang.String beanName, java.lang.String methodName)
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime.beanName - the bean name to use.methodName - the method to invoke.IntegrationFlowDefinition.public B handle(java.lang.String beanName, java.lang.String methodName, Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime.
In addition accept options for the integration endpoint using GenericEndpointSpec.beanName - the bean name to use.methodName - the method to invoke.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B handle(java.lang.Object service)
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the discovered method for provided service at runtime.service - the service object to use.IntegrationFlowDefinition.public B handle(java.lang.Object service, java.lang.String methodName)
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime.
In addition accept options for the integration endpoint using GenericEndpointSpec.service - the service object to use.methodName - the method to invoke.IntegrationFlowDefinition.public B handle(java.lang.Object service, java.lang.String methodName, Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the method for provided bean at runtime.
In addition accept options for the integration endpoint using GenericEndpointSpec.service - the service object to use.methodName - the method to invoke.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <P> B handle(GenericHandler<P> handler)
ServiceActivatingHandler for the
MethodInvokingMessageProcessor
to invoke the provided GenericHandler at runtime.
Typically used with a Java 8 Lambda expression:
.<Integer>handle((p, h) -> p / 2)
P - the payload type to expect.handler - the handler to invoke.IntegrationFlowDefinition.LambdaMessageProcessorpublic <P> B handle(GenericHandler<P> handler, Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
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:
.<Integer>handle((p, h) -> p / 2, e -> e.autoStartup(false))
P - the payload type to expect.handler - the handler to invoke.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.LambdaMessageProcessor,
GenericEndpointSpecpublic <P> B handle(java.lang.Class<P> payloadType, GenericHandler<P> handler)
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)
P - the payload type to expect.payloadType - the expected payload type.
The accepted payload can be converted to this one at runtimehandler - the handler to invoke.IntegrationFlowDefinition.LambdaMessageProcessorpublic <P> B handle(java.lang.Class<P> payloadType, GenericHandler<P> handler, Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
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))
P - the payload type to expect.payloadType - the expected payload type.
The accepted payload can be converted to this one at runtimehandler - the handler to invoke.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.LambdaMessageProcessorpublic B handle(MessageProcessorSpec<?> messageProcessorSpec)
ServiceActivatingHandler for the
MessageProcessor from the provided
MessageProcessorSpec.
.handle(Scripts.script("classpath:myScript.ruby"))
messageProcessorSpec - the MessageProcessorSpec to use.IntegrationFlowDefinition.public B handle(MessageProcessorSpec<?> messageProcessorSpec, Consumer<GenericEndpointSpec<org.springframework.integration.handler.ServiceActivatingHandler>> endpointConfigurer)
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))
messageProcessorSpec - the MessageProcessorSpec to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <H extends org.springframework.messaging.MessageHandler> B handle(MessageHandlerSpec<?,H> messageHandlerSpec, Consumer<GenericEndpointSpec<H>> endpointConfigurer)
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))
H - the MessageHandler type.messageHandlerSpec - the MessageHandlerSpec to configure protocol specific
MessageHandler.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <H extends org.springframework.messaging.MessageHandler> B handle(H messageHandler, Consumer<GenericEndpointSpec<H>> endpointConfigurer)
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 -> System.out.println(m.getPayload(), e -> e.autoStartup(false))
H - the MessageHandler type.messageHandler - the MessageHandler to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B bridge(Consumer<GenericEndpointSpec<org.springframework.integration.handler.BridgeHandler>> endpointConfigurer)
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"))
endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B delay(java.lang.String groupId)
DelayHandler to the current integration flow position
with default options.groupId - the groupId for delayed messages in the
MessageGroupStore.IntegrationFlowDefinition.public B delay(java.lang.String groupId, Consumer<DelayerEndpointSpec> endpointConfigurer)
DelayHandler to the current integration flow position
with provided options.groupId - the groupId for delayed messages in the
MessageGroupStore.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.DelayerEndpointSpecpublic B delay(java.lang.String groupId, java.lang.String expression)
DelayHandler to the current integration flow position
with provided delayExpression.groupId - the groupId for delayed messages in the
MessageGroupStore.expression - the delay SpEL expression.IntegrationFlowDefinition.public <P> B delay(java.lang.String groupId, Function<org.springframework.messaging.Message<P>,java.lang.Object> function)
DelayHandler to the current integration flow position
with provided delayFunction.P - the expected payload type.groupId - the groupId for delayed messages in the
MessageGroupStore.function - the delay Function.IntegrationFlowDefinition.FunctionExpressionpublic <P> B delay(java.lang.String groupId, Function<org.springframework.messaging.Message<P>,java.lang.Object> function, Consumer<DelayerEndpointSpec> endpointConfigurer)
DelayHandler to the current integration flow position
with provided delayFunction.
Typically used with a Java 8 Lambda expression:
*
.<Foo>delay("delayer", m -> m.getPayload().getDate(),
c -> c.advice(this.delayedAdvice).messageStore(this.messageStore()))
P - the expected payload type.groupId - the groupId for delayed messages in the
MessageGroupStore.function - the delay Function.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.FunctionExpression,
DelayerEndpointSpecpublic B delay(java.lang.String groupId, java.lang.String expression, Consumer<DelayerEndpointSpec> endpointConfigurer)
DelayHandler to the current integration flow position
with provided delayExpression.groupId - the groupId for delayed messages in the
MessageGroupStore.expression - the delay SpEL expression.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.DelayerEndpointSpecpublic B enrich(Consumer<EnricherSpec> enricherConfigurer)
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)
.<Map<String, String>>headerFunction("foo", m -> m.getPayload().get("name")))
enricherConfigurer - the Consumer to provide ContentEnricher options.IntegrationFlowDefinition.EnricherSpecpublic B enrich(Consumer<EnricherSpec> enricherConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.ContentEnricher>> endpointConfigurer)
ContentEnricher to the current integration flow position
with provided options.
In addition accept options for the integration endpoint using GenericEndpointSpec.
Typically used with a Java 8 Lambda expression:
.enrich(e -> e.requestChannel("enrichChannel")
.requestPayload(Message::getPayload)
.shouldClonePayload(false)
.<Map<String, String>>headerFunction("foo", m -> m.getPayload().get("name")),
e -> e.autoStartup(false))
enricherConfigurer - the Consumer to provide ContentEnricher options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.EnricherSpec,
GenericEndpointSpecpublic B enrichHeaders(MapBuilder<?,java.lang.String,java.lang.Object> headers)
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"}))
headers - the MapBuilder to use.IntegrationFlowDefinition.public B enrichHeaders(MapBuilder<?,java.lang.String,java.lang.Object> headers, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
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))
headers - the MapBuilder to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B enrichHeaders(java.util.Map<java.lang.String,java.lang.Object> headers)
Map of values to be used for the
Message header enrichment.
values can apply an Expression
to be evaluated against a request Message.headers - the Map of headers to enrich.IntegrationFlowDefinition.public B enrichHeaders(java.util.Map<java.lang.String,java.lang.Object> headers, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
Map of values to be used for the
Message header enrichment.
values can apply an Expression
to be evaluated against a request Message.headers - the Map of headers to enrich.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer)
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")))
headerEnricherConfigurer - the Consumer to use.IntegrationFlowDefinition.HeaderEnricherSpecpublic B enrichHeaders(Consumer<HeaderEnricherSpec> headerEnricherConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler for
a HeaderEnricher
as the result of provided Consumer.
In addition accept options for the integration endpoint using GenericEndpointSpec.
Typically used with a Java 8 Lambda expression:
.enrichHeaders(
s -> s.header("one", new XPathExpressionEvaluatingHeaderValueMessageProcessor("/root/elementOne"))
.header("two", new XPathExpressionEvaluatingHeaderValueMessageProcessor("/root/elementTwo"))
.headerChannelsToString(),
c -> c.autoStartup(false).id("xpathHeaderEnricher"))
headerEnricherConfigurer - the Consumer to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.HeaderEnricherSpec,
GenericEndpointSpecpublic B split()
DefaultMessageSplitter with default options
to the current integration flow position.IntegrationFlowDefinition.public B split(Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.DefaultMessageSplitter>> endpointConfigurer)
DefaultMessageSplitter with provided options
to the current integration flow position.
Typically used with a Java 8 Lambda expression:
.split(s -> s.applySequence(false).get().getT2().setDelimiters(","))
endpointConfigurer - the Consumer to provide integration endpoint options
and for DefaultMessageSplitter.IntegrationFlowDefinition.SplitterEndpointSpecpublic B split(java.lang.String expression)
ExpressionEvaluatingSplitter with provided
SpEL expression.expression - the splitter SpEL expression.
and for ExpressionEvaluatingSplitter.IntegrationFlowDefinition.SplitterEndpointSpecpublic B split(java.lang.String expression, Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.ExpressionEvaluatingSplitter>> endpointConfigurer)
ExpressionEvaluatingSplitter with provided
SpEL expression.expression - the splitter SpEL expression.endpointConfigurer - the Consumer to provide integration endpoint options
and for ExpressionEvaluatingSplitter.IntegrationFlowDefinition.SplitterEndpointSpecpublic B split(java.lang.Object service)
MethodInvokingSplitter to evaluate the discovered
method of the service at runtime.service - the service to use.IntegrationFlowDefinition.MethodInvokingSplitterpublic B split(java.lang.Object service, java.lang.String methodName)
MethodInvokingSplitter to evaluate the provided
method of the service at runtime.service - the service to use.methodName - the method to invoke.IntegrationFlowDefinition.MethodInvokingSplitterpublic B split(java.lang.Object service, java.lang.String methodName, Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
MethodInvokingSplitter to evaluate the provided
method of the bean at runtime.
In addition accept options for the integration endpoint using GenericEndpointSpec.service - the service to use.methodName - the method to invoke.endpointConfigurer - the Consumer to provide integration endpoint options
and for MethodInvokingSplitter.IntegrationFlowDefinition.SplitterEndpointSpec,
MethodInvokingSplitterpublic B split(java.lang.String beanName, java.lang.String methodName)
MethodInvokingSplitter to evaluate the provided
method of the bean at runtime.beanName - the bean name to use.methodName - the method to invoke at runtime.IntegrationFlowDefinition.public B split(java.lang.String beanName, java.lang.String methodName, Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
MethodInvokingSplitter to evaluate the provided
method of the bean at runtime.
In addition accept options for the integration endpoint using GenericEndpointSpec.beanName - the bean name to use.methodName - the method to invoke at runtime.endpointConfigurer - the Consumer to provide integration endpoint options
and for MethodInvokingSplitter.IntegrationFlowDefinition.SplitterEndpointSpecpublic B split(MessageProcessorSpec<?> messageProcessorSpec)
MethodInvokingSplitter to evaluate the
MessageProcessor at runtime
from provided MessageProcessorSpec.
.split(Scripts.script("classpath:myScript.ruby"))
messageProcessorSpec - the splitter MessageProcessorSpec.IntegrationFlowDefinition.SplitterEndpointSpec,
ScriptSpecpublic B split(MessageProcessorSpec<?> messageProcessorSpec, Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
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))
messageProcessorSpec - the splitter MessageProcessorSpec.endpointConfigurer - the Consumer to provide integration endpoint options
and for MethodInvokingSplitter.IntegrationFlowDefinition.SplitterEndpointSpec,
ScriptSpecpublic <P> B split(java.lang.Class<P> payloadType, Function<P,?> splitter)
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)))))
P - the payload type.payloadType - the expected payload type. Used at runtime to convert received payload type to.splitter - the splitter Function.IntegrationFlowDefinition.LambdaMessageProcessorpublic <P> B split(Function<P,?> splitter, Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
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:
.<String>split(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))
P - the payload type.splitter - the splitter Function.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.LambdaMessageProcessor,
SplitterEndpointSpecpublic <P> B split(java.lang.Class<P> payloadType, Function<P,?> splitter, Consumer<SplitterEndpointSpec<org.springframework.integration.splitter.MethodInvokingSplitter>> endpointConfigurer)
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))
P - the payload type.payloadType - the expected payload type. Used at runtime to convert received payload type to.splitter - the splitter Function.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.LambdaMessageProcessor,
SplitterEndpointSpecpublic <S extends org.springframework.integration.splitter.AbstractMessageSplitter> B split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec)
AbstractMessageSplitter to the current integration
flow position.S - the AbstractMessageSplittersplitterMessageHandlerSpec - the MessageHandlerSpec to populate.IntegrationFlowDefinition.SplitterEndpointSpecpublic <S extends org.springframework.integration.splitter.AbstractMessageSplitter> B split(MessageHandlerSpec<?,S> splitterMessageHandlerSpec, Consumer<SplitterEndpointSpec<S>> endpointConfigurer)
AbstractMessageSplitter to the current integration
flow position.S - the AbstractMessageSplittersplitterMessageHandlerSpec - the MessageHandlerSpec to populate.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.SplitterEndpointSpecpublic B split(org.springframework.integration.splitter.AbstractMessageSplitter splitter)
AbstractMessageSplitter to the current integration
flow position.splitter - the AbstractMessageSplitter to populate.IntegrationFlowDefinition.SplitterEndpointSpecpublic <S extends org.springframework.integration.splitter.AbstractMessageSplitter> B split(S splitter, Consumer<SplitterEndpointSpec<S>> endpointConfigurer)
AbstractMessageSplitter to the current integration
flow position.S - the AbstractMessageSplittersplitter - the AbstractMessageSplitter to populate.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.SplitterEndpointSpecpublic B headerFilter(java.lang.String... headersToRemove)
HeaderFilter to the current StandardIntegrationFlow.headersToRemove - the array of headers (or patterns)
to remove from MessageHeaders.IntegrationFlowDefinition.public B headerFilter(java.lang.String headersToRemove, boolean patternMatch)
HeaderFilter to the current StandardIntegrationFlow.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.IntegrationFlowDefinition.public B headerFilter(org.springframework.integration.transformer.HeaderFilter headerFilter, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler for the provided
HeaderFilter.headerFilter - the HeaderFilter to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B claimCheckIn(org.springframework.integration.store.MessageStore messageStore)
MessageTransformingHandler for the ClaimCheckInTransformer
with provided MessageStore.messageStore - the MessageStore to use.IntegrationFlowDefinition.public B claimCheckIn(org.springframework.integration.store.MessageStore messageStore, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler for the ClaimCheckInTransformer
with provided MessageStore.
In addition accept options for the integration endpoint using GenericEndpointSpec.messageStore - the MessageStore to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B claimCheckOut(org.springframework.integration.store.MessageStore messageStore)
MessageTransformingHandler for the ClaimCheckOutTransformer
with provided MessageStore.
The removeMessage option of ClaimCheckOutTransformer is to false.messageStore - the MessageStore to use.IntegrationFlowDefinition.public B claimCheckOut(org.springframework.integration.store.MessageStore messageStore, boolean removeMessage)
MessageTransformingHandler for the ClaimCheckOutTransformer
with provided MessageStore and removeMessage flag.messageStore - the MessageStore to use.removeMessage - the removeMessage boolean flag.IntegrationFlowDefinition.ClaimCheckOutTransformer.setRemoveMessage(boolean)public B claimCheckOut(org.springframework.integration.store.MessageStore messageStore, boolean removeMessage, Consumer<GenericEndpointSpec<org.springframework.integration.transformer.MessageTransformingHandler>> endpointConfigurer)
MessageTransformingHandler for the ClaimCheckOutTransformer
with provided MessageStore and removeMessage flag.
In addition accept options for the integration endpoint using GenericEndpointSpec.messageStore - the MessageStore to use.removeMessage - the removeMessage boolean flag.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpec,
ClaimCheckOutTransformer.setRemoveMessage(boolean)public B resequence()
ResequencingMessageHandler with default options.IntegrationFlowDefinition.@Deprecated public B resequence(Consumer<ResequencerSpec> resequencerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.aggregator.ResequencingMessageHandler>> endpointConfigurer)
resequence(Consumer)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'"),
e -> e.phase(100))
resequencerConfigurer - the Consumer to provide ResequencingMessageHandler options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B resequence(Consumer<ResequencerSpec> resequencer)
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))
resequencer - the Consumer to provide ResequencingMessageHandler options.IntegrationFlowDefinition.ResequencerSpecpublic B aggregate()
AggregatingMessageHandler with default options.IntegrationFlowDefinition.@Deprecated public B aggregate(Consumer<AggregatorSpec> aggregatorConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.aggregator.AggregatingMessageHandler>> endpointConfigurer)
aggregate(Consumer)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),
e -> e.applySequence(false))
aggregatorConfigurer - the Consumer to provide AggregatingMessageHandler options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.GenericEndpointSpecpublic B aggregate(Consumer<AggregatorSpec> aggregator)
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))
aggregator - the Consumer to provide AggregatingMessageHandler options.IntegrationFlowDefinition.AggregatorSpecpublic B route(java.lang.String beanName, java.lang.String method)
MethodInvokingRouter for provided bean and its method
with default options.beanName - the bean to use.method - the method to invoke at runtime.IntegrationFlowDefinition.public B route(java.lang.String beanName, java.lang.String method, Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
MethodInvokingRouter for provided bean and its method
with provided options from RouterSpec.beanName - the bean to use.method - the method to invoke at runtime.routerConfigurer - the Consumer to provide MethodInvokingRouter options.IntegrationFlowDefinition.public B route(java.lang.String beanName, java.lang.String method, Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
MethodInvokingRouter for provided bean and its method
with provided options from RouterSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.beanName - the bean to use.method - the method to invoke at runtime.routerConfigurer - the Consumer to provide MethodInvokingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B route(java.lang.Object service)
MethodInvokingRouter for the discovered method
of the provided service and its method with default options.service - the bean to use.IntegrationFlowDefinition.MethodInvokingRouterpublic B route(java.lang.Object service, java.lang.String methodName)
MethodInvokingRouter for the method
of the provided service and its method with default options.service - the service to use.methodName - the method to invoke.IntegrationFlowDefinition.MethodInvokingRouterpublic B route(java.lang.Object service, java.lang.String methodName, Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
MethodInvokingRouter for the method
of the provided service and its method with provided options from RouterSpec.service - the service to use.methodName - the method to invoke.routerConfigurer - the Consumer to provide MethodInvokingRouter options.IntegrationFlowDefinition.MethodInvokingRouterpublic B route(java.lang.Object service, java.lang.String methodName, Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
MethodInvokingRouter for the method
of the provided service and its method with provided options from RouterSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.service - the service to use.methodName - the method to invoke.routerConfigurer - the Consumer to provide MethodInvokingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.MethodInvokingRouterpublic B route(java.lang.String expression)
ExpressionEvaluatingRouter for provided SpEL expression
with default options.expression - the expression to use.IntegrationFlowDefinition.public <T> B route(java.lang.String expression, Consumer<RouterSpec<T,org.springframework.integration.router.ExpressionEvaluatingRouter>> routerConfigurer)
ExpressionEvaluatingRouter for provided SpEL expression
with provided options from RouterSpec.T - the target result type.expression - the expression to use.routerConfigurer - the Consumer to provide ExpressionEvaluatingRouter options.IntegrationFlowDefinition.public <T> B route(java.lang.String expression, Consumer<RouterSpec<T,org.springframework.integration.router.ExpressionEvaluatingRouter>> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.ExpressionEvaluatingRouter>> endpointConfigurer)
ExpressionEvaluatingRouter for provided bean and its method
with provided options from RouterSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.T - the target result type.expression - the expression to use.routerConfigurer - the Consumer to provide ExpressionEvaluatingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <S,T> B route(Function<S,T> router)
MethodInvokingRouter for provided Function
with default options.
Typically used with a Java 8 Lambda expression:
.route(p -> p.equals("foo") || p.equals("bar") ? new String[] {"foo", "bar"} : null)
S - the source payload type.T - the target result type.router - the Function to use.IntegrationFlowDefinition.public <S,T> B route(Function<S,T> router, Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
MethodInvokingRouter for provided Function
with provided options from RouterSpec.
Typically used with a Java 8 Lambda expression:
.<Integer, Boolean>route(p -> p % 2 == 0,
m -> m.channelMapping("true", "evenChannel")
.subFlowMapping("false", f ->
f.<Integer>handle((p, h) -> p * 3)))
S - the source payload type.T - the target result type.router - the Function to use.routerConfigurer - the Consumer to provide MethodInvokingRouter options.IntegrationFlowDefinition.public <S,T> B route(java.lang.Class<S> payloadType, Function<S,T> router)
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)
S - the source payload type.T - the target result type.payloadType - the expected payload type.router - the Function to use.IntegrationFlowDefinition.LambdaMessageProcessorpublic <S,T> B route(java.lang.Class<S> payloadType, Function<S,T> router, Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
MethodInvokingRouter for provided Function
and payload type and options from RouterSpec.
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)))
S - the source payload type.T - the target result type.payloadType - the expected payload type.router - the Function to use.routerConfigurer - the Consumer to provide MethodInvokingRouter options.IntegrationFlowDefinition.LambdaMessageProcessorpublic <S,T> B route(Function<S,T> router, Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
MethodInvokingRouter for provided Function
with provided options from RouterSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.
Typically used with a Java 8 Lambda expression:
.<Integer, Boolean>route(p -> p % 2 == 0,
m -> m.channelMapping("true", "evenChannel")
.subFlowMapping("false", f ->
f.<Integer>handle((p, h) -> p * 3)),
e -> e.applySequence(false))
S - the source payload type.T - the target result type.router - the Function to use.routerConfigurer - the Consumer to provide MethodInvokingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <P,T> B route(java.lang.Class<P> payloadType, Function<P,T> router, Consumer<RouterSpec<T,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
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)),
e -> e.applySequence(false))
P - the source payload type.T - the target result type.payloadType - the expected payload type.router - the Function to use.routerConfigurer - the Consumer to provide MethodInvokingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.LambdaMessageProcessorpublic B route(MessageProcessorSpec<?> messageProcessorSpec)
MethodInvokingRouter for the MessageProcessor
from the provided MessageProcessorSpec with default options.
.route(Scripts.script(myScriptResource).lang("groovy").refreshCheckDelay(1000))
messageProcessorSpec - the MessageProcessorSpec to use.IntegrationFlowDefinition.public B route(MessageProcessorSpec<?> messageProcessorSpec, Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer)
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)))
messageProcessorSpec - the MessageProcessorSpec to use.routerConfigurer - the Consumer to provide MethodInvokingRouter options.IntegrationFlowDefinition.public B route(MessageProcessorSpec<?> messageProcessorSpec, Consumer<RouterSpec<java.lang.Object,org.springframework.integration.router.MethodInvokingRouter>> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.MethodInvokingRouter>> endpointConfigurer)
MethodInvokingRouter for the MessageProcessor
from the provided MessageProcessorSpec with default options.
In addition accept options for the integration endpoint using GenericEndpointSpec.
.route(Scripts.script(myScriptResource).lang("groovy").refreshCheckDelay(1000),
m -> m.channelMapping("true", "evenChannel")
.subFlowMapping("false", f ->
f.<Integer>handle((p, h) -> p * 3)),
e -> e.applySequence(false))
messageProcessorSpec - the MessageProcessorSpec to use.routerConfigurer - the Consumer to provide MethodInvokingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public <K,R extends org.springframework.integration.router.AbstractMappingMessageRouter> B route(R router, Consumer<RouterSpec<K,R>> routerConfigurer, Consumer<GenericEndpointSpec<R>> endpointConfigurer)
AbstractMappingMessageRouter implementation
with options from RouterSpec and endpoint options from GenericEndpointSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.K - the channelKey mapping type.R - the AbstractMappingMessageRouter type.router - the AbstractMappingMessageRouter to populate.routerConfigurer - the Consumer to provide MethodInvokingRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer)
RecipientListRouter options from 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"))))
routerConfigurer - the Consumer to provide RecipientListRouter options.IntegrationFlowDefinition.public B routeToRecipients(Consumer<RecipientListRouterSpec> routerConfigurer, Consumer<GenericEndpointSpec<org.springframework.integration.router.RecipientListRouter>> endpointConfigurer)
RecipientListRouter options from RecipientListRouterSpec.
In addition accept options for the integration endpoint using GenericEndpointSpec.
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"))),
e -> e.applySequence(false))
routerConfigurer - the Consumer to provide RecipientListRouter options.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B route(org.springframework.integration.router.AbstractMessageRouter router)
AbstractMessageRouter implementation to the
current integration flow position.router - the AbstractMessageRouter to populate.IntegrationFlowDefinition.public <R extends org.springframework.integration.router.AbstractMessageRouter> B route(R router, Consumer<GenericEndpointSpec<R>> endpointConfigurer)
AbstractMessageRouter implementation to the
current integration flow position.
In addition accept options for the integration endpoint using GenericEndpointSpec.R - the AbstractMessageRouter type.router - the AbstractMessageRouter to populate.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B gateway(java.lang.String requestChannel)
GatewayMessageHandler for the provided
requestChannel to send a request with default options.
Uses RequestReplyExchanger Proxy
on the background.requestChannel - the MessageChannel bean name.IntegrationFlowDefinition.public B gateway(java.lang.String requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer)
GatewayMessageHandler for the provided
requestChannel to send a request with options from GatewayEndpointSpec.
Uses RequestReplyExchanger Proxy
on the background.requestChannel - the MessageChannel bean name.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B gateway(org.springframework.messaging.MessageChannel requestChannel)
GatewayMessageHandler for the provided
requestChannel to send a request with default options.
Uses RequestReplyExchanger Proxy
on the background.requestChannel - the MessageChannel to use.IntegrationFlowDefinition.public B gateway(org.springframework.messaging.MessageChannel requestChannel, Consumer<GatewayEndpointSpec> endpointConfigurer)
GatewayMessageHandler for the provided
requestChannel to send a request with options from GatewayEndpointSpec.
Uses RequestReplyExchanger Proxy
on the background.requestChannel - the MessageChannel to use.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B gateway(IntegrationFlow flow)
GatewayMessageHandler for the provided
subflow.
Typically used with a Java 8 Lambda expression:
.gateway(f -> f.transform("From Gateway SubFlow: "::concat))
flow - the IntegrationFlow to to send a request message and wait for reply.IntegrationFlowDefinition.public B gateway(IntegrationFlow flow, Consumer<GatewayEndpointSpec> endpointConfigurer)
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))
flow - the IntegrationFlow to to send a request message and wait for reply.endpointConfigurer - the Consumer to provide integration endpoint options.IntegrationFlowDefinition.public B log()
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.
IntegrationFlowDefinition.public B log(org.springframework.integration.handler.LoggingHandler.Level level)
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.
level - the LoggingHandler.Level.IntegrationFlowDefinition.public B log(java.lang.String category)
WireTap for the currentMessageChannel
with the LoggingHandler subscriber for the provided logging category
and INFO logging level.
The full request Message will be logged.
category - the logging category to use.IntegrationFlowDefinition.public B log(org.springframework.integration.handler.LoggingHandler.Level level, java.lang.String category)
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.
level - the LoggingHandler.Level.category - the logging category to use.IntegrationFlowDefinition.public B log(org.springframework.integration.handler.LoggingHandler.Level level, java.lang.String category, java.lang.String logExpression)
WireTap for the currentMessageChannel
with the LoggingHandler subscriber for the provided
LoggingHandler.Level logging level, logging category
and SpEL expression for the log message.level - the LoggingHandler.Level.category - the logging category.logExpression - the SpEL expression to evaluate logger message at runtime
against the request Message.IntegrationFlowDefinition.public <P> B log(Function<org.springframework.messaging.Message<P>,java.lang.Object> function)
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.P - the expected payload type.
against the request Message.function - the function to evaluate logger message at runtimeIntegrationFlowDefinition.public B log(org.springframework.expression.Expression logExpression)
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.logExpression - the Expression to evaluate logger message at runtime
against the request Message.IntegrationFlowDefinition.public B log(org.springframework.integration.handler.LoggingHandler.Level level, org.springframework.expression.Expression logExpression)
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.level - the LoggingHandler.Level.logExpression - the Expression to evaluate logger message at runtime
against the request Message.IntegrationFlowDefinition.public B log(java.lang.String category, org.springframework.expression.Expression logExpression)
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.category - the logging category.logExpression - the Expression to evaluate logger message at runtime
against the request Message.IntegrationFlowDefinition.public <P> B log(org.springframework.integration.handler.LoggingHandler.Level level, Function<org.springframework.messaging.Message<P>,java.lang.Object> function)
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.P - the expected payload type.
against the request Message.level - the LoggingHandler.Level.function - the function to evaluate logger message at runtimeIntegrationFlowDefinition.public <P> B log(java.lang.String category, Function<org.springframework.messaging.Message<P>,java.lang.Object> function)
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.P - the expected payload type.
against the request Message.category - the logging category.function - the function to evaluate logger message at runtimeIntegrationFlowDefinition.public <P> B log(org.springframework.integration.handler.LoggingHandler.Level level, java.lang.String category, Function<org.springframework.messaging.Message<P>,java.lang.Object> function)
WireTap for the currentMessageChannel
with the LoggingHandler subscriber for the provided
LoggingHandler.Level logging level, logging category
and Function for the log message.P - the expected payload type.
against the request Message.level - the LoggingHandler.Level.category - the logging category.function - the function to evaluate logger message at runtimeIntegrationFlowDefinition.public B log(org.springframework.integration.handler.LoggingHandler.Level level, java.lang.String category, org.springframework.expression.Expression logExpression)
WireTap for the currentMessageChannel
with the LoggingHandler subscriber for the provided
LoggingHandler.Level logging level, logging category
and SpEL expression for the log message.level - the LoggingHandler.Level.category - the logging category.logExpression - the Expression to evaluate logger message at runtime
against the request Message.IntegrationFlowDefinition.public B scatterGather(org.springframework.messaging.MessageChannel scatterChannel)
ScatterGatherHandler to the current integration flow position
based on the provided MessageChannel for scattering function
and default AggregatorSpec for gathering function.scatterChannel - the MessageChannel for scatting requests.IntegrationFlowDefinition.public B scatterGather(org.springframework.messaging.MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer)
ScatterGatherHandler to the current integration flow position
based on the provided MessageChannel for scattering function
and AggregatorSpec for gathering function.scatterChannel - the MessageChannel for scatting requests.gatherer - the Consumer for AggregatorSpec to configure gatherer.
Can be null.IntegrationFlowDefinition.public B scatterGather(org.springframework.messaging.MessageChannel scatterChannel, Consumer<AggregatorSpec> gatherer, Consumer<ScatterGatherSpec> scatterGather)
ScatterGatherHandler to the current integration flow position
based on the provided MessageChannel for scattering function
and AggregatorSpec for gathering function.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.IntegrationFlowDefinition.public B scatterGather(Consumer<RecipientListRouterSpec> scatterer)
ScatterGatherHandler to the current integration flow position
based on the provided RecipientListRouterSpec for scattering function
and default AggregatorSpec for gathering function.scatterer - the Consumer for RecipientListRouterSpec to configure scatterer.IntegrationFlowDefinition.public B scatterGather(Consumer<RecipientListRouterSpec> scatterer, Consumer<AggregatorSpec> gatherer)
ScatterGatherHandler to the current integration flow position
based on the provided RecipientListRouterSpec for scattering function
and AggregatorSpec for gathering function.scatterer - the Consumer for RecipientListRouterSpec to configure scatterer.
Can be null.gatherer - the Consumer for AggregatorSpec to configure gatherer.
Can be null.IntegrationFlowDefinition.public B scatterGather(Consumer<RecipientListRouterSpec> scatterer, Consumer<AggregatorSpec> gatherer, Consumer<ScatterGatherSpec> scatterGather)
ScatterGatherHandler to the current integration flow position
based on the provided RecipientListRouterSpec for scattering function
and AggregatorSpec for gathering function.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.IntegrationFlowDefinition.public <T> org.reactivestreams.Publisher<org.springframework.messaging.Message<T>> toReactivePublisher()
Publisher bean.T - the payload typePublisherpublic <T> org.reactivestreams.Publisher<org.springframework.messaging.Message<T>> toReactivePublisher(java.util.concurrent.Executor executor)
Publisher bean.T - the payload typeexecutor - the managed Executor to be used for the background task to
poll messages from the PollableChannel.
Defaults to Executors.newSingleThreadExecutor().Publisherprotected final B _this()
protected StandardIntegrationFlow get()