@Retention(value=RUNTIME) @Documented @Target(value={FIELD,METHOD,CONSTRUCTOR}) public @interface RecipientList
Exchange
is received from an Endpoint
then the
Bean Integration mechanism is used to map the incoming
Message
to the method parameters.
The return value of the method is then converted to either a Collection
or array of objects where
each element is converted to an Endpoint
or a String
, or if it is not a collection/array then it is
converted to an Endpoint
or String
.
Then for each endpoint or URI the message is forwarded a separate copy.Modifier and Type | Optional Element and Description |
---|---|
int |
cacheSize
Sets the maximum size used by the
ProducerCache which is used to cache and reuse
producers when using this recipient list, when uris are reused. |
String |
delimiter
Delimiter used if the Expression returned multiple endpoints.
|
String |
executorServiceRef
Refers to a custom Thread Pool to be used for parallel processing.
|
boolean |
ignoreInvalidEndpoints
Whether to ignore the invalidate endpoint exception when try to create a producer with that endpoint
|
String |
onPrepareRef
|
boolean |
parallelAggregate
If enabled then the aggregate method on AggregationStrategy can be called concurrently.
|
boolean |
parallelProcessing
If enabled then sending messages to the recipients occurs concurrently.
|
boolean |
shareUnitOfWork
Deprecated.
|
boolean |
stopOnAggregateException
If enabled, unwind exceptions occurring at aggregation time to the error handler when parallelProcessing is used.
|
boolean |
stopOnException
Will now stop further processing if an exception or failure occurred during processing of an
Exchange and the caused exception will be thrown. |
String |
strategyRef
Sets a reference to the AggregationStrategy to be used to assemble the replies from the recipients, into a single
outgoing message from the RecipientList.
|
boolean |
streaming
If enabled then Camel will process replies out-of-order, eg in the order they come back.
|
long |
timeout
Sets a total timeout specified in millis, when using parallel processing.
|
public abstract String delimiter
public abstract boolean parallelProcessing
public abstract boolean parallelAggregate
public abstract boolean stopOnException
Exchange
and the caused exception will be thrown.
Will also stop if processing the exchange failed (has a fault message) or an exception was thrown and handled by
the error handler (such as using onException). In all situations the recipient list will stop further processing.
This is the same behavior as in pipeline, which is used by the routing engine.
The default behavior is to not stop but continue processing till the endpublic abstract boolean stopOnAggregateException
false
for the sake of backward compatibility.public abstract boolean streaming
public abstract boolean ignoreInvalidEndpoints
public abstract String strategyRef
public abstract String executorServiceRef
public abstract long timeout
public abstract int cacheSize
ProducerCache
which is used to cache and reuse
producers when using this recipient list, when uris are reused.
Beware that when using dynamic endpoints then it affects how well the cache can be utilized. If each dynamic
endpoint is unique then its best to turn of caching by setting this to -1, which allows Camel to not cache both
the producers and endpoints; they are regarded as prototype scoped and will be stopped and discarded after use.
This reduces memory usage as otherwise producers/endpoints are stored in memory in the caches.
However if there are a high degree of dynamic endpoints that have been used before, then it can benefit to use
the cache to reuse both producers and endpoints and therefore the cache size can be set accordingly or rely on
the default size (1000).
If there is a mix of unique and used before dynamic endpoints, then setting a reasonable cache size can help
reduce memory usage to avoid storing too many non frequent used producers.@Deprecated public abstract boolean shareUnitOfWork
UnitOfWork
with the parent and each of the sub messages. Recipient List
will by default not share unit of work between the parent exchange and each recipient exchange. This means each
sub exchange has its own individual unit of work.Apache Camel