Author: buildbot
Date: Wed Aug 12 15:20:12 2015
New Revision: 961632
Log:
Production update by buildbot for camel
Modified:
websites/production/camel/content/aggregator2.html
websites/production/camel/content/book-in-one-page.html
websites/production/camel/content/book-pattern-appendix.html
websites/production/camel/content/cache/main.pageCache
websites/production/camel/content/camel-2160-release.html
Modified: websites/production/camel/content/aggregator2.html
==============================================================================
--- websites/production/camel/content/aggregator2.html (original)
+++ websites/production/camel/content/aggregator2.html Wed Aug 12 15:20:12 2015
@@ -86,7 +86,7 @@
<tbody>
<tr>
<td valign="top" width="100%">
-<div class="wiki-content maincontent"><h3
id="Aggregator2-Aggregator">Aggregator</h3><p><strong>This applies for Camel
version 2.3 or newer. If you use an older version then use this <a shape="rect"
href="aggregator.html">Aggregator</a> link instead.</strong></p><p>The <a
shape="rect" class="external-link"
href="http://www.enterpriseintegrationpatterns.com/Aggregator.html";
rel="nofollow">Aggregator</a> from the <a shape="rect"
href="enterprise-integration-patterns.html">EIP patterns</a> allows you to
combine a number of messages together into a single message.</p><p><span
class="confluence-embedded-file-wrapper"><img class="confluence-embedded-image
confluence-external-resource"
src="http://www.enterpriseintegrationpatterns.com/img/Aggregator.gif";
data-image-src="http://www.enterpriseintegrationpatterns.com/img/Aggregator.gif";></span></p><p>A
correlation <a shape="rect" href="expression.html">Expression</a> is used to
determine the messages which should be aggregated together. If yo
u want to aggregate all messages into a single message, just use a constant
expression. An AggregationStrategy is used to combine all the message exchanges
for a single correlation key into a single message exchange.</p><h3
id="Aggregator2-Aggregatoroptions">Aggregator options</h3><p>The aggregator
supports the following options:</p><div class="confluenceTableSmall"><div
class="table-wrap"><table class="confluenceTable"><tbody><tr><th colspan="1"
rowspan="1" class="confluenceTh"><p>Option</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>Default</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>Description</p></th></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>correlationExpression</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Mandatory <a shape="rect"
href="expression.html">Expression</a> which evaluates the correlation key to
use for aggregation. The <a shape="rect" h
ref="exchange.html">Exchange</a> which has the same correlation key is
aggregated together. If the correlation key could not be evaluated an Exception
is thrown. You can disable this by using the
<code>ignoreBadCorrelationKeys</code> option.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>aggregationStrategy</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Mandatory <code>AggregationStrategy</code> which is
used to <em>merge</em> the incoming <a shape="rect"
href="exchange.html">Exchange</a> with the existing already merged exchanges.
At first call the <code>oldExchange</code> parameter is <code>null</code>. On
subsequent invocations the <code>oldExchange</code> contains the merged
exchanges and <code>newExchange</code> is of course the new incoming Exchange.
From <strong>Camel 2.9.2</strong> onwards the strategy can also be a
<code>TimeoutAwareAggregationStrategy</code> implementation
, supporting the timeout callback, see further below for more details. From
<strong>Camel 2.16</strong> onwards the strategy can also be a
<code>PreCompletionAwareAggregationStrategy</code> implementation which then
runs the completion check in pre-completion mode. See further below for more
details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>strategyRef</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>A reference to lookup the
<code>AggregationStrategy</code> in the <a shape="rect"
href="registry.html">Registry</a>. From <strong>Camel 2.12</strong> onwards you
can also use a POJO as the <code>AggregationStrategy</code>, see further below
for details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>strategyMethodName</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><strong>Camel 2.12
:</strong> This option can be used to explicit declare the method name to use,
when using POJOs as the <code>AggregationStrategy</code>. See further below for
more details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>strategyMethodAllowNull</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.12:</strong> If this option
is <code>false</code> then the aggregate method is not used for the very first
aggregation. If this option is <code>true</code> then <code>null</code> values
is used as the <code>oldExchange</code> (at the very first aggregation), when
using POJOs as the <code>AggregationStrategy</code>. See further below for more
details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionSize</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Number of me
ssages aggregated before the aggregation is complete. This option can be set
as either a fixed value or using an <a shape="rect"
href="expression.html">Expression</a> which allows you to evaluate a size
dynamically - will use <code>Integer</code> as result. If both are set Camel
will fallback to use the fixed value if the <a shape="rect"
href="expression.html">Expression</a> result was <code>null</code> or
<code>0</code>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionTimeout</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Time in millis that an aggregated exchange should be
inactive before its complete. This option can be set as either a fixed value or
using an <a shape="rect" href="expression.html">Expression</a> which allows you
to evaluate a timeout dynamically - will use <code>Long</code> as result. If
both are set Camel will fallback to use the fixed value if the <a s
hape="rect" href="expression.html">Expression</a> result was <code>null</code>
or <code>0</code>. You cannot use this option together with completionInterval,
only one of the two can be used.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionInterval</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>A repeating period in millis by which the aggregator
will complete all current aggregated exchanges. Camel has a background task
which is triggered every period. You cannot use this option together with
completionTimeout, only one of them can be used.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p>completionPredicate</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>A <a shape="rect"
href="predicate.html">Predicate</a> to indicate when an aggregated exchange is
complete. Starting in <st
rong>Camel 2.15</strong>, if this is not specified and the AggregationStrategy
object implements Predicate, the aggregationStrategy object will be used as the
completionPredicate.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionFromBatchConsumer</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>This option is if the exchanges are coming
from a <a shape="rect" href="batch-consumer.html">Batch Consumer</a>. Then when
enabled the <a shape="rect" href="aggregator2.html">Aggregator2</a> will use
the batch size determined by the <a shape="rect"
href="batch-consumer.html">Batch Consumer</a> in the message header
<code>CamelBatchSize</code>. See more details at <a shape="rect"
href="batch-consumer.html">Batch Consumer</a>. This can be used to aggregate
all files consumed from a <a shape="rect" href="file2.html">File</a> endpoint
in that given poll.</p></td></tr><tr><td col
span="1" rowspan="1" class="confluenceTd"><p>forceCompletionOnStop</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p><strong>Camel 2.9</strong>
Indicates to complete all current aggregated exchanges when the context is
stopped</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>eagerCheckCompletion</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Whether or not to eager check for
completion when a new incoming <a shape="rect"
href="exchange.html">Exchange</a> has been received. This option influences the
behavior of the <code>completionPredicate</code> option as the <a shape="rect"
href="exchange.html">Exchange</a> being passed in changes accordingly. When
<code>false</code> the <a shape="rect" href="exchange.html">Exchange</a> passed
in the <a shape="rect" href="predicate.html">Predicate</
a> is the <em>aggregated</em> Exchange which means any information you may
store on the aggregated Exchange from the <code>AggregationStrategy</code> is
available for the <a shape="rect" href="predicate.html">Predicate</a>. When
<code>true</code> the <a shape="rect" href="exchange.html">Exchange</a> passed
in the <a shape="rect" href="predicate.html">Predicate</a> is the
<em>incoming</em> <a shape="rect" href="exchange.html">Exchange</a>, which
means you can access data from the incoming Exchange.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p>groupExchanges</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p>If enabled then Camel will
group all aggregated Exchanges into a single combined
<code>org.apache.camel.impl.GroupedExchange</code> holder class that holds all
the aggregated Exchanges. And as a result only one Exchange is being sent out
from the aggregator. Can be used
to combine many incoming Exchanges into a single output Exchange without
coding a custom <code>AggregationStrategy</code> yourself.
<strong>Important:</strong> This option does <strong>not</strong> support
persistent repository with the aggregator. See further below for an example and
more details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>ignoreInvalidCorrelationKeys</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Whether or not to ignore correlation keys
which could not be evaluated to a value. By default Camel will throw an
Exception, but you can enable this option and ignore the situation
instead.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>closeCorrelationKeyOnCompletion</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Whether or not too <em>late</em> Exchanges
should be accepted or not. You can enable this to indicate that if a
correlation key has already been completed, then any new exchanges with the
same correlation key be denied. Camel will then throw a
<code>closedCorrelationKeyException</code> exception. When using this option
you pass in a <code>integer</code> which is a number for a LRUCache which keeps
that last X number of closed correlation keys. You can pass in 0 or a negative
value to indicate a unbounded cache. By passing in a number you are ensured
that cache won't grow too big if you use a log of different correlation
keys.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>discardOnCompletionTimeout</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.5:</strong> Whether or not
exchanges which complete due to a timeout should be discarded. If enabled then
when a timeout occurs the aggregated message wil
l <strong>not</strong> be sent out but dropped
(discarded).</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>aggregationRepository</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Allows you to plugin you own implementation of
<code>org.apache.camel.spi.AggregationRepository</code> which keeps track of
the current inflight aggregated exchanges. Camel uses by default a memory based
implementation.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>aggregationRepositoryRef</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Reference to lookup a
<code>aggregationRepository</code> in the <a shape="rect"
href="registry.html">Registry</a>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>parallelProcessing</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><code>false</co
de></p></td><td colspan="1" rowspan="1" class="confluenceTd"><p>When
aggregated are completed they are being send out of the aggregator. This option
indicates whether or not Camel should use a thread pool with multiple threads
for concurrency. If no custom thread pool has been specified then Camel creates
a default pool with 10 concurrent threads.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>executorService</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>If using <code>parallelProcessing</code> you can
specify a custom thread pool to be used. In fact also if you are not using
<code>parallelProcessing</code> this custom thread pool is used to send out
aggregated exchanges as well.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>executorServiceRef</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="conflue
nceTd"><p>Reference to lookup a <code>executorService</code> in the <a
shape="rect" href="registry.html">Registry</a></p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>timeoutCheckerExecutorService</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.9:</strong> If using either
of the <code>completionTimeout</code>,
<code>completionTimeoutExpression</code>, or <code>completionInterval</code>
options a background thread is created to check for the completion for every
aggregator. Set this option to provide a custom thread pool to be used rather
than creating a new thread for every aggregator.</p></td></tr><tr><td
colspan="1" rowspan="1"
class="confluenceTd"><p>timeoutCheckerExecutorServiceRef</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.9:</strong> Reference to
lookup a <code>time
outCheckerExecutorService</code> in the <a shape="rect"
href="registry.html">Registry</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>optimisticLocking</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><code>false</code></p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><strong>Camel 2.11:</strong> Turns on using optimistic
locking, which requires the <code>aggregationRepository</code> being used, is
supporting this by implementing the
<code>org.apache.camel.spi.OptimisticLockingAggregationRepository</code>
interface.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>optimisticLockRetryPolicy</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><strong>Camel 2.11.1:</strong> Allows to configure
retry settings when using optimistic
locking.</p></td></tr></tbody></table></div></div><h3
id="Aggregator2-ExchangeProperties">Exchange Properties</h3><p>T
he following properties are set on each aggregated Exchange:</p><div
class="confluenceTableSmall"><div class="table-wrap"><table
class="confluenceTable"><tbody><tr><th colspan="1" rowspan="1"
class="confluenceTh"><p>header</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>type</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>description</p></th></tr><tr><td colspan="1"
rowspan="1"
class="confluenceTd"><p><code>CamelAggregatedSize</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p>int</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>The total number of Exchanges aggregated
into this combined Exchange.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><code>CamelAggregatedCompletedBy</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p>String</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Indicator how the aggregation was completed
as a value of either: <code>predicate</code>, <code>size</cod
e>, <code>strategy</code>, <code>consumer</code>, <code>timeout</code>,
<code>forceCompletion</code> or
<code>interval</code>.</p></td></tr></tbody></table></div></div><h3
id="Aggregator2-AboutAggregationStrategy">About AggregationStrategy</h3><p>The
<code>AggregationStrategy</code> is used for aggregating the old (lookup by its
correlation id) and the new exchanges together into a single exchange. Possible
implementations include performing some kind of combining or delta processing,
such as adding line items together into an invoice or just using the newest
exchange and removing old exchanges such as for state tracking or market data
prices; where old values are of little use.</p><p>Notice the aggregation
strategy is a mandatory option and must be provided to the
aggregator.</p><p>Here are a few example AggregationStrategy implementations
that should help you create your own custom strategy.</p><div class="code panel
pdl" style="border-width: 1px;"><div class="codeContent panelCon
tent pdl">
+<div class="wiki-content maincontent"><h3
id="Aggregator2-Aggregator">Aggregator</h3><p><strong>This applies for Camel
version 2.3 or newer. If you use an older version then use this <a shape="rect"
href="aggregator.html">Aggregator</a> link instead.</strong></p><p>The <a
shape="rect" class="external-link"
href="http://www.enterpriseintegrationpatterns.com/Aggregator.html";
rel="nofollow">Aggregator</a> from the <a shape="rect"
href="enterprise-integration-patterns.html">EIP patterns</a> allows you to
combine a number of messages together into a single message.</p><p><span
class="confluence-embedded-file-wrapper"><img class="confluence-embedded-image
confluence-external-resource"
src="http://www.enterpriseintegrationpatterns.com/img/Aggregator.gif";
data-image-src="http://www.enterpriseintegrationpatterns.com/img/Aggregator.gif";></span></p><p>A
correlation <a shape="rect" href="expression.html">Expression</a> is used to
determine the messages which should be aggregated together. If yo
u want to aggregate all messages into a single message, just use a constant
expression. An AggregationStrategy is used to combine all the message exchanges
for a single correlation key into a single message exchange.</p><h3
id="Aggregator2-Aggregatoroptions">Aggregator options</h3><p>The aggregator
supports the following options:</p><div class="confluenceTableSmall"><div
class="table-wrap"><table class="confluenceTable"><tbody><tr><th colspan="1"
rowspan="1" class="confluenceTh"><p>Option</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>Default</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>Description</p></th></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>correlationExpression</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Mandatory <a shape="rect"
href="expression.html">Expression</a> which evaluates the correlation key to
use for aggregation. The <a shape="rect" h
ref="exchange.html">Exchange</a> which has the same correlation key is
aggregated together. If the correlation key could not be evaluated an Exception
is thrown. You can disable this by using the
<code>ignoreBadCorrelationKeys</code> option.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>aggregationStrategy</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Mandatory <code>AggregationStrategy</code> which is
used to <em>merge</em> the incoming <a shape="rect"
href="exchange.html">Exchange</a> with the existing already merged exchanges.
At first call the <code>oldExchange</code> parameter is <code>null</code>. On
subsequent invocations the <code>oldExchange</code> contains the merged
exchanges and <code>newExchange</code> is of course the new incoming Exchange.
From <strong>Camel 2.9.2</strong> onwards the strategy can also be a
<code>TimeoutAwareAggregationStrategy</code> implementation
, supporting the timeout callback, see further below for more details. From
<strong>Camel 2.16</strong> onwards the strategy can also be a
<code>PreCompletionAwareAggregationStrategy</code> implementation which then
runs the completion check in pre-completion mode. See further below for more
details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>strategyRef</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>A reference to lookup the
<code>AggregationStrategy</code> in the <a shape="rect"
href="registry.html">Registry</a>. From <strong>Camel 2.12</strong> onwards you
can also use a POJO as the <code>AggregationStrategy</code>, see further below
for details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>strategyMethodName</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><strong>Camel 2.12
:</strong> This option can be used to explicit declare the method name to use,
when using POJOs as the <code>AggregationStrategy</code>. See further below for
more details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>strategyMethodAllowNull</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.12:</strong> If this option
is <code>false</code> then the aggregate method is not used for the very first
aggregation. If this option is <code>true</code> then <code>null</code> values
is used as the <code>oldExchange</code> (at the very first aggregation), when
using POJOs as the <code>AggregationStrategy</code>. See further below for more
details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionSize</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Number of me
ssages aggregated before the aggregation is complete. This option can be set
as either a fixed value or using an <a shape="rect"
href="expression.html">Expression</a> which allows you to evaluate a size
dynamically - will use <code>Integer</code> as result. If both are set Camel
will fallback to use the fixed value if the <a shape="rect"
href="expression.html">Expression</a> result was <code>null</code> or
<code>0</code>.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionTimeout</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Time in millis that an aggregated exchange should be
inactive before its complete. This option can be set as either a fixed value or
using an <a shape="rect" href="expression.html">Expression</a> which allows you
to evaluate a timeout dynamically - will use <code>Long</code> as result. If
both are set Camel will fallback to use the fixed value if the <a s
hape="rect" href="expression.html">Expression</a> result was <code>null</code>
or <code>0</code>. You cannot use this option together with completionInterval,
only one of the two can be used.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionInterval</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>A repeating period in millis by which the aggregator
will complete all current aggregated exchanges. Camel has a background task
which is triggered every period. You cannot use this option together with
completionTimeout, only one of them can be used.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p>completionPredicate</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>A <a shape="rect"
href="predicate.html">Predicate</a> to indicate when an aggregated exchange is
complete. Starting in <st
rong>Camel 2.15</strong>, if this is not specified and the AggregationStrategy
object implements Predicate, the aggregationStrategy object will be used as the
completionPredicate.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>completionFromBatchConsumer</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>This option is if the exchanges are coming
from a <a shape="rect" href="batch-consumer.html">Batch Consumer</a>. Then when
enabled the <a shape="rect" href="aggregator2.html">Aggregator2</a> will use
the batch size determined by the <a shape="rect"
href="batch-consumer.html">Batch Consumer</a> in the message header
<code>CamelBatchSize</code>. See more details at <a shape="rect"
href="batch-consumer.html">Batch Consumer</a>. This can be used to aggregate
all files consumed from a <a shape="rect" href="file2.html">File</a> endpoint
in that given poll.</p></td></tr><tr><td col
span="1" rowspan="1" class="confluenceTd"><p>forceCompletionOnStop</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p><strong>Camel 2.9</strong>
Indicates to complete all current aggregated exchanges when the context is
stopped</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd">completeAllOnStop</td><td colspan="1" rowspan="1"
class="confluenceTd"><code>false</code></td><td colspan="1" rowspan="1"
class="confluenceTd"><strong>Camel 2.16:</strong> Indicates to wait to
complete all current and partial (pending) aggregated exchanges when the
context is stopped. This also means that we will wait for all pending exchanges
which are stored in the aggregation repository to complete so the
repository is empty before we can stop.  You may want to enable this when
using the memory based aggregation repository that is memory based
only, and do not store data on disk.
When this option is enabled, then the aggregator is waiting to
complete all those exchanges before its stopped, when stopping
CamelContext or the route using it.</td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>eagerCheckCompletion</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Whether or not to eager check for
completion when a new incoming <a shape="rect"
href="exchange.html">Exchange</a> has been received. This option influences the
behavior of the <code>completionPredicate</code> option as the <a shape="rect"
href="exchange.html">Exchange</a> being passed in changes accordingly. When
<code>false</code> the <a shape="rect" href="exchange.html">Exchange</a> passed
in the <a shape="rect" href="predicate.html">Predicate</a> is the
<em>aggregated</em> Exchange which means any information you may store on the
aggregated Exchange from the <code>AggregationStrategy</code> is
available for the <a shape="rect" href="predicate.html">Predicate</a>. When
<code>true</code> the <a shape="rect" href="exchange.html">Exchange</a> passed
in the <a shape="rect" href="predicate.html">Predicate</a> is the
<em>incoming</em> <a shape="rect" href="exchange.html">Exchange</a>, which
means you can access data from the incoming Exchange.</p></td></tr><tr><td
colspan="1" rowspan="1" class="confluenceTd"><p>groupExchanges</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p>If enabled then Camel will
group all aggregated Exchanges into a single combined
<code>org.apache.camel.impl.GroupedExchange</code> holder class that holds all
the aggregated Exchanges. And as a result only one Exchange is being sent out
from the aggregator. Can be used to combine many incoming Exchanges into a
single output Exchange without coding a custom <code>AggregationStrategy</code>
yourself. <strong>Important:</s
trong> This option does <strong>not</strong> support persistent repository
with the aggregator. See further below for an example and more
details.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>ignoreInvalidCorrelationKeys</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Whether or not to ignore correlation keys
which could not be evaluated to a value. By default Camel will throw an
Exception, but you can enable this option and ignore the situation
instead.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>closeCorrelationKeyOnCompletion</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Whether or not too <em>late</em> Exchanges should be
accepted or not. You can enable this to indicate that if a correlation key has
already been completed, then any new exchanges with the same co
rrelation key be denied. Camel will then throw a
<code>closedCorrelationKeyException</code> exception. When using this option
you pass in a <code>integer</code> which is a number for a LRUCache which keeps
that last X number of closed correlation keys. You can pass in 0 or a negative
value to indicate a unbounded cache. By passing in a number you are ensured
that cache won't grow too big if you use a log of different correlation
keys.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>discardOnCompletionTimeout</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.5:</strong> Whether or not
exchanges which complete due to a timeout should be discarded. If enabled then
when a timeout occurs the aggregated message will <strong>not</strong> be sent
out but dropped (discarded).</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>aggregationRepository</p
></td><td colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td
>colspan="1" rowspan="1" class="confluenceTd"><p>Allows you to plugin you own
>implementation of <code>org.apache.camel.spi.AggregationRepository</code>
>which keeps track of the current inflight aggregated exchanges. Camel uses by
>default a memory based implementation.</p></td></tr><tr><td colspan="1"
>rowspan="1" class="confluenceTd"><p>aggregationRepositoryRef</p></td><td
>colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td
>colspan="1" rowspan="1" class="confluenceTd"><p>Reference to lookup a
><code>aggregationRepository</code> in the <a shape="rect"
>href="registry.html">Registry</a>.</p></td></tr><tr><td colspan="1"
>rowspan="1" class="confluenceTd"><p>parallelProcessing</p></td><td
>colspan="1" rowspan="1"
>class="confluenceTd"><p><code>false</code></p></td><td colspan="1"
>rowspan="1" class="confluenceTd"><p>When aggregated are completed they are
>being send out of the aggregator. This option indi
cates whether or not Camel should use a thread pool with multiple threads for
concurrency. If no custom thread pool has been specified then Camel creates a
default pool with 10 concurrent threads.</p></td></tr><tr><td colspan="1"
rowspan="1" class="confluenceTd"><p>executorService</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>If using <code>parallelProcessing</code> you can
specify a custom thread pool to be used. In fact also if you are not using
<code>parallelProcessing</code> this custom thread pool is used to send out
aggregated exchanges as well.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>executorServiceRef</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p>Reference to lookup a <code>executorService</code> in
the <a shape="rect" href="registry.html">Registry</a></p></td></tr><tr><td
colspan="1" ro
wspan="1" class="confluenceTd"><p>timeoutCheckerExecutorService</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.9:</strong> If using either
of the <code>completionTimeout</code>,
<code>completionTimeoutExpression</code>, or <code>completionInterval</code>
options a background thread is created to check for the completion for every
aggregator. Set this option to provide a custom thread pool to be used rather
than creating a new thread for every aggregator.</p></td></tr><tr><td
colspan="1" rowspan="1"
class="confluenceTd"><p>timeoutCheckerExecutorServiceRef</p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p><strong>Camel 2.9:</strong> Reference to
lookup a <code>timeoutCheckerExecutorService</code> in the <a shape="rect"
href="registry.html">Registry</a></p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceT
d"><p>optimisticLocking</p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><code>false</code></p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><strong>Camel 2.11:</strong> Turns on using optimistic
locking, which requires the <code>aggregationRepository</code> being used, is
supporting this by implementing the
<code>org.apache.camel.spi.OptimisticLockingAggregationRepository</code>
interface.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p>optimisticLockRetryPolicy</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p> </p></td><td colspan="1" rowspan="1"
class="confluenceTd"><p><strong>Camel 2.11.1:</strong> Allows to configure
retry settings when using optimistic
locking.</p></td></tr></tbody></table></div></div><h3
id="Aggregator2-ExchangeProperties">Exchange Properties</h3><p>The following
properties are set on each aggregated Exchange:</p><div
class="confluenceTableSmall"><div class="table-wrap"><table
class="confluenceTable">
<tbody><tr><th colspan="1" rowspan="1"
class="confluenceTh"><p>header</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>type</p></th><th colspan="1" rowspan="1"
class="confluenceTh"><p>description</p></th></tr><tr><td colspan="1"
rowspan="1"
class="confluenceTd"><p><code>CamelAggregatedSize</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p>int</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>The total number of Exchanges aggregated
into this combined Exchange.</p></td></tr><tr><td colspan="1" rowspan="1"
class="confluenceTd"><p><code>CamelAggregatedCompletedBy</code></p></td><td
colspan="1" rowspan="1" class="confluenceTd"><p>String</p></td><td colspan="1"
rowspan="1" class="confluenceTd"><p>Indicator how the aggregation was completed
as a value of either: <code>predicate</code>, <code>size</code>,
<code>strategy</code>, <code>consumer</code>, <code>timeout</code>,
<code>forceCompletion</code> or
<code>interval</code>.</p></td></tr></tbody></tab
le></div></div><h3 id="Aggregator2-AboutAggregationStrategy">About
AggregationStrategy</h3><p>The <code>AggregationStrategy</code> is used for
aggregating the old (lookup by its correlation id) and the new exchanges
together into a single exchange. Possible implementations include performing
some kind of combining or delta processing, such as adding line items together
into an invoice or just using the newest exchange and removing old exchanges
such as for state tracking or market data prices; where old values are of
little use.</p><p>Notice the aggregation strategy is a mandatory option and
must be provided to the aggregator.</p><p>Here are a few example
AggregationStrategy implementations that should help you create your own custom
strategy.</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[//simply combines Exchange String body values
using '+' as a delimiter
class StringAggregationStrategy implements AggregationStrategy {
@@ -141,7 +141,7 @@ from("direct:start")
.aggregate(header("id"), new
BodyInAggregatingStrategy()).completionTimeout(3000)
.to("mock:aggregated");
]]></script>
-</div></div><p>And the same example using Spring XML:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the same example using Spring XML:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
@@ -167,7 +167,7 @@ from("direct:start")
.aggregate(header("id"), new
BodyInAggregatingStrategy()).completionSize(3)
.to("mock:aggregated");
]]></script>
-</div></div><p>And the same example using Spring XML:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the same example using Spring XML:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
@@ -193,7 +193,7 @@ from("direct:start")
.aggregate(header("id"), new
BodyInAggregatingStrategy()).completionPredicate(body().contains("A+B+C"))
.to("mock:aggregated");
]]></script>
-</div></div><p>And the same example using Spring XML:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the same example using Spring XML:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
@@ -212,7 +212,7 @@ from("direct:start")
<bean id="aggregatorStrategy"
class="org.apache.camel.processor.BodyInAggregatingStrategy"/>
]]></script>
-</div></div><p>And the other situation where we use the
<code>eagerCheckCompletion</code> option to tell Camel to use the incoming
Exchange. Notice how we can just test in the completion predicate that the
incoming message is the <em>END</em> message:</p><div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the other situation where we use the
<code>eagerCheckCompletion</code> option to tell Camel to use the incoming
Exchange. Notice how we can just test in the completion predicate that the
incoming message is the <em>END</em> message:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
from("direct:start")
// aggregate all exchanges correlated by the id header.
@@ -224,7 +224,7 @@ from("direct:start")
.eagerCheckCompletion().completionPredicate(body().isEqualTo("END"))
.to("mock:aggregated");
]]></script>
-</div></div><p>And the same example using Spring XML:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the same example using Spring XML:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
@@ -253,7 +253,7 @@ from("direct:start")
.aggregate(header("id"), new
BodyInAggregatingStrategy()).completionTimeout(header("timeout"))
.to("mock:aggregated");
]]></script>
-</div></div><p>And the same example using Spring XML:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the same example using Spring XML:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
@@ -272,7 +272,7 @@ from("direct:start")
<bean id="aggregatorStrategy"
class="org.apache.camel.processor.BodyInAggregatingStrategy"/>
]]></script>
-</div></div><p><strong>Note:</strong> You can also add a fixed timeout value
and Camel will fallback to use this value if the dynamic value was
<code>null</code> or <code>0</code>.</p><h4
id="Aggregator2-UsingdynamiccompletionSize">Using dynamic
completionSize</h4><p>In this example we want to aggregate all incoming
messages based on a dynamic size per correlation key. The size is computed at
runtime based on the <code>mySize</code> header in the incoming messages. This
is done using the <code>completionSize</code> option as shown:</p><div
class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
+</div></div><strong>Note:</strong> You can also add a fixed timeout value and
Camel will fallback to use this value if the dynamic value was
<code>null</code> or <code>0</code>.<h4
id="Aggregator2-UsingdynamiccompletionSize">Using dynamic
completionSize</h4><p>In this example we want to aggregate all incoming
messages based on a dynamic size per correlation key. The size is computed at
runtime based on the <code>mySize</code> header in the incoming messages. This
is done using the <code>completionSize</code> option as shown:</p><div
class="code panel pdl" style="border-width: 1px;"><div class="codeContent
panelContent pdl">
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
from("direct:start")
// aggregate all exchanges correlated by the id header.
@@ -282,7 +282,7 @@ from("direct:start")
.aggregate(header("id"), new
BodyInAggregatingStrategy()).completionSize(header("mySize"))
.to("mock:aggregated");
]]></script>
-</div></div><p>And the same example using Spring XML:</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
+</div></div>And the same example using Spring XML:<div class="code panel pdl"
style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: xml; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[
<camelContext xmlns="http://camel.apache.org/schema/spring">
<route>
@@ -301,7 +301,7 @@ from("direct:start")
<bean id="aggregatorStrategy"
class="org.apache.camel.processor.BodyInAggregatingStrategy"/>
]]></script>
-</div></div><p><strong>Note:</strong> You can also add a fixed size value and
Camel will fallback to use this value if the dynamic value was
<code>null</code> or <code>0</code>.</p><p></p><h4
id="Aggregator2-UsingThisPattern">Using This Pattern</h4>
+</div></div><strong>Note:</strong> You can also add a fixed size value and
Camel will fallback to use this value if the dynamic value was
<code>null</code> or <code>0</code>.<p></p><h4
id="Aggregator2-UsingThisPattern">Using This Pattern</h4>
<p>If you would like to use this EIP Pattern then please read the <a
shape="rect" href="getting-started.html">Getting Started</a>, you may also find
the <a shape="rect" href="architecture.html">Architecture</a> useful
particularly the description of <a shape="rect"
href="endpoint.html">Endpoint</a> and <a shape="rect"
href="uris.html">URIs</a>. Then you could try out some of the <a shape="rect"
href="examples.html">Examples</a> first before trying this pattern out.</p><h4
id="Aggregator2-CompletingcurrentgroupdecidedfromtheAggregationStrategy">Completing
current group decided from the AggregationStrategy</h4><p><strong>Available as
of Camel 2.15</strong></p><p>The <code>AggregationStrategy</code> can now
included a property on the returned <code>Exchange</code> that contains a
boolean to indicate if the current group should be completed. This allows to
overrule any existing completion predicates / sizes / timeouts etc, and
complete the group.</p><p>For example the followin
g logic (from an unit test) will complete the group if the message body size
is larger than 5. This is done by setting the property <span
style="line-height: 1.4285715;">Exchange.AGGREGATION_COMPLETE_CURRENT_GROUP to
true.</span></p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[ public final class MyCompletionStrategy
implements AggregationStrategy {
@@ -335,7 +335,7 @@ public final class MyListOfNumbersStrate
]]></script>
</div></div><h3 id="Aggregator2-UsingAggregateController">Using
AggregateController</h3><p><strong>Available as of Camel
2.16</strong></p><p>The <code>org.apache.camel.processor.aggregate.AggregateController</code>
allows you to control the aggregate at runtime using Java or JMX API. This can
be used to force completing groups of exchanges, or query its current runtime
statistics.</p><p>The aggregator provides a default implementation if no custom
have been configured, which can be accessed
using <code>getAggregateController()</code> method. Though it may be
easier to configure a controller in the route using aggregateController as
shown below:</p><div class="code panel pdl" style="border-width: 1px;"><div
class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[private AggregateController controller = new
DefaultAggregateController();
-Â
+?
from("direct:start")
.aggregate(header("id"), new
MyAggregationStrategy()).completionSize(10).id("myAggregator")
.aggregateController(controller)
@@ -346,7 +346,7 @@ from("direct:start")
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><![CDATA[int groups =
controller.forceCompletionOfAllGroups();]]></script>
</div></div><p> </p><p>To configure this from XML DSL</p><div class="code
panel pdl" style="border-width: 1px;"><div class="codeContent panelContent pdl">
<script class="brush: java; gutter: false; theme: Default"
type="syntaxhighlighter"><
![http://www.enterpriseintegrationpatterns.com/img/Aggregator.gif"](http://www.enterpriseintegrationpatterns.com/img/Aggregator.gif"){kind=link}