Package org.apache.camel.processor

A collection of Processor implementations which are used to implement the Enterprise Integration Patterns

See:
Description

Interface Summary

CamelInternalProcessorAdvice<T>	An advice (before and after) to execute cross cutting functionality in the Camel routing engine.
ErrorHandler	An interface used to represent an error handler
ProcessorExchangePair	Exchange pair to be executed by MulticastProcessor.
RoutingSlip.RoutingSlipIterator	The iterator to be used for retrieving the next routing slip(s) to be used.
Traceable	Deprecated.

Class Summary

AOPProcessor
BatchProcessor	Deprecated. may be removed in the future when we overhaul the resequencer EIP
CamelInternalProcessor	Internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching ...
CamelInternalProcessor.BacklogDebuggerAdvice	Advice to execute the BacklogDebugger if enabled.
CamelInternalProcessor.BacklogTracerAdvice	Advice to execute the BacklogTracer if enabled.
CamelInternalProcessor.ChildUnitOfWorkProcessorAdvice	Advice when an EIP uses the shareUnitOfWork functionality.
CamelInternalProcessor.DelayerAdvice	Advice for delaying
CamelInternalProcessor.InstrumentationAdvice	Advice for JMX instrumentation of the process being invoked.
CamelInternalProcessor.MessageHistoryAdvice	Advice when Message History has been enabled.
CamelInternalProcessor.RouteContextAdvice	Advice to inject the current RouteContext into the UnitOfWork on the Exchange
CamelInternalProcessor.RouteInflightRepositoryAdvice	Advice to keep the InflightRepository up to date.
CamelInternalProcessor.RoutePolicyAdvice	Advice to execute any RoutePolicy a route may have been configured with.
CamelInternalProcessor.StreamCachingAdvice	Advice for StreamCachingStrategy
CamelInternalProcessor.SubUnitOfWorkProcessorAdvice	Advice when an EIP uses the shareUnitOfWork functionality.
CamelInternalProcessor.UnitOfWorkProcessorAdvice	Advice to inject new UnitOfWork to the Exchange if needed, and as well to ensure the UnitOfWork is done and stopped.
CamelLogger	Deprecated. This class has been split up into org.apache.camel.util.CamelLogger and org.apache.camel.processor.CamelLogProcessor
CamelLogProcessor	A Processor which just logs to a CamelLogger object which can be used as an exception handler instead of using a dead letter queue.
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.
ConvertBodyProcessor	A processor which converts the payload of the input message to be of the given type If the conversion fails an InvalidPayloadException is thrown.
DeadLetterChannel	Implements a Dead Letter Channel after attempting to redeliver the message using the RedeliveryPolicy
DefaultErrorHandler	Default error handler
DefaultExchangeFormatter	Default ExchangeFormatter that have fine grained options to configure what to include in the output.
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.
DelegateAsyncProcessor	A Delegate pattern which delegates processing to a nested AsyncProcessor which can be useful for implementation inheritance when writing an Policy Important: This implementation does support the asynchronous routing engine.
DelegateProcessor	A Delegate pattern which delegates processing to a nested Processor which can be useful for implementation inheritance when writing an Policy Important: This implementation does not support the asynchronous routing engine.
DelegateSyncProcessor	A Delegate pattern which delegates synchronous processing to a nested Processor which can be useful for implementation inheritance when writing an Policy Important: This implementation does support the asynchronous routing engine, only.
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.
ExchangePatternProcessor
FatalFallbackErrorHandler	An ErrorHandler used as a safe fallback when processing by other error handlers such as the OnExceptionDefinition.
FilterProcessor	The processor which implements the Message Filter EIP pattern.
FinallyProcessor	Processor to handle do finally supporting asynchronous routing engine
InterceptEndpointProcessor	Endpoint intercept processor so we know the processor is supposed to intercept an endpoint.
InterceptorToAsyncProcessorBridge	A bridge to have regular interceptors implemented as Processor work with the asynchronous routing engine without causing side effects.
LoggingErrorHandler	An ErrorHandler which uses commons-logging to dump the error
LogProcessor	A processor which evaluates an Expression and logs it.
LoopProcessor	The processor which sends messages in a loop.
MarshalProcessor	Marshals the body of the incoming message using the given data format
MulticastProcessor	Implements the Multicast pattern to send a message exchange to a number of endpoints, each endpoint receiving a copy of the message exchange.
OnCompletionProcessor
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.
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
Resequencer	An implementation of the Resequencer which can reorder messages within a batch.
RollbackProcessor	Processor for marking an Exchange to rollback.
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.
SamplingThrottler	A SamplingThrottler is a special kind of throttler.
SendProcessor	Processor for forwarding exchanges to an endpoint destination.
SetBodyProcessor	A processor which sets the body on the IN or OUT message with an Expression
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.
StopProcessor	Stops continue processing the route and marks it as complete.
StreamResequencer	A resequencer that re-orders a (continuous) stream of Exchanges.
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.
ThroughputLogger	A logger for logging message throughput.
ThrowExceptionProcessor	The processor which sets an Exception on the Exchange
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.
UnmarshalProcessor	Unmarshals the body of the incoming message using the given data format
WireTapProcessor	Processor for wire tapping exchanges to an endpoint destination.
WrapProcessor	A processor which ensures wrapping processors is having lifecycle handled.

Enum Summary

DefaultExchangeFormatter.OutputStyle

Package org.apache.camel.processor Description

A collection of Processor implementations which are used to implement the Enterprise Integration Patterns