Page History

{div:class=confluenceTableSmall}
|| Option || Default || Description ||
| correlationExpression | | Mandatory [Expression] which evaluates the correlation key to use for aggregation. The [Exchange] 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 {{ignoreBadCorrelationKeys}} option. |
| aggregationStrategy | | Mandatory {{AggregationStrategy}} which is used to _merge_ the incoming [Exchange] with the existing already merged exchanges. At first call the {{oldExchange}} parameter is {{null}}. On subsequent invocations the {{oldExchange}} contains the merged exchanges and {{newExchange}} is of course the new incoming Exchange. From *Camel 2.9.2* onwards the strategy can also be a {{TimeoutAwareAggregationStrategy}} implementation, supporting the timeout callback, see further below for more details. |
| strategyRef | | A reference to lookup the {{AggregationStrategy}} in the [Registry]. From *Camel 2.12* onwards you can also use a POJO as the {{AggregationStrategy}}, see further below for details. |
| strategyMethodName | | *Camel 2.12:* This option can be used to explicit declare the method name to use, when using POJOs as the {{AggregationStrategy}}. See further below for more details. |
| strategyMethodAllowNull | {{false}} | *Camel 2.12:* If this option is {{false}} then the aggregate method is not used for the very first aggregation. If this option is {{true}} then {{null}} values is used as the {{oldExchange}} (at the very first aggregation), when using POJOs as the {{AggregationStrategy}}. See further below for more details. |
| completionSize | | Number of messages aggregated before the aggregation is complete. This option can be set as either a fixed value or using an [Expression] which allows you to evaluate a size dynamically - will use {{Integer}} as result. If both are set Camel will fallback to use the fixed value if the [Expression] result was {{null}} or {{0}}. |
| completionTimeout | | 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 [Expression] which allows you to evaluate a timeout dynamically - will use {{Long}} as result. If both are set Camel will fallback to use the fixed value if the [Expression] result was {{null}} or {{0}}. You cannot use this option together with completionInterval, only one of the two can be used. |
| completionInterval | | 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. | 
| completionPredicate | | A [Predicate] to indicate when an aggregated exchange is complete. |
| completionFromBatchConsumer | {{false}} | This option is if the exchanges are coming from a [Batch Consumer]. Then when enabled the [Aggregator2] will use the batch size determined by the [Batch Consumer] in the message header {{CamelBatchSize}}. See more details at [Batch Consumer]. This can be used to aggregate all files consumed from a [File|File2] endpoint in that given poll. |
| forceCompletionOnStop | {{false}} | *Camel 2.9* Indicates to complete all current aggregated exchanges when the context is stopped |  
| eagerCheckCompletion | {{false}} | Whether or not to eager check for completion when a new incoming [Exchange] has been received. This option influences the behavior of the {{completionPredicate}} option as the [Exchange] being passed in changes accordingly. When {{false}} the [Exchange] passed in the [Predicate] is the _aggregated_ Exchange which means any information you may store on the aggregated Exchange from the {{AggregationStrategy}} is available for the [Predicate]. When {{true}} the [Exchange] passed in the [Predicate] is the _incoming_ [Exchange], which means you can access data from the incoming Exchange. |
| groupExchanges | {{false}} | If enabled then Camel will group all aggregated Exchanges into a single combined {{org.apache.camel.impl.GroupedExchange}} 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 {{AggregationStrategy}} yourself. *Important:* This option does *not* support persistent repository with the aggregator. See further below for an example and more details. |
| ignoreInvalidCorrelationKeys | {{false}} | 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. |
| closeCorrelationKeyOnCompletion |  | Whether or not too _late_ 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 {{closedCorrelationKeyException}} exception. When using this option you pass in a {{integer}} 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. |
| discardOnCompletionTimeout | {{false}} | *Camel 2.5:* Whether or not exchanges which complete due to a timeout should be discarded. If enabled then when a timeout occurs the aggregated message will *not* be sent out but dropped (discarded). |
| aggregationRepository | | Allows you to plugin you own implementation of {{org.apache.camel.spi.AggregationRepository}} which keeps track of the current inflight aggregated exchanges. Camel uses by default a memory based implementation. |
| aggregationRepositoryRef | | Reference to lookup a {{aggregationRepository}} in the [Registry]. |
| parallelProcessing | {{false}} | 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. |
| executorService | | If using {{parallelProcessing}} you can specify a custom thread pool to be used. In fact also if you are not using {{parallelProcessing}} this custom thread pool is used to send out aggregated exchanges as well. |
| executorServiceRef | | Reference to lookup a {{executorService}} in the [Registry] |
| timeoutCheckerExecutorService | | *Camel 2.9:* If using either of the {{completionTimeout}}, {{completionTimeoutExpression}}, or {{completionInterval}} 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. |
| timeoutCheckerExecutorServiceRef | | *Camel 2.9:* Reference to lookup a {{timeoutCheckerExecutorService}} in the [Registry] |
| optimisticLocking | {{false}} | *Camel 2.11:* Turns on using optimistic locking, which requires the {{aggregationRepository}} being used, is supporting this by implementing the {{org.apache.camel.spi.OptimisticLockingAggregationRepository}} interface. |
| optimisticLockRetryPolicy | | *Camel 2.11.1:* Allows to configure retry settings when using optimistic locking. |
{div}

{div:class=confluenceTableSmall}
|| header || type || description ||
| {{CamelAggregatedSize}} | int | The total number of Exchanges aggregated into this combined Exchange. | 
| {{CamelAggregatedCompletedBy}} | String | Indicator how the aggregation was completed as a value of either: {{predicate}}, {{size}}, {{consumer}}, {{timeout}}, {{forceCompletion}} or {{interval}}. |
{div}

//simply combines Exchange String body values using '+' as a delimiter
class StringAggregationStrategy implements AggregationStrategy {

    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
        if (oldExchange == null) {
            return newExchange;
        }

        String oldBody = oldExchange.getIn().getBody(String.class);
        String newBody = newExchange.getIn().getBody(String.class);
        oldExchange.getIn().setBody(oldBody + "+" + newBody);
        return oldExchange;
    }
}

//simply combines Exchange body values into an ArrayList<Object>
class ArrayListAggregationStrategy implements AggregationStrategy {

    public Exchange aggregate(Exchange oldExchange, Exchange newExchange) {
		Object newBody = newExchange.getIn().getBody();
		ArrayList<Object> list = null;
        if (oldExchange == null) {
			list = new ArrayList<Object>();
			list.add(newBody);
			newExchange.getIn().setBody(list);
			return newExchange;
        } else {
	        list = oldExchange.getIn().getBody(ArrayList.class);
			list.add(newBody);
			return oldExchange;
		}
    }
}

See the TimeoutAwareAggregationStrategy and CompletionAwareAggregationStrategy extensions to AggregationStrategy that has callbacks when the aggregated Exchange was completed and if a timeout occurred.

Many of the options are configurable as attributes on the <aggregate> tag when using Spring XML.

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateSimpleTimeoutTest.java}

{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/processor/aggregator/SpringAggregateSimpleTimeoutTest.xml}

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateSimpleSizeTest.java}

{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/processor/aggregator/SpringAggregateSimpleSizeTest.xml}

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateSimplePredicateTest.java}

{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/processor/aggregator/SpringAggregateSimplePredicateTest.xml}

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateSimplePredicateEagerTest.java}

{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/processor/aggregator/SpringAggregateSimplePredicateEagerTest.xml}

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateExpressionTimeoutTest.java}

{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/processor/aggregator/SpringAggregateExpressionTimeoutTest.xml}

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/AggregateExpressionSizeTest.java}

{snippet:id=e1|lang=xml|url=camel/trunk/components/camel-spring/src/test/resources/org/apache/camel/spring/processor/aggregator/SpringAggregateExpressionSizeTest.xml}

{snippet:id=e1|lang=java|url=camel/trunk/camel-core/src/test/java/org/apache/camel/processor/aggregator/CustomListAggregationStrategyTest.java}

                from("direct:start")
                    // aggregate all using same expression
                    .aggregate(constant(true))
                    // wait for 0.5 seconds to aggregate
                    .completionTimeout(500L)
                    // group the exchanges so we get one single exchange containing all the others
                    .groupExchanges()
                    .to("mock:result");

List<Exchange> grouped = out.getProperty(Exchange.GROUPED_EXCHANGE, List.class);

List<Exchange> grouped = exchange.getIn().getBody(List.class);

Notice the old way using the property is still present in Camel 2.13 onwards, but its considered deprecated and to be removed in Camel 3.0 onwards.

You can use POJOs as AggregationStrategy with the other EIPs that supports aggregation, such as Splitter, Recipient List, etc.

public String append(String existing, String next) {
  return existing + next;
}

public String append(String existing, Map existingHeaders, String next, Map nextHeaders) {
  return existing + next;
}

public String append(String existing, Map existingHeaders, Map existingProperties, String next, Map nextHeaders, Map nextProperties) {
  return existing + next;
}

public class MyBodyAppender {

    public String append(String existing, String next) {
        return next + existing;
    }

}

    private MyBodyAppender appender = new MyBodyAppender();

    public void configure() throws Exception {
        from("direct:start")
            .aggregate(constant(true), AggregationStrategies.bean(appender, "append"))
                .completionSize(3)
                .to("mock:result");
    }

    public void configure() throws Exception {
        from("direct:start")
            .aggregate(constant(true), AggregationStrategies.bean(MyBodyAppender.class, "append"))
                .completionSize(3)
                .to("mock:result");
    }

    public void configure() throws Exception {
        from("direct:start")
            .aggregate(constant(true), AggregationStrategies.bean(MyBodyAppender.class))
                .completionSize(3)
                .to("mock:result");
    }

public class MyBodyAppender {

    public static String append(String existing, String next) {
        return next + existing;
    }

}

    <bean id="myAppender" class="com.foo.MyBodyAppender"/>

    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="direct:start"/>
            <aggregate strategyRef="myAppender" strategyMethodName="append" completionSize="3">
                <correlationExpression>
                    <constant>true</constant>
                </correlationExpression>
                <to uri="mock:result"/>
            </aggregate>
        </route>
    </camelContext>

    public void configure() throws Exception {
        AggregationStrategyBeanAdapter myStrategy = new AggregationStrategyBeanAdapter(appender, "append");
        myStrategy.setAllowNullOldExchange(true);
        myStrategy.setAllowNullNewExchange(true);

        from("direct:start")
            .pollEnrich("seda:foo", 1000, myStrategy)
                .to("mock:result");
    }

    public void configure() throws Exception {
        from("direct:start")
            .pollEnrich("seda:foo", 1000, AggregationStrategies.beanAllowNull(appender, "append"))
                .to("mock:result");
    }

    public class MyBodyAppender {

        public String append(String existing, String next) {
            if (next == null) {
                return "NewWasNull" + existing;
            } else {
                return existing + next;
            }
        }

    }

    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="direct:start"/>
            <aggregate strategyRef="myAppender" strategyMethodName="append" strategyMethodAllowNull="true" completionSize="3">
                <correlationExpression>
                    <constant>true</constant>
                </correlationExpression>
                <to uri="mock:result"/>
            </aggregate>
        </route>
    </camelContext>

    public static final class MyUserAppender {

        public List addUsers(List names, User user) {
            if (names == null) {
                names = new ArrayList();
            }
            names.add(user.getName());
            return names;
        }
    }