Package org.apache.camel.model

Class AggregateDefinition

    • Constructor Detail

      • AggregateDefinition

        public AggregateDefinition()

      • AggregateDefinition

        public AggregateDefinition​(@AsPredicate
                           org.apache.camel.Predicate predicate)

      • AggregateDefinition

        public AggregateDefinition​(org.apache.camel.Expression expression)

      • AggregateDefinition

        public AggregateDefinition​(org.apache.camel.Expression correlationExpression,
                           org.apache.camel.AggregationStrategy aggregationStrategy)

    • Method Detail

      • description

        protected String description()

      • getAggregationRepositoryBean

        public org.apache.camel.spi.AggregationRepository getAggregationRepositoryBean()

      • getAggregateControllerBean

        public org.apache.camel.processor.aggregate.AggregateController getAggregateControllerBean()

      • getAggregationRepository

        public String getAggregationRepository()

      • setAggregationRepository

        public void setAggregationRepository​(org.apache.camel.spi.AggregationRepository aggregationRepository)

      • setAggregationRepository

        public void setAggregationRepository​(String aggregationRepository)
        The AggregationRepository to use.

        Sets the custom aggregate repository to use. Will by default use org.apache.camel.processor.aggregate.MemoryAggregationRepository

      • setAggregationStrategy

        public void setAggregationStrategy​(org.apache.camel.AggregationStrategy aggregationStrategy)
        The AggregationStrategy to use.

        For example to lookup a bean with the name foo, the value is simply just #bean:foo.

        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.

      • getAggregationStrategy

        public String getAggregationStrategy()

      • setAggregationStrategy

        public void setAggregationStrategy​(String aggregationStrategy)
        The AggregationStrategy to use.

        For example to lookup a bean with the name foo, the value is simply just #bean:foo.

        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.

      • setAggregationStrategyMethodName

        public void setAggregationStrategyMethodName​(String strategyMethodName)
        This option can be used to explicit declare the method name to use, when using beans as the AggregationStrategy.

      • setAggregationStrategyMethodAllowNull

        public void setAggregationStrategyMethodAllowNull​(String aggregationStrategyMethodAllowNull)
        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 beans 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.

      • getCompletionSize

        public String getCompletionSize()

      • setCompletionSize

        public void setCompletionSize​(String completionSize)

      • getOptimisticLockRetryPolicy

        public org.apache.camel.processor.aggregate.OptimisticLockRetryPolicy getOptimisticLockRetryPolicy()

      • setOptimisticLockRetryPolicy

        public void setOptimisticLockRetryPolicy​(org.apache.camel.processor.aggregate.OptimisticLockRetryPolicy optimisticLockRetryPolicy)

      • getCompletionInterval

        public String getCompletionInterval()

      • setCompletionInterval

        public void setCompletionInterval​(String completionInterval)

      • getCompletionTimeout

        public String getCompletionTimeout()

      • setCompletionTimeout

        public void setCompletionTimeout​(String completionTimeout)

      • getCompletionTimeoutCheckerInterval

        public String getCompletionTimeoutCheckerInterval()

      • setCompletionTimeoutCheckerInterval

        public void setCompletionTimeoutCheckerInterval​(String completionTimeoutCheckerInterval)

      • setCompletionTimeoutExpression

        public void setCompletionTimeoutExpression​(ExpressionSubElementDefinition completionTimeoutExpression)
        Time in millis that an aggregated exchange should be inactive before its complete (timeout). 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.

        By default the timeout checker runs every second, you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. The timeout is an approximation and there is no guarantee that the a timeout is triggered exactly after the timeout value. It is not recommended to use very low timeout values or checker intervals.

        Parameters:
        completionTimeoutExpression - the timeout as an Expression which is evaluated as a Long type

      • setCompletionSizeExpression

        public void setCompletionSizeExpression​(ExpressionSubElementDefinition completionSizeExpression)
        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.
        Parameters:
        completionSizeExpression - the completion size as an Expression which is evaluated as a Integer type

      • getCompletionFromBatchConsumer

        public String getCompletionFromBatchConsumer()

      • setCompletionFromBatchConsumer

        public void setCompletionFromBatchConsumer​(String completionFromBatchConsumer)

      • getCompletionOnNewCorrelationGroup

        public String getCompletionOnNewCorrelationGroup()

      • setCompletionOnNewCorrelationGroup

        public void setCompletionOnNewCorrelationGroup​(String completionOnNewCorrelationGroup)

      • getOptimisticLocking

        public String getOptimisticLocking()

      • setOptimisticLocking

        public void setOptimisticLocking​(String optimisticLocking)

      • getParallelProcessing

        public String getParallelProcessing()

      • setParallelProcessing

        public void setParallelProcessing​(String parallelProcessing)

      • getExecutorService

        public String getExecutorService()

      • setExecutorService

        public void setExecutorService​(String executorService)

      • getEagerCheckCompletion

        public String getEagerCheckCompletion()

      • setEagerCheckCompletion

        public void setEagerCheckCompletion​(String eagerCheckCompletion)

      • getIgnoreInvalidCorrelationKeys

        public String getIgnoreInvalidCorrelationKeys()

      • setIgnoreInvalidCorrelationKeys

        public void setIgnoreInvalidCorrelationKeys​(String ignoreInvalidCorrelationKeys)

      • getCloseCorrelationKeyOnCompletion

        public String getCloseCorrelationKeyOnCompletion()

      • setCloseCorrelationKeyOnCompletion

        public void setCloseCorrelationKeyOnCompletion​(String closeCorrelationKeyOnCompletion)

      • getDiscardOnCompletionTimeout

        public String getDiscardOnCompletionTimeout()

      • setDiscardOnCompletionTimeout

        public void setDiscardOnCompletionTimeout​(String discardOnCompletionTimeout)

      • getDiscardOnAggregationFailure

        public String getDiscardOnAggregationFailure()

      • setDiscardOnAggregationFailure

        public void setDiscardOnAggregationFailure​(String discardOnAggregationFailure)

      • getTimeoutCheckerExecutorService

        public String getTimeoutCheckerExecutorService()

      • setTimeoutCheckerExecutorService

        public void setTimeoutCheckerExecutorService​(String timeoutCheckerExecutorService)

      • getForceCompletionOnStop

        public String getForceCompletionOnStop()

      • setForceCompletionOnStop

        public void setForceCompletionOnStop​(String forceCompletionOnStop)

      • getCompleteAllOnStop

        public String getCompleteAllOnStop()

      • setCompleteAllOnStop

        public void setCompleteAllOnStop​(String completeAllOnStop)

      • getAggregateController

        public String getAggregateController()

      • setAggregateController

        public void setAggregateController​(String aggregateController)
        To use a AggregateController to allow external sources to control this aggregator.

      • setAggregateController

        public void setAggregateController​(org.apache.camel.processor.aggregate.AggregateController aggregateController)

      • eagerCheckCompletion

        public AggregateDefinition eagerCheckCompletion()
        Use eager completion checking which means that the completionPredicate will use the incoming Exchange. As 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

      • discardOnAggregationFailure

        public AggregateDefinition discardOnAggregationFailure()
        Discards the aggregated message when aggregation failed (an exception was thrown from AggregationStrategy. This means the partly aggregated message is dropped and not sent out of the aggregator.

        This option cannot be used together with completionFromBatchConsumer.

        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.

        This option cannot be used together with discardOnAggregationFailure.

        Returns:
        builder

      • completionOnNewCorrelationGroup

        public AggregateDefinition completionOnNewCorrelationGroup()
        Enables completion on all previous groups when a new incoming correlation group. This can for example be used to complete groups with same correlation keys when they are in consecutive order. Notice when this is enabled then only 1 correlation group can be in progress as when a new correlation group starts, then the previous groups is forced completed.
        Returns:
        builder

      • completionSize

        public AggregateDefinition completionSize​(String 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.
        Parameters:
        completionSize - the completion size, must be a an expression evaluating to positive number
        Returns:
        builder

      • completionSize

        public AggregateDefinition completionSize​(int 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.
        Parameters:
        completionSize - the completion size, must be a positive number
        Returns:
        builder

      • completionSize

        public AggregateDefinition completionSize​(org.apache.camel.Expression 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.
        Parameters:
        completionSize - the completion size as an Expression which is evaluated as a Integer type
        Returns:
        builder

      • completionInterval

        public AggregateDefinition completionInterval​(long 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.
        Parameters:
        completionInterval - the interval in millis, must be a positive value
        Returns:
        the builder

      • completionInterval

        public AggregateDefinition completionInterval​(String 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.
        Parameters:
        completionInterval - the interval in millis, must be a positive value
        Returns:
        the builder

      • completionTimeout

        public AggregateDefinition completionTimeout​(String completionTimeout)
        Time in millis that an aggregated exchange should be inactive before its complete (timeout). 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.

        By default the timeout checker runs every second, you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. The timeout is an approximation and there is no guarantee that the a timeout is triggered exactly after the timeout value. It is not recommended to use very low timeout values or checker intervals.

        Parameters:
        completionTimeout - the timeout in millis, must be a positive value
        Returns:
        the builder

      • completionTimeout

        public AggregateDefinition completionTimeout​(long completionTimeout)
        Time in millis that an aggregated exchange should be inactive before its complete (timeout). 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.

        By default the timeout checker runs every second, you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. The timeout is an approximation and there is no guarantee that the a timeout is triggered exactly after the timeout value. It is not recommended to use very low timeout values or checker intervals.

        Parameters:
        completionTimeout - the timeout in millis, must be a positive value
        Returns:
        the builder

      • completionTimeout

        public AggregateDefinition completionTimeout​(org.apache.camel.Expression completionTimeout)
        Time in millis that an aggregated exchange should be inactive before its complete (timeout). 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.

        By default the timeout checker runs every second, you can use the completionTimeoutCheckerInterval option to configure how frequently to run the checker. The timeout is an approximation and there is no guarantee that the a timeout is triggered exactly after the timeout value. It is not recommended to use very low timeout values or checker intervals.

        Parameters:
        completionTimeout - the timeout as an Expression which is evaluated as a Long type
        Returns:
        the builder

      • completionTimeoutCheckerInterval

        public AggregateDefinition completionTimeoutCheckerInterval​(long completionTimeoutCheckerInterval)
        Interval in millis that is used by the background task that checks for timeouts (TimeoutMap).

        By default the timeout checker runs every second. The timeout is an approximation and there is no guarantee that the a timeout is triggered exactly after the timeout value. It is not recommended to use very low timeout values or checker intervals.

        Parameters:
        completionTimeoutCheckerInterval - the interval in millis, must be a positive value
        Returns:
        the builder

      • aggregationStrategyMethodName

        public AggregateDefinition aggregationStrategyMethodName​(String methodName)
        Sets the method name to use when using a bean as AggregationStrategy.
        Parameters:
        methodName - the method name to call
        Returns:
        the builder

      • aggregationStrategyMethodAllowNull

        public AggregateDefinition aggregationStrategyMethodAllowNull()
        Sets allowing null when using a bean as AggregationStrategy.
        Returns:
        the builder

      • aggregationRepository

        public AggregateDefinition aggregationRepository​(org.apache.camel.spi.AggregationRepository aggregationRepository)
        Sets the custom aggregate repository to use.

        Will by default use MemoryAggregationRepository

        Parameters:
        aggregationRepository - the aggregate repository to use
        Returns:
        the builder

      • aggregationRepository

        public AggregateDefinition aggregationRepository​(String aggregationRepository)
        Sets the custom aggregate repository to use.

        Will by default use MemoryAggregationRepository

        Parameters:
        aggregationRepository - reference to the repository to lookup in the registry
        Returns:
        the builder

      • completionPredicate

        public AggregateDefinition completionPredicate​(@AsPredicate
                                               org.apache.camel.Predicate predicate)
        A Predicate to indicate when an aggregated exchange is complete. If this is not specified and the AggregationStrategy object implements Predicate, the aggregationStrategy object will be used as the completionPredicate.

      • completionPredicate

        @AsPredicate
public PredicateClause<AggregateDefinition> completionPredicate()
        A Predicate to indicate when an aggregated exchange is complete. If this is not specified and the AggregationStrategy object implements Predicate, the aggregationStrategy object will be used as the completionPredicate.

      • completion

        @AsPredicate
public PredicateClause<AggregateDefinition> completion()
        A Predicate to indicate when an aggregated exchange is complete. If this is not specified and the AggregationStrategy object implements Predicate, the aggregationStrategy object will be used as the completionPredicate.

      • completion

        public AggregateDefinition completion​(@AsPredicate
                                      org.apache.camel.Predicate predicate)
        A Predicate to indicate when an aggregated exchange is complete. If this is not specified and the AggregationStrategy object implements Predicate, the aggregationStrategy object will be used as the completionPredicate.

      • 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​(org.apache.camel.processor.aggregate.OptimisticLockRetryPolicy policy)
        Allows to configure retry settings when using optimistic locking.

      • 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.

      • timeoutCheckerExecutorService

        public AggregateDefinition timeoutCheckerExecutorService​(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​(org.apache.camel.processor.aggregate.AggregateController aggregateController)
        To use a AggregateController to allow external sources to control this aggregator.

      • aggregateController

        public AggregateDefinition aggregateController​(String aggregateController)
        To use a AggregateController to allow external sources to control this aggregator.

      • setExpression

        public void setExpression​(org.apache.camel.Expression expression)

      • checkNoCompletedPredicate

        protected void checkNoCompletedPredicate()