AggregateDefinition (Camel :: Core 2.17.7 API)

java.lang.Object
- org.apache.camel.model.OptionalIdentifiedDefinition<Type>
- - org.apache.camel.model.ProcessorDefinition<AggregateDefinition>
  - - org.apache.camel.model.AggregateDefinition

All Implemented Interfaces:

ExecutorServiceAware, Block, ExecutorServiceAwareDefinition<AggregateDefinition>, OtherAttributesAware, NamedNode
```
@Metadata(label="eip,routing")
public class AggregateDefinition
extends ProcessorDefinition<AggregateDefinition>
implements ExecutorServiceAwareDefinition<AggregateDefinition>
```
Aggregates many messages into a single message

Version:

Field Summary
- Fields inherited from class org.apache.camel.model.ProcessorDefinition
  inheritErrorHandler, log

Constructor Summary

Constructors
Constructor and Description
`AggregateDefinition()`
`AggregateDefinition(Expression expression)`
`AggregateDefinition(Expression correlationExpression, AggregationStrategy aggregationStrategy)`
`AggregateDefinition(ExpressionDefinition correlationExpression)`
`AggregateDefinition(Predicate predicate)`

Method Summary

Methods
Modifier and Type	Method and Description
`AggregateDefinition`	`aggregateController(AggregateController aggregateController)` To use a `AggregateController` to allow external sources to control this aggregator.
`AggregateDefinition`	`aggregationRepository(AggregationRepository aggregationRepository)` Sets the custom aggregate repository to use.
`AggregateDefinition`	`aggregationRepositoryRef(String aggregationRepositoryRef)` Sets the custom aggregate repository to use Will by default use `MemoryAggregationRepository`
`AggregateDefinition`	`aggregationStrategy(AggregationStrategy aggregationStrategy)` Sets the aggregate strategy to use
`AggregateDefinition`	`aggregationStrategyMethodAllowNull()` Sets allowing null when using a POJO as `AggregationStrategy`.
`AggregateDefinition`	`aggregationStrategyMethodName(String methodName)` Sets the method name to use when using a POJO as `AggregationStrategy`.
`AggregateDefinition`	`aggregationStrategyRef(String aggregationStrategyRef)` Sets the aggregate strategy to use
`protected void`	`checkNoCompletedPredicate()`
`AggregateDefinition`	`closeCorrelationKeyOnCompletion(int capacity)` Closes a correlation key when its complete.
`AggregateDefinition`	`completeAllOnStop()` Indicates to wait to complete all current and partial (pending) aggregated exchanges when the context is stopped.
`AggregateDefinition`	`completionFromBatchConsumer()` Enables the batch completion mode where we aggregate from a `BatchConsumer` and aggregate the total number of exchanges the `BatchConsumer` has reported as total by checking the exchange property `Exchange.BATCH_COMPLETE` when its complete.
`AggregateDefinition`	`completionInterval(long completionInterval)` Sets the completion interval, which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
`AggregateDefinition`	`completionPredicate(Predicate predicate)` Sets the predicate used to determine if the aggregation is completed
`AggregateDefinition`	`completionSize(Expression completionSize)` Sets the completion size, which is the number of aggregated exchanges which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
`AggregateDefinition`	`completionSize(int completionSize)` Sets the completion size, which is the number of aggregated exchanges which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
`AggregateDefinition`	`completionTimeout(Expression completionTimeout)` Sets the completion timeout, which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
`AggregateDefinition`	`completionTimeout(long completionTimeout)` Sets the completion timeout, which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
`void`	`configureChild(ProcessorDefinition<?> output)` Strategy for children to do any custom configuration
`protected AggregateProcessor`	`createAggregator(RouteContext routeContext)`
`Processor`	`createProcessor(RouteContext routeContext)` Override this in definition class and implement logic to create the processor based on the definition model.
`protected String`	`description()`
`AggregateDefinition`	`discardOnCompletionTimeout()` Discards the aggregated message on completion timeout.
`AggregateDefinition`	`eagerCheckCompletion()` Use eager completion checking which means that the {{completionPredicate}} will use the incoming Exchange.
`AggregateDefinition`	`executorService(ExecutorService executorService)` If using parallelProcessing you can specify a custom thread pool to be used.
`AggregateDefinition`	`executorServiceRef(String executorServiceRef)` If using parallelProcessing you can specify a custom thread pool to be used.
`AggregateDefinition`	`forceCompletionOnStop()` Indicates to complete all current aggregated exchanges when the context is stopped
`AggregateController`	`getAggregateController()`
`String`	`getAggregateControllerRef()`
`AggregationRepository`	`getAggregationRepository()`
`String`	`getAggregationRepositoryRef()`
`AggregationStrategy`	`getAggregationStrategy()`
`String`	`getAggregationStrategyMethodName()`
`String`	`getAggregationStrategyRef()`
`Integer`	`getCloseCorrelationKeyOnCompletion()`
`Boolean`	`getCompleteAllOnStop()`
`Boolean`	`getCompletionFromBatchConsumer()`
`Long`	`getCompletionInterval()`
`ExpressionSubElementDefinition`	`getCompletionPredicate()`
`Integer`	`getCompletionSize()`
`ExpressionSubElementDefinition`	`getCompletionSizeExpression()`
`Long`	`getCompletionTimeout()`
`ExpressionSubElementDefinition`	`getCompletionTimeoutExpression()`
`ExpressionSubElementDefinition`	`getCorrelationExpression()`
`Boolean`	`getDiscardOnCompletionTimeout()`
`Boolean`	`getEagerCheckCompletion()`
`ExecutorService`	`getExecutorService()` Gets the executor service
`String`	`getExecutorServiceRef()` Gets the reference to lookup in the `Registry` for the executor service to be used.
`ExpressionDefinition`	`getExpression()`
`Boolean`	`getForceCompletionOnStop()`
`Boolean`	`getGroupExchanges()`
`Boolean`	`getIgnoreInvalidCorrelationKeys()`
`String`	`getLabel()` Returns a label to describe this node such as the expression if some kind of expression node
`Boolean`	`getOptimisticLocking()`
`OptimisticLockRetryPolicy`	`getOptimisticLockRetryPolicy()`
`OptimisticLockRetryPolicyDefinition`	`getOptimisticLockRetryPolicyDefinition()`
`List<ProcessorDefinition<?>>`	`getOutputs()`
`Boolean`	`getParallelProcessing()`
`Boolean`	`getStrategyMethodAllowNull()`
`String`	`getStrategyMethodName()`
`String`	`getStrategyRef()`
`ScheduledExecutorService`	`getTimeoutCheckerExecutorService()`
`String`	`getTimeoutCheckerExecutorServiceRef()`
`AggregateDefinition`	`groupExchanges()` Deprecated. use `GroupedExchangeAggregationStrategy` as aggregation strategy instead.
`AggregateDefinition`	`ignoreInvalidCorrelationKeys()` If a correlation key cannot be successfully evaluated it will be ignored by logging a {{DEBUG}} and then just ignore the incoming Exchange.
`boolean`	`isOutputSupported()`
`AggregateDefinition`	`optimisticLocking()` Turns on using optimistic locking, which requires the aggregationRepository being used, is supporting this by implementing `OptimisticLockingAggregationRepository`.
`AggregateDefinition`	`optimisticLockRetryPolicy(OptimisticLockRetryPolicy policy)` Allows to configure retry settings when using optimistic locking.
`AggregateDefinition`	`parallelProcessing()` When aggregated are completed they are being send out of the aggregator.
`AggregateDefinition`	`parallelProcessing(boolean parallelProcessing)` When aggregated are completed they are being send out of the aggregator.
`void`	`setAggregateController(AggregateController aggregateController)`
`void`	`setAggregateControllerRef(String aggregateControllerRef)` To use a `AggregateController` to allow external sources to control this aggregator.
`void`	`setAggregationRepository(AggregationRepository aggregationRepository)`
`void`	`setAggregationRepositoryRef(String aggregationRepositoryRef)`
`void`	`setAggregationStrategy(AggregationStrategy aggregationStrategy)` The AggregationStrategy to use.
`void`	`setAggregationStrategyMethodName(String strategyMethodName)` This option can be used to explicit declare the method name to use, when using POJOs as the AggregationStrategy.
`void`	`setAggregationStrategyRef(String aggregationStrategyRef)` A reference to lookup the AggregationStrategy in the Registry.
`void`	`setCloseCorrelationKeyOnCompletion(Integer closeCorrelationKeyOnCompletion)`
`void`	`setCompleteAllOnStop(Boolean completeAllOnStop)`
`void`	`setCompletionFromBatchConsumer(Boolean completionFromBatchConsumer)`
`void`	`setCompletionInterval(Long completionInterval)`
`void`	`setCompletionPredicate(ExpressionSubElementDefinition completionPredicate)`
`void`	`setCompletionSize(Integer completionSize)`
`void`	`setCompletionSizeExpression(ExpressionSubElementDefinition completionSizeExpression)`
`void`	`setCompletionTimeout(Long completionTimeout)`
`void`	`setCompletionTimeoutExpression(ExpressionSubElementDefinition completionTimeoutExpression)`
`void`	`setCorrelationExpression(ExpressionSubElementDefinition correlationExpression)` The expression used to calculate the correlation key to use for aggregation.
`void`	`setDiscardOnCompletionTimeout(Boolean discardOnCompletionTimeout)`
`void`	`setEagerCheckCompletion(Boolean eagerCheckCompletion)`
`void`	`setExecutorService(ExecutorService executorService)` Sets the executor service to be used.
`void`	`setExecutorServiceRef(String executorServiceRef)` Sets a reference to lookup in the `Registry` for the executor service to be used.
`void`	`setExpression(ExpressionDefinition expression)`
`void`	`setForceCompletionOnStop(Boolean forceCompletionOnStop)`
`void`	`setGroupExchanges(Boolean groupExchanges)`
`void`	`setIgnoreInvalidCorrelationKeys(Boolean ignoreInvalidCorrelationKeys)`
`void`	`setOptimisticLocking(boolean optimisticLocking)`
`void`	`setOptimisticLockRetryPolicy(OptimisticLockRetryPolicy optimisticLockRetryPolicy)`
`void`	`setOptimisticLockRetryPolicyDefinition(OptimisticLockRetryPolicyDefinition optimisticLockRetryPolicyDefinition)`
`void`	`setOutputs(List<ProcessorDefinition<?>> outputs)`
`void`	`setParallelProcessing(boolean parallelProcessing)`
`void`	`setStrategyMethodAllowNull(Boolean strategyMethodAllowNull)` If this option is false then the aggregate method is not used for the very first aggregation.
`void`	`setStrategyMethodName(String strategyMethodName)` This option can be used to explicit declare the method name to use, when using POJOs as the AggregationStrategy.
`void`	`setStrategyRef(String strategyRef)` A reference to lookup the AggregationStrategy in the Registry.
`void`	`setTimeoutCheckerExecutorService(ScheduledExecutorService timeoutCheckerExecutorService)`
`void`	`setTimeoutCheckerExecutorServiceRef(String timeoutCheckerExecutorServiceRef)`
`AggregateDefinition`	`timeoutCheckerExecutorService(ScheduledExecutorService executorService)` If using either of the completionTimeout, completionTimeoutExpression, or completionInterval options a background thread is created to check for the completion for every aggregator.
`AggregateDefinition`	`timeoutCheckerExecutorServiceRef(String executorServiceRef)` If using either of the completionTimeout, completionTimeoutExpression, or completionInterval options a background thread is created to check for the completion for every aggregator.
`String`	`toString()`

Methods inherited from class org.apache.camel.model.ProcessorDefinition
addInterceptStrategies, addInterceptStrategy, addOutput, addRoutes, aggregate, aggregate, aggregate, aggregate, aop, attribute, bean, bean, bean, bean, bean, bean, bean, bean, beanRef, beanRef, beanRef, beanRef, beanRef, choice, clearOutput, convertBodyTo, convertBodyTo, createChannel, createChildProcessor, createCompositeProcessor, createOutputsProcessor, createOutputsProcessor, createOutputsProcessorImpl, createProcessor, delay, delay, delay, doTry, dynamicRouter, dynamicRouter, end, endChoice, endDoTry, endParent, endRest, enrich, enrich, enrich, enrich, enrich, enrichRef, enrichRef, enrichRef, filter, filter, filter, filter, getIndex, getInterceptStrategies, getOtherAttributes, getParent, id, idempotentConsumer, idempotentConsumer, idempotentConsumer, inheritErrorHandler, inOnly, inOnly, inOnly, inOnly, inOnly, inOnly, inOut, inOut, inOut, inOut, inOut, inOut, isAbstract, isInheritErrorHandler, isTopLevelOnly, loadBalance, loadBalance, log, log, log, log, log, log, loop, loop, loop, loopDoWhile, makeProcessor, markRollbackOnly, markRollbackOnlyLast, marshal, marshal, marshal, marshal, multicast, multicast, multicast, onCompletion, onException, onException, pipeline, pipeline, pipeline, pipeline, placeholder, policy, policy, pollEnrich, pollEnrich, pollEnrich, pollEnrich, pollEnrich, pollEnrich, pollEnrich, pollEnrichRef, pollEnrichRef, preCreateProcessor, process, process, processRef, recipientList, recipientList, recipientList, recipientList, removeFaultHeader, removeHeader, removeHeaders, removeHeaders, removeProperties, removeProperties, removeProperty, resequence, resequence, rollback, rollback, routeDescription, routeId, routingSlip, routingSlip, routingSlip, routingSlip, routingSlip, routingSlip, routingSlip, sample, sample, sample, script, script, setBody, setBody, setExchangePattern, setFaultBody, setFaultHeader, setHeader, setHeader, setInheritErrorHandler, setOtherAttributes, setOutHeader, setOutHeader, setParent, setProperty, setProperty, sort, sort, sort, split, split, split, startupOrder, stop, threads, threads, threads, threads, throttle, throttle, throwException, throwException, to, to, to, to, to, to, to, to, to, to, toD, toD, toF, transacted, transacted, transform, transform, unmarshal, unmarshal, unmarshal, unmarshal, validate, validate, validate, wireTap, wireTap, wireTap, wireTap, wireTap, wireTap, wireTap, wireTap, wireTap, wrapChannel, wrapChannel, wrapInErrorHandler, wrapProcessor

Methods inherited from class org.apache.camel.model.OptionalIdentifiedDefinition
description, description, getCustomId, getDescription, getDescriptionText, getId, getShortName, hasCustomIdAssigned, idOrCreate, setCustomId, setDescription, setId

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - AggregateDefinition
```
public AggregateDefinition()
```
  - AggregateDefinition
```
public AggregateDefinition(Predicate predicate)
```
  - AggregateDefinition
```
public AggregateDefinition(Expression expression)
```
  - AggregateDefinition
```
public AggregateDefinition(ExpressionDefinition correlationExpression)
```
  - AggregateDefinition
```
public AggregateDefinition(Expression correlationExpression,
                   AggregationStrategy aggregationStrategy)
```
- Method Detail
  - toString
```
public String toString()
```
    Overrides:
    
    toString in class Object
  - description
```
protected String description()
```
  - getLabel
```
public String getLabel()
```
    Description copied from class: ProcessorDefinition
    
    Returns a label to describe this node such as the expression if some kind of expression node
    
    Specified by:
    
    getLabel in interface NamedNode
    
    Overrides:
    
    getLabel in class ProcessorDefinition<AggregateDefinition>
  - createProcessor
```
public Processor createProcessor(RouteContext routeContext)
                          throws Exception
```
    Description copied from class: ProcessorDefinition
    
    Override this in definition class and implement logic to create the processor based on the definition model.
    
    Overrides:
    
    createProcessor in class ProcessorDefinition<AggregateDefinition>
    
    Throws:
    
    Exception
  - createAggregator
```
protected AggregateProcessor createAggregator(RouteContext routeContext)
                                       throws Exception
```
    Throws:
    
    Exception
  - configureChild
```
public void configureChild(ProcessorDefinition<?> output)
```
    Description copied from class: ProcessorDefinition
    
    Strategy for children to do any custom configuration
    
    Overrides:
    
    configureChild in class ProcessorDefinition<AggregateDefinition>
    
    Parameters:
    output - the child to be added as output to this
  - getAggregationStrategy
```
public AggregationStrategy getAggregationStrategy()
```
  - setAggregationStrategy
```
public void setAggregationStrategy(AggregationStrategy aggregationStrategy)
```
    The AggregationStrategy to use.
    Configuring an AggregationStrategy is required, and 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.
  - getAggregationStrategyRef
```
public String getAggregationStrategyRef()
```
  - setAggregationStrategyRef
```
public void setAggregationStrategyRef(String aggregationStrategyRef)
```
    A reference to lookup the AggregationStrategy in the Registry.
    Configuring an AggregationStrategy is required, and 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.
  - getStrategyRef
```
public String getStrategyRef()
```
  - setStrategyRef
```
public void setStrategyRef(String strategyRef)
```
    A reference to lookup the AggregationStrategy in the Registry.
    Configuring an AggregationStrategy is required, and 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.
  - getAggregationStrategyMethodName
```
public String getAggregationStrategyMethodName()
```
  - setAggregationStrategyMethodName
```
public void setAggregationStrategyMethodName(String strategyMethodName)
```
    This option can be used to explicit declare the method name to use, when using POJOs as the AggregationStrategy.
  - getStrategyMethodAllowNull
```
public Boolean getStrategyMethodAllowNull()
```
  - getStrategyMethodName
```
public String getStrategyMethodName()
```
  - setStrategyMethodName
```
public void setStrategyMethodName(String strategyMethodName)
```
    This option can be used to explicit declare the method name to use, when using POJOs as the AggregationStrategy.
  - setStrategyMethodAllowNull
```
public void setStrategyMethodAllowNull(Boolean strategyMethodAllowNull)
```
    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.
  - setCorrelationExpression
```
public void setCorrelationExpression(ExpressionSubElementDefinition correlationExpression)
```
    The expression used to calculate 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.
  - getCorrelationExpression
```
public ExpressionSubElementDefinition getCorrelationExpression()
```
  - getCompletionSize
```
public Integer getCompletionSize()
```
  - setCompletionSize
```
public void setCompletionSize(Integer completionSize)
```
  - getOptimisticLockRetryPolicyDefinition
```
public OptimisticLockRetryPolicyDefinition getOptimisticLockRetryPolicyDefinition()
```
  - setOptimisticLockRetryPolicyDefinition
```
public void setOptimisticLockRetryPolicyDefinition(OptimisticLockRetryPolicyDefinition optimisticLockRetryPolicyDefinition)
```
  - getOptimisticLockRetryPolicy
```
public OptimisticLockRetryPolicy getOptimisticLockRetryPolicy()
```
  - setOptimisticLockRetryPolicy
```
public void setOptimisticLockRetryPolicy(OptimisticLockRetryPolicy optimisticLockRetryPolicy)
```
  - getCompletionInterval
```
public Long getCompletionInterval()
```
  - setCompletionInterval
```
public void setCompletionInterval(Long completionInterval)
```
  - getCompletionTimeout
```
public Long getCompletionTimeout()
```
  - setCompletionTimeout
```
public void setCompletionTimeout(Long completionTimeout)
```
  - getCompletionPredicate
```
public ExpressionSubElementDefinition getCompletionPredicate()
```
  - setCompletionPredicate
```
public void setCompletionPredicate(ExpressionSubElementDefinition completionPredicate)
```
  - getCompletionTimeoutExpression
```
public ExpressionSubElementDefinition getCompletionTimeoutExpression()
```
  - setCompletionTimeoutExpression
```
public void setCompletionTimeoutExpression(ExpressionSubElementDefinition completionTimeoutExpression)
```
  - getCompletionSizeExpression
```
public ExpressionSubElementDefinition getCompletionSizeExpression()
```
  - setCompletionSizeExpression
```
public void setCompletionSizeExpression(ExpressionSubElementDefinition completionSizeExpression)
```
  - getGroupExchanges
```
public Boolean getGroupExchanges()
```
  - setGroupExchanges
```
public void setGroupExchanges(Boolean groupExchanges)
```
  - getCompletionFromBatchConsumer
```
public Boolean getCompletionFromBatchConsumer()
```
  - setCompletionFromBatchConsumer
```
public void setCompletionFromBatchConsumer(Boolean completionFromBatchConsumer)
```
  - getExecutorService
```
public ExecutorService getExecutorService()
```
    Description copied from interface: ExecutorServiceAware
    
    Gets the executor service
    
    Specified by:
    
    getExecutorService in interface ExecutorServiceAware
    
    Returns:
    the executor
  - setExecutorService
```
public void setExecutorService(ExecutorService executorService)
```
    Description copied from interface: ExecutorServiceAware
    
    Sets the executor service to be used.
    
    Specified by:
    
    setExecutorService in interface ExecutorServiceAware
    
    Parameters:
    executorService - the executor
  - getOptimisticLocking
```
public Boolean getOptimisticLocking()
```
  - setOptimisticLocking
```
public void setOptimisticLocking(boolean optimisticLocking)
```
  - getParallelProcessing
```
public Boolean getParallelProcessing()
```
  - setParallelProcessing
```
public void setParallelProcessing(boolean parallelProcessing)
```
  - getExecutorServiceRef
```
public String getExecutorServiceRef()
```
    Description copied from interface: ExecutorServiceAware
    
    Gets the reference to lookup in the Registry for the executor service to be used.
    
    Specified by:
    
    getExecutorServiceRef in interface ExecutorServiceAware
    
    Returns:
    the reference, or null if the executor was set directly
  - setExecutorServiceRef
```
public void setExecutorServiceRef(String executorServiceRef)
```
    Description copied from interface: ExecutorServiceAware
    
    Sets a reference to lookup in the Registry for the executor service to be used.
    
    Specified by:
    
    setExecutorServiceRef in interface ExecutorServiceAware
    
    Parameters:
    executorServiceRef - reference for the executor
  - getEagerCheckCompletion
```
public Boolean getEagerCheckCompletion()
```
  - setEagerCheckCompletion
```
public void setEagerCheckCompletion(Boolean eagerCheckCompletion)
```
  - getIgnoreInvalidCorrelationKeys
```
public Boolean getIgnoreInvalidCorrelationKeys()
```
  - setIgnoreInvalidCorrelationKeys
```
public void setIgnoreInvalidCorrelationKeys(Boolean ignoreInvalidCorrelationKeys)
```
  - getCloseCorrelationKeyOnCompletion
```
public Integer getCloseCorrelationKeyOnCompletion()
```
  - setCloseCorrelationKeyOnCompletion
```
public void setCloseCorrelationKeyOnCompletion(Integer closeCorrelationKeyOnCompletion)
```
  - getAggregationRepository
```
public AggregationRepository getAggregationRepository()
```
  - setAggregationRepository
```
public void setAggregationRepository(AggregationRepository aggregationRepository)
```
  - getAggregationRepositoryRef
```
public String getAggregationRepositoryRef()
```
  - setAggregationRepositoryRef
```
public void setAggregationRepositoryRef(String aggregationRepositoryRef)
```
  - getDiscardOnCompletionTimeout
```
public Boolean getDiscardOnCompletionTimeout()
```
  - setDiscardOnCompletionTimeout
```
public void setDiscardOnCompletionTimeout(Boolean discardOnCompletionTimeout)
```
  - setTimeoutCheckerExecutorService
```
public void setTimeoutCheckerExecutorService(ScheduledExecutorService timeoutCheckerExecutorService)
```
  - getTimeoutCheckerExecutorService
```
public ScheduledExecutorService getTimeoutCheckerExecutorService()
```
  - setTimeoutCheckerExecutorServiceRef
```
public void setTimeoutCheckerExecutorServiceRef(String timeoutCheckerExecutorServiceRef)
```
  - getTimeoutCheckerExecutorServiceRef
```
public String getTimeoutCheckerExecutorServiceRef()
```
  - getForceCompletionOnStop
```
public Boolean getForceCompletionOnStop()
```
  - setForceCompletionOnStop
```
public void setForceCompletionOnStop(Boolean forceCompletionOnStop)
```
  - getCompleteAllOnStop
```
public Boolean getCompleteAllOnStop()
```
  - setCompleteAllOnStop
```
public void setCompleteAllOnStop(Boolean completeAllOnStop)
```
  - getAggregateController
```
public AggregateController getAggregateController()
```
  - setAggregateController
```
public void setAggregateController(AggregateController aggregateController)
```
  - getAggregateControllerRef
```
public String getAggregateControllerRef()
```
  - setAggregateControllerRef
```
public void setAggregateControllerRef(String aggregateControllerRef)
```
    To use a AggregateController to allow external sources to control this aggregator.
  - eagerCheckCompletion
```
public AggregateDefinition eagerCheckCompletion()
```
    Use eager completion checking which means that the {{completionPredicate}} will use the incoming Exchange. At opposed to without eager completion checking the {{completionPredicate}} will use the aggregated Exchange.
    
    Returns:
    builder
  - ignoreInvalidCorrelationKeys
```
public AggregateDefinition ignoreInvalidCorrelationKeys()
```
    If a correlation key cannot be successfully evaluated it will be ignored by logging a {{DEBUG}} and then just ignore the incoming Exchange.
    
    Returns:
    builder
  - closeCorrelationKeyOnCompletion
```
public AggregateDefinition closeCorrelationKeyOnCompletion(int capacity)
```
    Closes a correlation key when its complete. Any late received exchanges which has a correlation key that has been closed, it will be defined and a ClosedCorrelationKeyException is thrown.
    
    Parameters:
    capacity - the maximum capacity of the closed correlation key cache. Use 0 or negative value for unbounded capacity.
    
    Returns:
    builder
  - discardOnCompletionTimeout
```
public AggregateDefinition discardOnCompletionTimeout()
```
    Discards the aggregated message on completion timeout.
    This means on timeout the aggregated message is dropped and not sent out of the aggregator.
    
    Returns:
    builder
  - completionFromBatchConsumer
```
public AggregateDefinition completionFromBatchConsumer()
```
    Enables the batch completion mode where we aggregate from a BatchConsumer and aggregate the total number of exchanges the BatchConsumer has reported as total by checking the exchange property Exchange.BATCH_COMPLETE when its complete.
    
    Returns:
    builder
  - completionSize
```
public AggregateDefinition completionSize(int completionSize)
```
    Sets the completion size, which is the number of aggregated exchanges which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
    
    Parameters:
    completionSize - the completion size
    
    Returns:
    builder
  - completionSize
```
public AggregateDefinition completionSize(Expression completionSize)
```
    Sets the completion size, which is the number of aggregated exchanges which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
    
    Parameters:
    completionSize - the completion size as an Expression which is evaluated as a Integer type
    
    Returns:
    builder
  - completionInterval
```
public AggregateDefinition completionInterval(long completionInterval)
```
    Sets the completion interval, which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
    
    Parameters:
    completionInterval - the interval in millis
    
    Returns:
    the builder
  - completionTimeout
```
public AggregateDefinition completionTimeout(long completionTimeout)
```
    Sets the completion timeout, which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
    
    Parameters:
    completionTimeout - the timeout in millis
    
    Returns:
    the builder
  - completionTimeout
```
public AggregateDefinition completionTimeout(Expression completionTimeout)
```
    Sets the completion timeout, which would cause the aggregate to consider the group as complete and send out the aggregated exchange.
    
    Parameters:
    completionTimeout - the timeout as an Expression which is evaluated as a Long type
    
    Returns:
    the builder
  - aggregationStrategy
```
public AggregateDefinition aggregationStrategy(AggregationStrategy aggregationStrategy)
```
    Sets the aggregate strategy to use
    
    Parameters:
    aggregationStrategy - the aggregate strategy to use
    
    Returns:
    the builder
  - aggregationStrategyRef
```
public AggregateDefinition aggregationStrategyRef(String aggregationStrategyRef)
```
    Sets the aggregate strategy to use
    
    Parameters:
    aggregationStrategyRef - reference to the strategy to lookup in the registry
    
    Returns:
    the builder
  - aggregationStrategyMethodName
```
public AggregateDefinition aggregationStrategyMethodName(String methodName)
```
    Sets the method name to use when using a POJO as AggregationStrategy.
    
    Parameters:
    methodName - the method name to call
    
    Returns:
    the builder
  - aggregationStrategyMethodAllowNull
```
public AggregateDefinition aggregationStrategyMethodAllowNull()
```
    Sets allowing null when using a POJO as AggregationStrategy.
    
    Returns:
    the builder
  - aggregationRepository
```
public AggregateDefinition aggregationRepository(AggregationRepository aggregationRepository)
```
    Sets the custom aggregate repository to use.
    Will by default use MemoryAggregationRepository
    
    Parameters:
    aggregationRepository - the aggregate repository to use
    
    Returns:
    the builder
  - aggregationRepositoryRef
```
public AggregateDefinition aggregationRepositoryRef(String aggregationRepositoryRef)
```
    Sets the custom aggregate repository to use
    Will by default use MemoryAggregationRepository
    
    Parameters:
    aggregationRepositoryRef - reference to the repository to lookup in the registry
    
    Returns:
    the builder
  - groupExchanges
```
@Deprecated
public AggregateDefinition groupExchanges()
```
    Deprecated. use GroupedExchangeAggregationStrategy as aggregation strategy instead.
    
    Enables grouped exchanges, so the aggregator will group all aggregated exchanges into a single combined Exchange holding all the aggregated exchanges in a List.
  - completionPredicate
```
public AggregateDefinition completionPredicate(Predicate predicate)
```
    Sets the predicate used to determine if the aggregation is completed
  - forceCompletionOnStop
```
public AggregateDefinition forceCompletionOnStop()
```
    Indicates to complete all current aggregated exchanges when the context is stopped
  - completeAllOnStop
```
public AggregateDefinition completeAllOnStop()
```
    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.
  - parallelProcessing
```
public AggregateDefinition parallelProcessing()
```
    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.
  - parallelProcessing
```
public AggregateDefinition parallelProcessing(boolean parallelProcessing)
```
    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.
  - optimisticLocking
```
public AggregateDefinition optimisticLocking()
```
    Turns on using optimistic locking, which requires the aggregationRepository being used, is supporting this by implementing OptimisticLockingAggregationRepository.
  - optimisticLockRetryPolicy
```
public AggregateDefinition optimisticLockRetryPolicy(OptimisticLockRetryPolicy policy)
```
    Allows to configure retry settings when using optimistic locking.
  - executorService
```
public AggregateDefinition executorService(ExecutorService 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.
    
    Specified by:
    
    executorService in interface ExecutorServiceAwareDefinition<AggregateDefinition>
    
    Parameters:
    executorService - the executor service
    
    Returns:
    the builder
  - executorServiceRef
```
public AggregateDefinition executorServiceRef(String executorServiceRef)
```
    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.
    
    Specified by:
    
    executorServiceRef in interface ExecutorServiceAwareDefinition<AggregateDefinition>
    
    Parameters:
    executorServiceRef - reference for a ExecutorService to lookup in the Registry
    
    Returns:
    the builder
  - timeoutCheckerExecutorService
```
public AggregateDefinition timeoutCheckerExecutorService(ScheduledExecutorService executorService)
```
    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
```
public AggregateDefinition timeoutCheckerExecutorServiceRef(String executorServiceRef)
```
    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.
  - aggregateController
```
public AggregateDefinition aggregateController(AggregateController aggregateController)
```
    To use a AggregateController to allow external sources to control this aggregator.
  - getExpression
```
public ExpressionDefinition getExpression()
```
  - setExpression
```
public void setExpression(ExpressionDefinition expression)
```
  - checkNoCompletedPredicate
```
protected void checkNoCompletedPredicate()
```
  - getOutputs
```
public List<ProcessorDefinition<?>> getOutputs()
```
    Specified by:
    
    getOutputs in class ProcessorDefinition<AggregateDefinition>
  - isOutputSupported
```
public boolean isOutputSupported()
```
    Specified by:
    
    isOutputSupported in class ProcessorDefinition<AggregateDefinition>
  - setOutputs
```
public void setOutputs(List<ProcessorDefinition<?>> outputs)
```

Class AggregateDefinition

Field Summary

Fields inherited from class org.apache.camel.model.ProcessorDefinition

Constructor Summary

Method Summary

Methods inherited from class org.apache.camel.model.ProcessorDefinition

Methods inherited from class org.apache.camel.model.OptionalIdentifiedDefinition

Methods inherited from class java.lang.Object

Constructor Detail

AggregateDefinition

AggregateDefinition

AggregateDefinition

AggregateDefinition

AggregateDefinition

Method Detail

toString

description

getLabel

createProcessor

createAggregator

configureChild

getAggregationStrategy

setAggregationStrategy

getAggregationStrategyRef

setAggregationStrategyRef

getStrategyRef

setStrategyRef

getAggregationStrategyMethodName

setAggregationStrategyMethodName

getStrategyMethodAllowNull

getStrategyMethodName

setStrategyMethodName

setStrategyMethodAllowNull

setCorrelationExpression

getCorrelationExpression

getCompletionSize

setCompletionSize

getOptimisticLockRetryPolicyDefinition

setOptimisticLockRetryPolicyDefinition

getOptimisticLockRetryPolicy

setOptimisticLockRetryPolicy

getCompletionInterval

setCompletionInterval

getCompletionTimeout

setCompletionTimeout

getCompletionPredicate

setCompletionPredicate

getCompletionTimeoutExpression

setCompletionTimeoutExpression

getCompletionSizeExpression

setCompletionSizeExpression

getGroupExchanges

setGroupExchanges

getCompletionFromBatchConsumer

setCompletionFromBatchConsumer

getExecutorService

setExecutorService

getOptimisticLocking

setOptimisticLocking

getParallelProcessing

setParallelProcessing

getExecutorServiceRef

setExecutorServiceRef

getEagerCheckCompletion

setEagerCheckCompletion

getIgnoreInvalidCorrelationKeys

setIgnoreInvalidCorrelationKeys

getCloseCorrelationKeyOnCompletion

setCloseCorrelationKeyOnCompletion

getAggregationRepository

setAggregationRepository

getAggregationRepositoryRef

setAggregationRepositoryRef

getDiscardOnCompletionTimeout

setDiscardOnCompletionTimeout

setTimeoutCheckerExecutorService

getTimeoutCheckerExecutorService

setTimeoutCheckerExecutorServiceRef

getTimeoutCheckerExecutorServiceRef

getForceCompletionOnStop