All Classes and Interfaces
Class
Description
Aggregate all exchanges into a
List
of values defined by the AbstractListAggregationStrategy.getValue(Exchange)
call.A controller which allows controlling a
AggregateProcessor
from an
external source, such as Java API or JMX.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.Various statistics of the aggregator
An
AggregationStrategy
that adapts to a POJO.Class information about the POJO method to call when using the
AggregationStrategyBeanAdapter
.An
AggregationStrategy
that adapts to a BiFunction
.Method information about the POJO method to call when using the
AggregationStrategyBeanAdapter
.Parameter information to be used for method invocation.
Transformer loader scans packages for
Transformer
classes annotated with
DataType
annotation.Generic binary data type uses Camel message body converter mechanism to convert content to byte array representation.
A processor which catches exceptions.
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.
Default
AggregationStrategy
used by the ClaimCheckProcessor
EIP.ClaimCheck EIP implementation.
The correlation key has been closed and the Exchange cannot be aggregated.
A
CamelInternalProcessorAdvice
which applies Transformer
and Validator
according to the data
type Contract.A
Transformer
implementation which leverages DataFormat
to perform transformation.Processor applies data type conversion based on given format name.
Implements a Dead Letter Channel after attempting to
redeliver the message using the
RedeliveryPolicy
A default
AggregateController
that offers Java and JMX API.The default
ClaimCheckRepository
implementation that is an in-memory storage.Default error handler
The default strategy used in Camel to resolve the
ExceptionPolicyKey
that should handle the thrown exception.Compares elements of an
Exchange
sequence by comparing long
values returned by this comparator's
expression
.Default
ProcessorFactory
that supports using 3rd party Camel components to implement the EIP
Processor
.Transformer loader loads known default
Transformer
implementations.A Delayer which delays processing the exchange until the correct
amount of time has elapsed using an expression to determine the delivery time.
A useful base class for any processor which provides some kind of throttling or delayed processing.
A disabled EIP that does not do anything
Implements a Dynamic Router pattern where the
destination(s) is computed at runtime.
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.Support class for
ErrorHandler
implementations.A
Processor
which evaluates an Expression
and stores the result as a property on the
Exchange
with the key Exchange.EVALUATE_EXPRESSION_RESULT
.Ensures a
Producer
do send EventNotifier
notifications when sending.Statistics about exception failures for load balancers that reacts on exceptions
Exception policy key is a compound key for storing: route id + exception class + when =>
exception type.
A strategy to determine which
ExceptionPolicyKey
should handle the thrown exception.Processor to set
ExchangePattern
on the Exchange
.A
SequenceElementComparator
that compares Exchange
s based on the result of an expression evaluation.This FailOverLoadBalancer will failover to use next processor when an exception occurred
An
ErrorHandler
used as a safe fallback when processing by other error handlers such as the
org.apache.camel.model.OnExceptionDefinition
.The processor which implements the Message Filter EIP
pattern.
Processor to handle do finally supporting asynchronous routing engine
Aggregate all exchanges into a single combined Exchange holding all the aggregated exchanges in a
List
of
Exchange
as the message body.Aggregate all
Message
into a single combined Exchange holding all the aggregated messages in a List
of Message
as the message body.An implementation of the Idempotent Consumer pattern.
On completion strategy for
IdempotentConsumer
.Endpoint intercept processor so we know the processor is supposed to intercept an endpoint.
Endpoint strategy used by intercept send to endpoint.
Processor
used to interceptor and detour the routing when using the
DefaultInterceptSendToEndpoint
functionality.A strategy for load balancing across a number of
Processor
instancesRepresents a consumer which on starting registers itself with a
LoadBalancer
and on closing unregisters
itself with a load balancerA default base class for a
LoadBalancer
implementation.A processor which evaluates an
Expression
and logs it.The processor which sends messages in a loop.
Saga processor implementing the MANDATORY propagation mode.
A memory based
AggregationRepository
which stores Exchange
s in memory only.An exception thrown if message is rejected by the resequencer
Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy
of the message exchange.
Saga processor implementing the NEVER propagation mode.
An exception thrown if no message ID could be found on a message which is to be used with the
Idempotent Consumer pattern.
An exception thrown if no camel offset header could be found on the message.
Saga processor implementing the NOT_SUPPORTED propagation mode.
Processor implementing onCompletion.
Class to control how failed optimistic locks are tried.
Creates a Pipeline pattern where the output of the previous step is sent as input to the next step, reusing the same
message exchanges
Helper for processing
Exchange
in a
pipeline.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.A task that EIPs and internal routing engine uses to store state when processing an
Exchange
.Factory to create
PooledExchangeTask
.Exchange pair to be executed by
MulticastProcessor
.A
Transformer
implementation which leverages Processor
to perform transformation.A
Validator
implementation which leverages Processor
to perform validation.A base class for
LoadBalancer
implementations which choose a single destination for each exchange (rather
like JMS Queues)Implements the random load balancing policy
Implements a dynamic Recipient List pattern where the list
of actual endpoints to send a message exchange to are dependent on some dynamic expression.
Implements a dynamic Recipient List pattern where the list
of actual endpoints to send a message exchange to are dependent on some dynamic expression.
Base redeliverable error handler that also supports a final dead letter queue in case all redelivery attempts fail.
The policy used to decide how many times to redeliver and the time between the redeliveries before being sent to a
Dead Letter Channel
Generated by camel build tools - do NOT edit this file!
A processor which removes the header from the IN or OUT message
A processor which removes one ore more headers from the IN or OUT message
A processor which removes one ore more properties from the exchange
A processor which removes the property from the exchange
Saga processor implementing the REQUIRED propagation mode.
Saga processor implementing the REQUIRES_NEW propagation mode.
An implementation of the Resequencer which can reorder
messages within a batch.
Resequences elements based on a given
SequenceElementComparator
.A
CamelInternalProcessorAdvice
that binds the REST DSL incoming and outgoing messages from sources of json or
xml to Java Objects.Resume EIP
Processor for marking an
Exchange
to rollback.Implements the round robin load balancing policy
Pipeline
used as starting point for Route
.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.
The iterator to be used for retrieving the next routing slip(s) to be used.
Enumerates all saga completion modes.
Processor for handling sagas.
Builder of Saga processors.
Enumerates all saga propagation modes.
A
SamplingThrottler
is a special kind of throttler.A processor which executes the script as an expression and does not change the message body.
Processor for forwarding exchanges to a dynamic endpoint destination.
Processor for forwarding exchanges to a static endpoint destination.
A sorted set of elements with additional methods for obtaining immediate successors and immediate predecessors of a
given element in the sequence.
A strategy for comparing elements of a sequence.
An interface used by the
ResequencerEngine.deliver()
and ResequencerEngine.deliverNext()
methods to
send out re-ordered elements.A processor which sets the body on the IN or OUT message with an
Expression
A processor which sets the header on the IN or OUT message with an
Expression
A processor which sets the property on the exchange with an
Expression
An
AggregationStrategy
which are used when the option shareUnitOfWork is enabled on EIPs such as
multicast, splitter or recipientList.A processor that sorts the expression using a comparator
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.
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.Stops continue processing the route and marks it as complete.
A resequencer that re-orders a (continuous) stream of
Exchange
s.Aggregate result of pick expression into a single combined Exchange holding all the aggregated bodies in a
String
as the message body.Generic String data type converts Exchange payload to String representation using the Camel message body converter
mechanism.
Saga processor implementing the SUPPORTS propagation mode.
Threads processor that leverage a thread pool for continue processing the
Exchange
s using the asynchronous
routing engine.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.
The processor which sets an
Exception
on the Exchange
A timer task that notifies handlers about scheduled timeouts.
Implemented by classes that handle timeout notifications.
A
LoadBalancer
implementations which sends to all destinations (rather like JMS Topics).A processor which sets the body on the OUT message with an
Expression
.A resume strategy that keeps all the resume strategy information in memory.
Implements try/catch/finally type processing
Data type converter receives a name and a target type in order to use traditional exchange body conversion mechanisms
in order to transform the message body to a given type.
Ensures a
Producer
is executed within an UnitOfWork
.An
AggregationStrategy
which just uses the latest exchange which is useful for status messages where old
status messages have no real value.An
AggregationStrategy
which just uses the original exchange which can be needed when you want to preserve
the original Exchange.Processor for wire tapping exchanges to an endpoint destination.
A processor which ensures wrapping processors is having lifecycle handled.