@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