Enables annotation support for Message Endpoints.
Default output channel for the @Publisher annotation support.
Allows you to configure org.springframework.integration.transaction.DefaultTransactionSynchronizationFactory
This implementation of org.springframework.integration.transaction.TransactionSynchronizationFactory
allows you to configure SpEL expressions, with their execution being coordinated (synchronized) with a
transaction - see {TransactionSynchronization}. Expressions for before-commit, after.-commit, and after-rollback
are supported, together with a channel for each where the evaluation result (if any) will be sent.
For each sub-element you can specify 'expression' and/or 'channel' attributes.
If only the 'channel' attribute is present the received Message will be sent there as part of a particular synchronization scenario.
If only the 'expression' attribute is present and the result of an expression is a non-Null value, a Message with the
result as the payload will be generated and sent to a default channel (NullChannel) and will appear in the logs.
If you want the evaluation result to go to a specific channel add a 'channel' attribute. If the result of an expression is null
or void, no Message will be generated.
Defines the ApplicationEventMulticaster to use for this
ApplicationContext.
The "task-executor"
reference is optional. If not provided, an
instance of
ThreadPoolTaskExecutor will be created by default.
).
]]>
Defines a Point-to-Point MessageChannel.
See 'PointToPointChannelParser' source code for 'MessageChannel' implementaitons.
Identifies this channel as a Queue style
channel
Identifies this channel as a Queue style
channel where messages could be prioritized
based on custom logic
Provides MessageDispatcher configuration
(i.e., failover, load-balancing, task-executor)
Defines a queue for messages. If 'capacity' is specified, it will be a
bounded queue. A custom Queue implementation can be injected using the 'ref' attribute.
Capacity for this queue. Default capacity is 0 which means
this queue will accumulate as many
messages as available resources allow.
This attribute is mutually exclusive with the "message-store"
and "ref" attributes (only one can be specified).
Reference to a MessageGroupStore that can be used to buffer the messages. If a message store is
specified then it will store messages for this channel with a correlation key equal to the
channel name. If you need
more control over the correlation key (e.g. two channels in the same
application share a name), then you need to
look to the queue implementation itself and provide an
explicit instance via the "ref" attribute, or else maybe the
message store has a way to specify a region or similar additional
tag for messages. This attribute is
mutually
exclusive with the "capacity" and "ref" attributes (only one can be specified).
Reference to a Queue that can be used to buffer the messages. This attribute is
mutually exclusive with the "capacity" and "message-store" attributes (only one can be specified).
Defines a queue with priority-ordering for message reception.
Capacity for this queue. Default capacity is 0 which means
this queue will accumulate as many
messages as available resources allow.
A reference to a bean that implements 'org.springframework.integration.store.PriorityCapableChannelMessageStore'.
A message store that supports priority in a manner defined by the store. When set, the underlying
channel will be a 'QueueChannel' that delegates to a 'MessageGroupQueue' backed by the store.
Not allowed if 'comparator' is set.
Defines a rendezvous queue where a sender will block until the receiver
arrives or vice-versa.
Defines the dispatching configuration for a non-buffering channel
(i.e. one without a queue).
A reference to a bean that implements the 'org.springframework.integration.dispatcher.LoadBalancingStrategy'.
This attribute is mutually exclusive with 'load-balancer'.
Defines a load-balancing strategy for the channel's dispatcher.
The default is a round-robin load balancer.
This attribute is mutually exclusive with 'load-balancer-ref'.
Specifies whether this dispatcher has failover enabled. By default,
failover will be enabled. Set
this to 'false' to disable it.
When enabled and message delivery to the primary Message Handler fails,
an attempt
will be made to deliver the message to the next handler
and so on...
Primary, secondary etc... is determined by the
load-balancing strategy in
use
(e.g. round-robin). If no load-balancer strategy is configured, the
order will
be fixed
in a sequence determined by the 'order' attribute on the
Message Handlers
(or the @Ordered annotation on adapted
methods).
).
]]>
[DEFAULT] Defines a Round Robin dispatching strategy which allows
load balancing of messages
between multiple Message Handlers. Which
message
handler receives the message first is determined by the 'order'
attribute
of such Message Handler.
No LoadBalancingStrategy will be used.
Defines a 'org.springframework.integration.channel.PublishSubscribeChannel' that broadcasts messages to
its subscribers.
).
]]>
Specify whether Exceptions thrown by any subscribed handler should be
ignored (only logged).
Specify whether the sequence size, sequence number, and correlation id
headers should be set on
Messages that are sent through this channel.
Defines a message channel.
Defines a Messaging Gateway - 'org.springframework.integration.gateway.GatewayProxyFactoryBean'.
Defines a Messaging Gateway to be used within a chain.
Defines a Polling Channel Adapter for the
'org.springframework.integration.endpoint.MethodInvokingMessageSource',
or 'org.springframework.integration.endpoint.ExpressionEvaluatingMessageSource'
or 'org.springframework.integration.scripting.ScriptExecutingMessageSource'
that receives from a MessageSource and sends to a
MessageChannel.
Note, when using the 'expression' attribute, or 'expression' or 'script' sub-element,
there is not yet a root Message object and therefore
the 'payload' and 'headers' properties are not available in the expression or script.
Maximum amount of time in milliseconds to wait when sending a message to the channel
if such channel may block.
For example, a Queue Channel can block until space is available if its maximum capacity
has been reached.
Defaults to '-1' - blocking indefinitely.
Defines a Polling Channel Adapter for the
'org.springframework.integration.resource.ResourceRetrievingMessageSource' that receives Resource(s)
and sends them to a MessageChannel identified via 'channel' attribute.
Component identifier
Channel where Message will be sent to
Reference to the implementation of org.springframework.integration.util.CollectionFilter.
Location pattern expression (e.g., "/**/*.txt")
Reference to a org.springframework.core.io.support.ResourcePatternResolver.
Maximum amount of time in milliseconds to wait when sending a message to the channel if such channel may block.
For example, a Queue Channel can block until space is available if its maximum capacity has been reached.
Defines an endpoint for the
'org.springframework.integration.handler.ExpressionEvaluatingMessageHandler'
or 'org.springframework.integration.handler.MethodInvokingMessageHandler'.
Defines a Message Producing Endpoint for the
'org.springframework.integration.handler.LoggingHandler'.
Provide a name for the logger. This is useful when there are multiple logging Channel Adapters configured,
and you would like to differentiate them within the actual log. By default the logger name will be the
fully qualified class name of the LoggingHandler implementation.
A reference to a bean defined in the application context.
A method defined on the bean referenced by 'ref' attribute
SpEL expression to be evaluated for each triggered execution.
The result of the evaluation will be
passed as the payload of
the Message that is sent to the MessageChannel.
Identifies channel attached to this adapter. Depending on the type of the adapter
this channel could be the receiving channel (e.g., outbound-channel-adapter) or channel where
messages will be sent to by this adapter (e.g., inbound-channel-adapter).
Specifies the order for invocation when this endpoint is connected as a
subscriber to a channel. This is particularly relevant when that channel
is using a "failover" dispatching strategy. It has no effect when this
endpoint itself is a Polling Consumer for a channel with a queue.
Defines an endpoint for the 'org.springframework.integration.handler.ServiceActivatingHandler'
for exposing any bean reference as a service that
receives request Messages
from an 'input-channel' and may send reply
Messages to an 'output-channel'. The 'ref' may point to an instance
that
has either a single public method or a method with the
@ServiceActivator annotation. Otherwise, the 'method'
attribute
should be provided along with 'ref'.
and this flag is 'true', the calling
thread is released immediately. The remaining flow will run on the thread that completes
the future. If 'false' (default), the future will be sent as the payload of the result
message. This has no effect with any other type of return.
]]>
Header patterns ("xxx*", "*xxx", "*xxx*" or "xxx*yyy")
that will NOT be copied from the inbound message.
'*' means do not copy headers at all.
Base type for Message-handling endpoints.
'id' value:
- Identifies the underlying Spring bean definition (AbstractEndpoint)
- as MessageHandler bean alias together with suffix '.handler'
A reference to a bean that implements the handler.
The bean can be an implementation of the MessageHandler interface or a POJO
A method defined on the bean referenced by 'ref' attribute
Base type for Message Handlers.
A reference to a bean that implements the handler.
The bean can be an implementation of the MessageHandler interface or a POJO
A method defined on the bean referenced by 'ref' attribute
Defines a Consumer Endpoint for the 'org.springframework.integration.transformer.ContentEnricher'
that passes a Message to its request-channel
and then expects a reply Message. The reply Message then becomes
the root object for evaluation of expressions to enrich the
target payload.
Each property sub-element provides the name of a property (via the required 'name' attribute).
That property should be settable on the target payload instance. Exactly one of the 'value'
or 'expression' attributes must be provided as well. The former for a literal value to set,
and the latter for a SpEL expression to be evaluated. The root object of the evaluation
context is the Message that was returned from the flow initiated by this enricher.
Each header sub-element provides the name of a message header (via the required 'name' attribute).
Exactly one of the 'value' or 'expression' attributes must be provided as well.
The former for a literal value to set, and the latter for a SpEL expression to be evaluated.
The root object of the evaluation context is the Message that was returned from the flow initiated
by this enricher.
Boolean value to indicate whether this header value should overwrite an
existing header value. Unlike the Header Enricher, this attribute is 'true'
by default, similar to the 'property' attribute.
Channel to which a Message will be sent to get the data to use
for enrichment. This attribute is optional. Not specifying a
'request-channel' is useful in situations, where only static
values shall be used for enrichment using the 'property'
sub-element.
Channel where a reply Message is expected. This is optional; typically the auto-generated
temporary reply channel is sufficient.
Used when exceptions occur in a downstream flow and allows the error
handling flow to return an alternative object to use for enrichment.
If no "error-channel" reference is provided,
this enricher will propagate Exceptions to the caller.
Boolean value indicating whether any payload that implements Cloneable should be cloned
prior to sending the Message to the request channel for acquiring the enriching data.
The cloned version would be used as the target payload for the ultimate reply.
If the payload does NOT implement 'Cloneable', then setting this
attribute to 'true' has NO effect.
Default is false.
Defines a Consumer Endpoint for the 'org.springframework.integration.handler.DelayHandler'
that passes a Message to the output-channel after a delay.
The delay may be dynamically determined by evaluating an expression
(such as a Message header) or fallback to the
'default-delay' of this endpoint.
'transactional' and 'advice-chain' elements specify the configuration List of AOP Advice
to proxy DelayHandler's 'release Message task'.
Specify the SpEL expression that evaluates to the delay value in milliseconds,
or a java.util.Date.
Specify the default delay in milliseconds. This value can be set to 0
if the only Messages
that
should be delayed are those with a particular expression evaluation result.
Specify the SpEL expression that evaluates to the delay value in milliseconds,
or a java.util.Date.
Specify whether Exceptions thrown by 'expression' evaluation should be
ignored (only logged). In this case case the delayer will fall back to the
to the 'default-delay'. Default behaviour.
If this attribute is specified as 'false', any
'expression' evaluation Exception will be thrown to the caller without
falling back to the to the 'default-delay'.
Provide a reference to the TaskScheduler instance to which
this endpoint should
delegate when scheduling the sending of delayed Messages. If not
provided, the default scheduler
registered in the ApplicationContext {ThreadPoolTaskScheduler} will be
used.
Provide a reference to the MessageStore instance that should be used
to store Messages while
awaiting the delay.
Defines a Consumer Endpoint for the 'org.springframework.integration.aggregator.BarrierMessageHandler'
that suspends a thread until a corresponding release message is received.
The endpoint's message handler is a 'BarrierMessageHandler'.
The time in milliseconds to suspend the thread. See `requires-reply`.
Also, if the trigger message is received first, the time that thread will
wait before logging an error and exiting.
Specify whether the barrier must return a non-null value. This value will be
'false' by default, but if set to 'true', a ReplyRequiredException will be thrown when
the barrier times out.
A reference to a bean that implements the decision algorithm as to whether a given
message group is complete. The bean can be an implementation of the
CorrelationStrategy interface or a POJO.
A method defined on the bean referenced by correlation-strategy, that implements the
correlation decision algorithm
A SpEL expression which implements correlation decision
algorithm to apply to the Message (e.g., payload.getPerson().getId() - correlate
based on the 'id' of the 'person' attribute of the message payload object)
A reference to a bean that implements 'MessageGroupProcessor'. The processor is invoked to
produce the result when the release is triggered. By default the payloads of the two
messages are aggregated as a 'Collection' and the message headers are merged.
The message channel to which to send a trigger message if it arrives after the main
thread has timed out.
Defines a Consumer Endpoint for the 'org.springframework.integration.handler.BridgeHandler'
that passes a Message to the output-channel without modifying it.
Defines a Consumer Endpoint for the 'org.springframework.integration.handler.MessageHandlerChain'
composed of a chain of Message Handlers.
Defines a top-level poller - 'org.springframework.integration.scheduling.PollerMetadata'.
Defines the configuration metadata for a poller.
Run each poll task in a transaction; mutually exclusive
with 'advice-chain'; add a transaction advice if you need transactions
in addition to other advices.
A chain of nested AOP 'Advice' objects applied to the poller task.
Mutually exclusive with 'transactional'.
Fixed delay trigger (in milliseconds).
Allows this poller to reference another instance of a top-level poller.
[IMPORTANT] - This attribute is only allowed on inner poller definitions.
Defining this attribute on a top-level poller definition will result in a configuration exception.
Fixed rate trigger (in milliseconds).
Cron trigger.
Only applies to polling consumers - the time the poll thread will wait
after the trigger for a new message to arrive. Defaults to 1000 (1 second).
For polled inbound channel adapters, whether or not the polling thread blocks is
dependent on the message source implementation.
The maximum number of messages that will be produced for each poll. Defaults to
infinity (indicated by -1) for polling consumers, and 1 for polled
inbound channel adapters.
Defines a MessageSelector chain.
Provides a MessageSelector reference. If a method attribute is set the
referred bean doesn't need
to implement the MessageSelector
interface.
Defines a Consumer Endpoint for the 'org.springframework.integration.transformer.HeaderEnricher'
for values defined in the MessageHeaders.
Shortcut to specify value for 'replyChannel' header.
Can be a 'ref' to the MessageChannel, a 'value' as name of the MessageChannel,
or some valid SpEL 'expression' which returns the MessageChannel reference or name of the MessageChannel.
Converts the 'replyChannel' and 'errorChannel' headers to a String after registering it in the HeaderChannelRegistry.
Use this when a message is serialized for any reason. No changes are made
if the header does not exist, or if the header does not currently reference a MessageChannel.
Overrides the header channel registry default 'reaperDelay' - specifies the minimum time
that the mapping will remain in the registry, in milliseconds.
Shortcut to specify value for 'errorChannel' header.
Can be a 'ref' to the MessageChannel, a 'value' as name of the MessageChannel,
or some valid SpEL 'expression' which returns the MessageChannel reference or name of the MessageChannel.
Shortcut to specify value for 'correlationId' header
Shortcut to specify a value for the 'expirationDate' header (java.lang.Long).
Shortcut to specify a value for the 'priority' header.
The 'RoutingSlip' header. semicolon-separated value of message channel names,
or bean names of 'org.springframework.integration.routingslip.RoutingSlipRouteStrategy'
or SpEL expression like 'request.headers[nextPathHeader]'.
Element that accepts any user-defined header name/value pair.
Allows you to configure Message Poller if this endpoint is a Polling Consumer
Specify the default boolean value for whether to overwrite existing
header values. This will
only
take effect for
sub-elements that do not provide their own 'overwrite' attribute. If the
'default-overwrite'
attribute is not
provided, then the specified header values will NOT overwrite any
existing ones with the same
header
names.
Specify whether null values, such as might be returned from an expression evaluation,
should be
skipped. The default value is true. Set this to false if a null value should
trigger removal of the corresponding
header instead.
Reference to an Object to be invoked for header values.
The 'method' attribute is required
along
with this.
Method to be invoked on the referenced Object as specified by the
'ref' attribute. The method
should return a Map with String-typed keys.
Defines a Message Header with a literal value or object reference.
Name of the header to be added.
Provides a header value for the given header name. Requires
exactly one of the 'ref', 'value', or
'expression' attributes.
The 'type' attribute allows for the specification of the expected
type when using a 'value'
or 'expression', but it is optional.
Also for a header value one of 'bean', 'script' or
'expression' sub-elements can be defined, but they are mutually exclusive
with the attributes defined above.
Literal value to be associated with the given header name.
Expression to be evaluated at runtime to determine the header value.
The EvaluationContext will
include variables for 'payload' and
'headers'.
Reference to be associated with the given header name.
Name of a method to be invoked on the referenced target object.
Boolean value to indicate whether this header value should overwrite an
existing header value for
the same name.
Defines a Consumer Endpoint for the 'org.springframework.integration.transformer.HeaderFilter'
to remove values defined in the MessageHeaders.
Specify one or more header names (as a comma separated list) to
be removed from the
MessageHeaders
of the Message being handled.
Boolean flag that specifies whether values provided in 'header-names' should be treated as
match patterns or literal values. For example header-names='foo*' would mean remove all
headers that begin with 'foo' including the header named 'foo*'. However if you want to
treat '*' as literal value setting this flag to FALSE will not perform pattern match and
the only header that will be removed is the one that is an exact match.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.MessageTransformingHandler'
based on the 'org.springframework.integration.transformer.Transformer' strategy.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.ObjectToStringTransformer'
that converts any Object payload to a String by
invoking its toString()
method.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.ObjectToMapTransformer' that converts any Object payload to
a SpEL Map.
Specifies if the result Map of Maps should be transformed further to flat keys of
object's property paths.
Default is 'true'.
Optional reference to a JsonObjectMapper instance.
By default, a JsonObjectMapper that uses a JsonObjectMapperProvider.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.MapToObjectTransformer' that converts SpEL-based Map to an
object.
The name of the bean to be produced by this transformer. The bean MUST BE of scope 'prototype'.
NOTE: This attribute is mutually-exclusive with 'type'.
Defines a Consumer Endpoint for the
'org.springframework.integration.json.ObjectToJsonTransformer'
that converts any Object payload to a JSON String.
before or after the transformer.
]]>
Optional reference to a JsonObjectMapper instance.
By default, a JsonObjectMapper that uses a Jackson 2 ObjectMapper.
The type of the JSON transformation result. 'STRING' and 'NODE' values are allowed.
If 'NODE', the JSON result tree depends on the provided implementation of
'org.springframework.integration.support.json.JsonObjectMapper' (e.g. JsonNode for
Jackson). The default value is 'STRING'.
Defines a Consumer Endpoint for the
'org.springframework.integration.json.JsonToObjectTransformer' that converts a JSON String to an object.
Optional reference to a JsonObjectMapper instance.
By default, a JsonObjectMapper that uses a Jackson 2 ObjectMapper.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.PayloadSerializingTransformer' that converts an object
payload to a byte array.
Reference to a Serializer instance to convert from an object to a byte array.
This is optional.
The default will use standard Java serialization.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.PayloadDeserializingTransformer' that converts a byte array
to an object.
Reference to a Deserializer instance to convert from a byte array to an object.
This is optional.
The default will use standard Java deserialization.
When using the default Deserializer, a list of package/class patterns indicating
classes that are allowed to be deserialized. Consider providing this if you receive
data from untrusted sources. Example: "com.mycom.*, com.yourcom.*".
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.SyslogToMapTransformer' that converts an RFC5424 packet to a
Map.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.StreamTransformer'
that converts an 'InputStream' payload to a byte[] or String.
Providing a 'charset' signals that the conversion to String is
required.
Allows you to specify the Charset (e.g., US-ASCII,
ISO-8859-1, UTF-8) to be used when transforming byte[].
None by default, meaning the payload will be byte[].
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.ClaimCheckInTransformer' that stores a Message and returns
a new Message, whose payload is the id of the stored Message.
Defines a Consumer Endpoint for the
'org.springframework.integration.transformer.ClaimCheckOutTransformer' that accepts a Message whose
payload is a UUID and retrieves the Message associated with that id from a
MessageStore if available (else null).
If set to 'true' the Message will be removed
from the MessageStore by this transformer.
Useful when Message can be 'claimed' only
once. DEFAULT is 'false'.
Reference to the MessageStore to be used by this Claim Check
transformer. If not specified, the default reference will be
to a bean named 'messageStore'.
Allows you to specify the Charset (e.g., US-ASCII,
ISO-8859-1, UTF-8) to be used when transforming byte[]. [UTF-8] is the default
Defines a Consumer Endpoint for the
'org.springframework.integration.filter.MessageFilter'
that is used to decide whether a Message should be passed
along or dropped based on some criteria
The channel where the filter will send the messages that were dropped
Throw an exception if the filter rejects the message (default false).
Defines a Consumer Endpoint for the
'org.springframework.integration.router.HeaderValueRouter'.
The 'header-name' attribute specifies which
header value to lookup. That header value can then provide the name of a
channel to be resolved. Alternatively, 1 or more 'mapping' sub-elements
may be provided with expected header values mapped to channels.
Defines a Consumer Endpoint for the
'org.springframework.integration.router.RecipientListRouter'.
A RecipientListRouter will send
each received Message to a statically defined list of Message Channels.
Another convenient option when configuring a RecipientListRouter
is to define the 'selector-expression' for the 'mapping' sub elements.
The 'selector-expression' uses Spring Expression Language (SpEL)
and can be used as selectors for individual recipient channels.
This is similar to using a Filter at the beginning of 'chain' to
act as a "Selective Consumer". However, in this case, it's all
combined rather concisely into the router's configuration.
Defines a Consumer Endpoint for the
'org.springframework.integration.router.PayloadTypeRouter'.
The 'mapping' sub-elements specify the
associations between Java types and target channels.
Defines a Consumer Endpoint for the
'org.springframework.integration.router.ErrorMessageExceptionTypeRouter'
which resolves the target MessageChannel for
messages whose payload is an Exception. The channel resolution is based upon
the most specific cause of the error for which a channel mapping exists.
Defines a Consumer Endpoint for the
'org.springframework.integration.router.AbstractMessageProcessingRouter' implementation
that serves as an adapter for invoking a method on any
Spring-managed object as specified by the "ref" and "method" attributes.
The "ref" attribute references the bean name of a custom
Router implementation. Typically that implementation will
be a simple POJO, but it may extend AbstractMessageRouter.
Provide the "method" attribute as well to clarify which
method should be invoked, Alternatively, the "ref" attribute
may point to an instance that contains the @Router annotation
on one of its methods.
Instead of using the "ref" attribute you may also provide
the custom Router implementation as an inner bean
definition.
However, keep in mind that using both the "ref" attribute
and an inner handler definition in the same Router
configuration is not allowed, as it creates an
ambiguous condition, and an Exception will be thrown.
Additionally, instead of using "ref" and "method" at all,
you can use the "expression" attribute (see description below).
When implementing a custom Router using a plain POJO
the "ref" attribute may be combined with an explicit
method name using the "method" attribute.
The referenced method may return either a MessageChannel
or a String type. Additionally, the method may return
either a single value or a collection. If a collection
is returned, the reply message will be sent to
multiple channels.
Specifying a "method" attribute applies the same behavior
as when using the @Router annotation on a single method
within the object pointed to by the "ref".
SpEL Expression to be evaluated at runtime. Allows you
to implement simple computations without implementing
a custom POJO router. Generally, the SpEL expression is
evaluated and the result is mapped to a channel using
"mapping" sub-elements.
However, if no "mapping" sub-element is present, the
SpEL Expression will evaluate to a channel name directly.
A SpEL expression may also return a Collection. Whenever
the expression returns multiple channel values the
Message will be forwarded to each channel.
Note that SpEL supports bean-references within expressions
using the @ sign. This enables more sophisticated mapping
of Message content to method arguments, e.g.:
expression="@someBean.someMethod(payload.foo, headers.bar)"
An expression to be evaluated to determine if this recipient
should be included in the recipient list for a given input
Message. The evaluation result of the expression must be a boolean.
If this attribute is not defined, the channel will always be
among the list of recipients.
).
]]>
)
]]>
)
The most specific matching exception type is determined
by navigating the hierarchy of 'exception causes'
(e.g., payload.getCause()).
]]>
)
The most specific matching exception type is determined
by navigating the hierarchy of 'exception causes'
(e.g., payload.getCause()).
]]>
A value of the evaluation token that will be mapped to a channel reference
(e.g., mapping value='foo' channel='myChannel')
A reference to a bean that defines a Message Channel
(e.g., mapping value='foo' channel='myChannel')
An expression to be evaluated to determine if this recipient
should be included in the recipient list for a given input
Message. The evaluation result of the expression must be a boolean.
If this attribute is not defined, the channel will always be
among the list of recipients.
The receiving Message channel of this endpoint
Reference to the channel where Messages should be sent if
channel resolution fails to return any channels. If no
default output channel is provided, the router will throw an
Exception.
If you would like to silently drop those messages instead,
add the "nullChannel" as the default output channel attribute
value.
Specify the maximum amount of time in milliseconds to wait
when sending Messages to the target MessageChannels if blocking
is possible (e.g. a bounded queue channel that is currently full).
By default the send will block indefinitely.
Synonym for 'timeout' - only one can be supplied.
Specify whether sequence number and size headers should be added to each
Message. Defaults to false.
Specify whether channel names must always be successfully resolved
to existing channel instances.
If set to 'true', a MessagingException will be raised in case
the channel cannot be resolved. Setting this attribute to 'false',
will cause any unresolvable channels to be ignored.
If not explicitly set, 'resolution-required' will
default to 'true'.
Defines a Consumer Endpoint for the
'org.springframework.integration.splitter.AbstractMessageProcessingSplitter'
implementation or 'org.springframework.integration.splitter.DefaultMessageSplitter'.
Set this flag to false to prevent adding sequence related headers in this splitter.
This can be convenient in cases where the set sequence numbers conflict with downstream
custom aggregations. When true, existing correlation and sequence related headers
are pushed onto a stack; downstream components, such as aggregators may pop
the stack to revert the existing headers after aggregation. Default is 'true'.
Provide one or more delimiters (as a single String value, e.g. delimiters=",;:") for
tokenizing String-typed payload values. This attribute is only allowed if no 'ref' or
'expression' have been provided since that is when the DefaultMessageSplitter would
be used, and it's the implementation that contains the "delimiters" property.
Defines a Consumer Endpoint for the
'org.springframework.integration.config.AggregatorFactoryBean'.
A SpEL expression to be evaluated against the input message list as its root object.
Boolean flag specifying if MessageGroup should be removed once completed. Useful for
handling late arrival use cases where messages arriving with the correlationKey that
is the same as the completed MessageGroup will be discarded. Default is 'false'
'transactional' or 'advice-chain' are applied only to 'forceComplete' operation.
A reference to a bean that implements the decision algorithm as to whether a given
message group is complete. The bean can be an implementation of the
CorrelationStrategy interface or a POJO.
A method defined on the bean referenced by correlation-strategy, that implements the
correlation decision algorithm
A SpEL expression which implements correlation decision
algorithm to apply to the Message (e.g., payload.getPerson().getId() - correlate
based on the 'id' of the 'person' attribute of the message payload object)
A reference to a bean that implements the release strategy.
The bean can be an implementation of the
ReleaseStrategy interface or a POJO
A method defined on the bean referenced by release-strategy, that implements the completion
decision algorithm.
A SpEL expression to evaluate against a root object that is the Collection of messages within the message group (e.g, size() > 6)
A timeout in milliseconds to force the MessageGroup complete,
when the 'ReleaseStrategy' does not 'release' the group when the current Message arrives.
If 'group-timeout' is not provided or is less than '0' the MessageGroup won't be scheduled
to be forced complete.
The action taken when the group is forced complete depends on the
'send-partial-result-on-expiry' attribute.
Mutually exclusive with the 'group-timeout-expression' attribute.
A SpEL expression to evaluate a 'group-timeout' with the MessageGroup as the #root evaluation
context object for scheduling the MessageGroup forced completion,
when the 'ReleaseStrategy' does not 'release' the group when the current Message arrives.
If 'group-timeout-expression' evaluates to 'null' or less than '0',
the MessageGroup won't be scheduled to be forced complete.
The action taken when the group is forced complete depends on the
'send-partial-result-on-expiry' attribute.
Mutually exclusive with the 'group-timeout' attribute.
Provide a reference to the TaskScheduler instance to schedule 'forceComplete' on
the MessageGroup
when no new message arrives for the MessageGroup within the
'group-timeout' or 'group-timeout-expression'. If it isn't
provided, the default scheduler 'taskScheduler',
registered in the ApplicationContext {ThreadPoolTaskScheduler} will be
used. This attribute only applies if 'group-timeout' or
'group-timeout-expression' is specified.
Boolean flag specifying, if a group is completed due to timeout (reaper or
'group-timeout(-expression)'), whether the group should be removed.
When true, late arriving messages will form a new group. When false, they
will be discarded. Default is 'true' for an aggregator and 'false' for a
resequencer.
A reference to a 'org.springframework.integration.support.locks.LockRegistry' bean
to obtain 'java.util.concurrent.locks.Lock' by 'groupId'. Used for concurrent operations on
MessageGroups. By default an internal 'DefaultLockRegistry' is used.
The channel where the aggregator will send the messages that timed out (if send-partial-results-
on-expiry is 'false').
Reference to a MessageGroupStore for holding
state in between message processing. The default
is to use a volatile in-memory store, which means that unprocessed messages
will be lost if the JVM exits. To customize
the expiry of incomplete message groups configure the message store.
Specifies whether messages that expired should be aggregated and sent to the 'output-channel' or 'replyChannel'.
Messages are expired when their containing MessageGroup expires. One of the ways of expiring MessageGroups is by
configuring a MessageGroupStoreReaper. However MessageGroups can alternatively be expired by simply calling
MessageGroupStore.expireMessageGroups(timeout). That could be accomplished via a ControlBus operation
or by simply invoking that method if you have a reference to the MessageGroupStore instance.
Empty groups exist after a group is released normally.
This is to enable the detection and discarding of late-arriving messages.
If you wish to run empty group deletion on a longer
schedule than expiring partial groups, set this property. Empty groups will
then not be removed from the MessageStore until they have not been modified
for at least this number of milliseconds.
If this is set, the group is scheduled for removal after normal
or partial sequences group release.
When a MessageGroupStoreReaper is configured to expire partial
groups, empty groups are also removed, but using this value.
Note that the actual time to expire an
empty group will also be affected by the reaper's 'timeout'
property and it could be as much as this value plus the timeout.
Defines a Consumer Endpoint for the
'org.springframework.integration.aggregator.ResequencingMessageHandler'.
Flag to say that partial sequences can be released (e.g. 1-4 of 10).
Defaults to true, so the
sequence has to be complete before any messages
are released.
This is mutually exclusive with the release-strategy
attribute (either or none can be specified , but not both).
Defines a list of interceptors. Each element may be a ChannelInterceptor,
ref, or inner-bean.
Reference to a bean in this Application Context that implements ChannelInterceptor
Reference to a bean in this Application Context that implements ChannelInterceptor
Allows you to configure a Wire Tap interceptor that will send a copy of the message to a
channel identified by 'channel' attribute.
Defines a Wire Tap Channel Interceptor.
A reference to a bean in the Application Context
which implements MessageSelector that must accept a message for it to be
sent to the intercepting channel. Mutually exclusive with 'selector-expression'.
A boolean expression evaluated against the message to determine whether it should
sent to the intercepting channel. Mutually exclusive with 'selector'.
The timeout for sending the message to the intercepting channel
A SpEL expression to be evaluated against the input Message as its root object.
If set to 'true', a reply must return a non-null value.
By setting 'requires-reply' to 'true', a 'ReplyRequiredException'
will be raised for null reply messages. If 'requires-reply' is set
to false, those messages are silently dropped.
This attribute defaults to 'true' for 'transformer'.
A SpEL expression to be evaluated against the input Message as its root object.
The key for retrieving the expression from an ExpressionSource.
The reference to an ExpressionSource.
Defines a MessagePublishingInterceptor which allows you to generate messages
as a by-product of
method invocations on Spring configured components.
Defines a 'org.springframework.integration.channel.interceptor.WireTap' bean.
[REQUIRED] Channel name(s) or patterns. To specify more than one channel use
','
(e.g.,
channel-name-pattern="input*, foo, bar")
[OPTIONAL] Specifies the order in which this interceptor will be
added to the existing channel
interceptors (if any).
Negative value (e.g., -2) will signify BEFORE existing interceptors (if any). Positive
value (e.g., 2)
will signify AFTER existing interceptors (if any)
Allows you to define channel interceptors
('org.springframework.messaging.support.ChannelInterceptor' implementation)
to be applied globally.
[REQUIRED] Channel name(s) or patterns. To specify more than one channel use ','.
A leading '!' negates the pattern match ('!foo*' means don't add
interceptor where the name matches the pattern 'foo*').
For example "input*, foo, bar, !Foo*".
[OPTIONAL] Specifies the order in which this interceptor will be
added to the existing channel
interceptors (if any).
Negative value (e.g., -2) will signify BEFORE existing interceptors (if any). Positive
value (e.g., 2)
will signify AFTER existing interceptors (if any)
Allows you to register Converters (implementation of the Converter interface) that will
be automatically registered with the ConversionService. ConversionService itself does not have to be
explicitly defined since the default ConversionService will be registered under the name 'integrationConversionService'
unless bean with this name is already registered.
Will register a Message History writer which will track the message history. There can
only be one Message History writer per ApplicationContext hierarchy.
See also @EnableMessageHistory annotation.
Defines a bean for the 'org.springframework.integration.config.ExpressionControlBusFactoryBean'.
Defines a bean for the 'org.springframework.integration.config.SpelFunctionFactoryBean'.
Specifies the name of the SpEL function.
The fully qualified class name where to find the static method for SpEL function.
The method signature in the form 'methodName[([arg_list])]',
where 'arg_list' is an optional, comma-separated list of fully-qualified
type names.
Allows you to register PropertyAccessors (implementation of the PropertyAccessor interface) that will
be automatically registered with the SpEL EvaluationContext.
Note, the 'id' attribute of the bean definition below is required.
Defines a Consumer Endpoint for the 'org.springframework.integration.scattergather.ScatterGatherHandler'.
Base type for 'scatter-gather' elements.
'id' value:
- Identifies the underlying Spring bean definition (AbstractEndpoint)
- as MessageHandler bean alias together with suffix '.handler'
- as a RecipientListRouter bean together with suffix '.scatterer'
- as a AggregatingMessageHandler bean together with suffix '.gatherer'
Identifies the channel to send a message for 'auction' Scatter-Gather pattern variant.
Mutually exclusive with 'scatterer' sub-element.
Identifies the channel to receive reply Messages for gathering.
Allows to specify how long the Scatter-Gather will wait for reply Messages for gathering.
By default it will wait indefinitely. Value is specified in milliseconds.
Specify whether the Scatter-Gather must return a non-null value. This value is
'true' by default, hence a ReplyRequiredException will be thrown when
the underlying aggregator returns a null value after 'gather-timeout'.
Note, if 'null' is a possibility, the 'gather-timeout' should be specified to avoid an indefinite wait.
Defines an 'org.springframework.integration.handler.advice.IdempotentReceiverInterceptor' bean.
Consumer Endpoint name(s) or patterns. To specify more than one name(pattern) use ','
(e.g. endpoint="xxx, xxx*, *xxx, *xxx*, xxx*yyy").
The endpoint 'id' is used to retrieve the target endpoint's
'MessageHandler' bean (using its '.handler' suffix),
for which the 'IdempotentReceiverInterceptor' will be applied.
A 'MessageSelector' reference. Used to identify if the message should be accepted
by the target 'MessageHandler' endpoint.
Mutually exclusive with 'metadata-store' and 'key-strategy' or 'key-expression'.
A 'ConcurrentMetadataStore' reference. Used by the underlying
'org.springframework.integration.selector.MetadataStoreSelector'.
Mutually exclusive with 'selector'.
Optional. The default 'MetadataStoreSelector' uses an internal 'SimpleMetadataStore' which
does not maintain state across application executions.
A 'MessageProcessor' reference. Used by the underlying
'org.springframework.integration.selector.MetadataStoreSelector'.
Evaluates an 'idempotentKey' from the request Message.
Mutually exclusive with 'selector' and 'key-expression'.
A 'MessageProcessor' reference. Used by the underlying
'org.springframework.integration.selector.MetadataStoreSelector'.
Evaluates a 'value' for the 'idempotentKey' from the request Message.
Mutually exclusive with 'selector' and 'value-expression'.
By default, the 'MetadataStoreSelector' uses the 'timestamp' message header as the Metadata 'value'.
Identifies the channel to send a message when 'IdempotentReceiverInterceptor' doesn't accept
the message. When omitted, duplicate messages are forwarded to the handler with a
'DUPLICATE_MESSAGE' header.
Throw an exception if the 'IdempotentReceiverInterceptor' rejects the message (default false).
It is applied regardless of whether or not a discard channel is provided.
Set false, to disable all main-path debug logging for components that implement
'IntegrationManagement' (channels, message handlers etc). For high-volume environments
avoiding calls to 'isDebuggingEnabled()` can improve performance.
The default value for components that don't match 'counts-enabled-patterns'.
Defaults to false, or true when an Integration MBean Exporter is provided.
The default value for components that don't match 'stats-enabled-patterns'.
Defaults to false, or true when an Integration MBean Exporter is provided.
Comma separated list of simple patterns for component names for which message counts
will be enabled (defaults to '*'). Only patterns that also match 'managed-components'
will be considered. Enables message counting (`sendCount`, `errorCount`, `receiveCount`)
for those components that support counters (channels, message handlers, etc).
This is the initial setting only, individual components can have counts enabled/disabled
at runtime. May be overridden by an entry in 'stats-enabled' which is additional
functionality over simple counts. If a pattern starts with `!`, counts are disabled
for matches. For components with names that match multiple patterns, the first pattern wins.
Disabling counts at runtime also disables stats.
Comma separated list of simple patterns for component names for which message statistics
will be enabled (response times, rates etc), as well as counts (a positive match here
overrides `counts-enabled`, you can't have statistics without counts).
(defaults to '*'). Only patterns that also match 'managed-components'
will be considered. Enables statistics for those components that support
statistics (channels - when sending, message handlers, etc).
This is the initial setting only, individual components can have stats enabled/disabled
at runtime. If a pattern starts with `!`, stats (and counts) are disabled
for matches. Note: this means that '!foo' here will disable stats
and counts for 'foo' even if counts are enabled for 'foo' in 'counts-enabled'.
For components with names that match multiple patterns, the first pattern wins.
Enabling stats at runtime also enables counts.
A MetricsFactory responsible for creating objects that maintain metrics for message
channels and message handlers.
Identifies the Message channel where Message will be sent after it's being processed by this endpoint
Specify the maximum amount of time in milliseconds to wait when sending a reply
Message to the output channel. Defaults to '-1' - blocking indefinitely.
It is applied only if the output channel has some 'sending' limitations, e.g. QueueChannel with
fixed a 'capacity'. In this case a MessageDeliveryException is thrown. The 'send-timeout'
is ignored in case of AbstractSubscribableChannel implementations.
The receiving Message channel of this endpoint
or poller
sub element.
Used to take action after the transaction completes () or after
the channel.send() is complete ().
]]>
),
or after the transaction commits (). The #root variable of the
expression evaluation is the original message; a BeanResolver is also available.
]]>
),
or after the transaction rolls back (). The #root variable of the
expression evaluation is the original message; a BeanResolver is also available.
]]>
When fetching objects from some external resource, limit the number of such objects that
will be retrieved on each fetch. A negative value (default) indicates no limit; a value
of zero effectively disables fetching remote objects.