All Classes

Class	Description
AbstractListAggregationStrategy<V>	Aggregate all exchanges into a List of values defined by the AbstractListAggregationStrategy.getValue(Exchange) call.
AggregateController	A controller which allows controlling a AggregateProcessor from an external source, such as Java API or JMX.
AggregateProcessor	An implementation of the Aggregator pattern where a batch of messages are processed (up to a maximum amount or until some timeout is reached) and messages for the same correlation key are combined together using some kind of AggregationStrategy (by default the latest message is used) to compress many message exchanges into a smaller number of exchanges.
AggregateProcessorStatistics	Various statistics of the aggregator
AggregationStrategyBeanAdapter	An AggregationStrategy that adapts to a POJO.
AggregationStrategyBeanInfo	Class information about the POJO method to call when using the AggregationStrategyBeanAdapter.
AggregationStrategyMethodInfo	Method information about the POJO method to call when using the AggregationStrategyBeanAdapter.
AggregationStrategyParameterInfo	Parameter information to be used for method invocation.
CatchProcessor	A processor which catches exceptions.
ChoiceProcessor	Implements a Choice structure where one or more predicates are used which if they are true their processors are used, with a default otherwise clause used if none match.
ClaimCheckAggregationStrategy	Default AggregationStrategy used by the ClaimCheckProcessor EIP.
ClaimCheckProcessor	ClaimCheck EIP implementation.
ClosedCorrelationKeyException	The correlation key has been closed and the Exchange cannot be aggregated.
ContractAdvice	A CamelInternalProcessorAdvice which applies Transformer and Validator according to the data type Contract.
DataFormatTransformer	A Transformer implementation which leverages DataFormat to perform transformation.
DeadLetterChannel	Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy
DefaultAggregateController	A default AggregateController that offers Java and JMX API.
DefaultAnnotationBasedProcessorFactory
DefaultClaimCheckRepository	The default ClaimCheckRepository implementation that is an in-memory storage.
DefaultDeferServiceFactory
DefaultErrorHandler	Default error handler
DefaultExceptionPolicyStrategy	The default strategy used in Camel to resolve the ExceptionPolicyKey that should handle the thrown exception.
DefaultExchangeComparator	Compares elements of an Exchange sequence by comparing long values returned by this comparator's expression.
DefaultInternalProcessorFactory
DefaultProcessorFactory	Default ProcessorFactory that supports using 3rd party Camel components to implement the EIP Processor.
Delayer	A Delayer which delays processing the exchange until the correct amount of time has elapsed using an expression to determine the delivery time.
DelayProcessorSupport	A useful base class for any processor which provides some kind of throttling or delayed processing.
DistributionRatio
DynamicRouter	Implements a Dynamic Router pattern where the destination(s) is computed at runtime.
Enricher	A content enricher that enriches input data by first obtaining additional data from a resource represented by an endpoint producer and second by aggregating input data and additional data.
ErrorHandlerSupport	Support class for ErrorHandler implementations.
EvaluateExpressionProcessor	A Processor which evaluates an Expression and stores the result as a property on the Exchange with the key Exchange.EVALUATE_EXPRESSION_RESULT.
EventNotifierProducer	Ensures a Producer do send EventNotifier notifications when sending.
ExceptionFailureStatistics	Statistics about exception failures for load balancers that reacts on exceptions
ExceptionPolicy
ExceptionPolicy.RedeliveryOption
ExceptionPolicyKey	Exception policy key is a compound key for storing: route id + exception class + when => exception type.
ExceptionPolicyStrategy	A strategy to determine which ExceptionPolicyKey should handle the thrown exception.
ExchangePatternProcessor	Processor to set ExchangePattern on the Exchange.
ExpressionResultComparator	A SequenceElementComparator that compares Exchanges based on the result of an expression evaluation.
FailOverLoadBalancer	This FailOverLoadBalancer will failover to use next processor when an exception occurred
FatalFallbackErrorHandler	An ErrorHandler used as a safe fallback when processing by other error handlers such as the org.apache.camel.model.OnExceptionDefinition.
FilterProcessor	The processor which implements the Message Filter EIP pattern.
FinallyProcessor	Processor to handle do finally supporting asynchronous routing engine
GroupedBodyAggregationStrategy	Aggregate body of input Message into a single combined Exchange holding all the aggregated bodies in a List of type Object as the message body.
GroupedExchangeAggregationStrategy	Aggregate all exchanges into a single combined Exchange holding all the aggregated exchanges in a List of Exchange as the message body.
GroupedMessageAggregationStrategy	Aggregate all Message into a single combined Exchange holding all the aggregated messages in a List of Message as the message body.
IdempotentConsumer	An implementation of the Idempotent Consumer pattern.
IdempotentOnCompletion	On completion strategy for IdempotentConsumer.
InterceptEndpointProcessor	Endpoint intercept processor so we know the processor is supposed to intercept an endpoint.
InterceptSendToEndpointCallback	Endpoint strategy used by intercept send to endpoint.
InterceptSendToEndpointProcessor	Processor used to interceptor and detour the routing when using the DefaultInterceptSendToEndpoint functionality.
LoadBalancer	A strategy for load balancing across a number of Processor instances
LoadBalancerConsumer	Represents a consumer which on starting registers itself with a LoadBalancer and on closing unregisters itself with a load balancer
LoadBalancerSupport	A default base class for a LoadBalancer implementation.
LogProcessor	A processor which evaluates an Expression and logs it.
LoopProcessor	The processor which sends messages in a loop.
MandatorySagaProcessor	Saga processor implementing the MANDATORY propagation mode.
MemoryAggregationRepository	A memory based AggregationRepository which stores Exchanges in memory only.
MessageRejectedException	An exception thrown if message is rejected by the resequencer
MulticastProcessor	Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange.
NeverSagaProcessor	Saga processor implementing the NEVER propagation mode.
NoErrorHandler
NoMessageIdException	An exception thrown if no message ID could be found on a message which is to be used with the Idempotent Consumer pattern.
NotSupportedSagaProcessor	Saga processor implementing the NOT_SUPPORTED propagation mode.
OnCompletionProcessor	Processor implementing onCompletion.
OptimisticLockRetryPolicy	Class to control how failed optimistic locks are tried.
Pipeline	Creates a Pipeline pattern where the output of the previous step is sent as input to the next step, reusing the same message exchanges
PipelineHelper	Helper for processing Exchange in a pipeline.
PollEnricher	A content enricher that enriches input data by first obtaining additional data from a resource represented by an endpoint producer and second by aggregating input data and additional data.
PooledExchangeTask	A task that EIPs and internal routing engine uses to store state when processing an Exchange.
PooledExchangeTaskFactory	Factory to create PooledExchangeTask.
PooledTaskFactory
ProcessorExchangePair	Exchange pair to be executed by MulticastProcessor.
ProcessorTransformer	A Transformer implementation which leverages Processor to perform transformation.
ProcessorValidator	A Validator implementation which leverages Processor to perform validation.
PrototypeTaskFactory
QueueLoadBalancer	A base class for LoadBalancer implementations which choose a single destination for each exchange (rather like JMS Queues)
RandomLoadBalancer	Implements the random load balancing policy
RecipientList	Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression.
RecipientListProcessor	Implements a dynamic Recipient List pattern where the list of actual endpoints to send a message exchange to are dependent on some dynamic expression.
RedeliveryErrorHandler	Base redeliverable error handler that also supports a final dead letter queue in case all redelivery attempts fail.
RedeliveryPolicy	The policy used to decide how many times to redeliver and the time between the redeliveries before being sent to a Dead Letter Channel
RemoveHeaderProcessor	A processor which removes the header from the IN or OUT message
RemoveHeadersProcessor	A processor which removes one ore more headers from the IN or OUT message
RemovePropertiesProcessor	A processor which removes one ore more properties from the exchange
RemovePropertyProcessor	A processor which removes the property from the exchange
RequiredSagaProcessor	Saga processor implementing the REQUIRED propagation mode.
RequiresNewSagaProcessor	Saga processor implementing the REQUIRES_NEW propagation mode.
Resequencer	An implementation of the Resequencer which can reorder messages within a batch.
ResequencerEngine<E>	Resequences elements based on a given SequenceElementComparator.
RestBindingAdvice	A CamelInternalProcessorAdvice that binds the REST DSL incoming and outgoing messages from sources of json or xml to Java Objects.
RollbackProcessor	Processor for marking an Exchange to rollback.
RoundRobinLoadBalancer	Implements the round robin load balancing policy
RoutePipeline	Pipeline used as starting point for Route.
RoutingSlip	Implements a Routing Slip pattern where the list of actual endpoints to send a message exchange to are dependent on the value of a message header.
RoutingSlip.RoutingSlipIterator	The iterator to be used for retrieving the next routing slip(s) to be used.
SagaCompletionMode	Enumerates all saga completion modes.
SagaProcessor	Processor for handling sagas.
SagaProcessorBuilder	Builder of Saga processors.
SagaPropagation	Enumerates all saga propagation modes.
SamplingThrottler	A SamplingThrottler is a special kind of throttler.
ScriptProcessor	A processor which executes the script as an expression and does not change the message body.
SendDynamicAwareResolver
SendDynamicProcessor	Processor for forwarding exchanges to a dynamic endpoint destination.
SendProcessor	Processor for forwarding exchanges to a static endpoint destination.
Sequence<E>	A sorted set of elements with additional methods for obtaining immediate successors and immediate predecessors of a given element in the sequence.
SequenceElementComparator<E>	A strategy for comparing elements of a sequence.
SequenceSender<E>	An interface used by the ResequencerEngine.deliver() and ResequencerEngine.deliverNext() methods to send out re-ordered elements.
SetBodyProcessor	A processor which sets the body on the IN or OUT message with an Expression
SetHeaderProcessor	A processor which sets the header on the IN or OUT message with an Expression
SetPropertyProcessor	A processor which sets the property on the exchange with an Expression
ShareUnitOfWorkAggregationStrategy	An AggregationStrategy which are used when the option shareUnitOfWork is enabled on EIPs such as multicast, splitter or recipientList.
SortProcessor<T>	A processor that sorts the expression using a comparator
Splitter	Implements a dynamic Splitter pattern where an expression is evaluated to iterate through each of the parts of a message and then each part is then send to some endpoint.
StepProcessor
StickyLoadBalancer	Implements a sticky load balancer using an Expression to calculate a correlation key to perform the sticky load balancing; rather like jsessionid in the web or JMSXGroupID in JMS.
StopProcessor	Stops continue processing the route and marks it as complete.
StreamResequencer	A resequencer that re-orders a (continuous) stream of Exchanges.
StringAggregationStrategy	Aggregate result of pick expression into a single combined Exchange holding all the aggregated bodies in a String as the message body.
SupportsSagaProcessor	Saga processor implementing the SUPPORTS propagation mode.
ThreadsProcessor	Threads processor that leverage a thread pool for continue processing the Exchanges using the asynchronous routing engine.
Throttler	A Throttler will set a limit on the maximum number of message exchanges which can be sent to a processor within a specific time period.
ThrottlerRejectedExecutionException
ThrowExceptionProcessor	The processor which sets an Exception on the Exchange
Timeout	A timer task that notifies handlers about scheduled timeouts.
TimeoutHandler	Implemented by classes that handle timeout notifications.
TopicLoadBalancer	A LoadBalancer implementations which sends to all destinations (rather like JMS Topics).
TransformProcessor	A processor which sets the body on the OUT message with an Expression.
TryProcessor	Implements try/catch/finally type processing
UnitOfWorkProducer	Ensures a Producer is executed within an UnitOfWork.
UseLatestAggregationStrategy	An AggregationStrategy which just uses the latest exchange which is useful for status messages where old status messages have no real value.
UseOriginalAggregationStrategy	An AggregationStrategy which just uses the original exchange which can be needed when you want to preserve the original Exchange.
WeightedLoadBalancer
WeightedRandomLoadBalancer
WeightedRoundRobinLoadBalancer
WireTapProcessor	Processor for wire tapping exchanges to an endpoint destination.
WrapProcessor	A processor which ensures wrapping processors is having lifecycle handled.