Package | Description |
---|---|
org.apache.camel |
The core Camel API.
|
org.apache.camel.component.bean |
The Bean Component which will look up the
bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO
|
org.apache.camel.component.controlbus |
The Control Bus Component which
allows to manage Camel at runtime.
|
org.apache.camel.component.direct |
The Direct Component which synchronously invokes
all the consumers when a producer sends an exchange to the endpoint.
|
org.apache.camel.component.directvm |
The Direct VM Component which synchronously invokes
the consumer when a producer sends an exchange to the endpoint.
|
org.apache.camel.component.log |
The Log Component uses Jakarta Commons Logging to log message exchanges.
|
org.apache.camel.component.rest |
The REST Component for defining REST services, supporting
the Camel Rest DSL.
|
org.apache.camel.component.saga | |
org.apache.camel.component.seda | |
org.apache.camel.component.validator |
The Validator Component for validating XML against some schema
|
org.apache.camel.impl |
Default implementation classes for Camel Core
|
org.apache.camel.impl.cloud | |
org.apache.camel.impl.converter |
Default implementation classes the Type Conversion Strategies
|
org.apache.camel.management |
Camel management
|
org.apache.camel.model |
The JAXB POJOs for the
XML Configuration
of the routing rules.
|
org.apache.camel.processor |
A collection of Processor
implementations which are used to implement the
Enterprise Integration Patterns
|
org.apache.camel.processor.aggregate |
Helper classes for the Aggregator pattern.
|
org.apache.camel.processor.idempotent |
An implementation of the Idempotent Consumer
pattern.
|
org.apache.camel.processor.interceptor |
Helper classes for interceptors.
|
org.apache.camel.processor.loadbalancer |
Various load balancer processors
|
org.apache.camel.processor.saga | |
org.apache.camel.processor.validation |
Performs XML validation using JAXP for validating against XSD or
RelaxNG
|
org.apache.camel.util |
Utility classes used by the core of Camel.
|
org.apache.camel.util.component |
Base classes and utilities for API based components
|
Modifier and Type | Interface and Description |
---|---|
interface |
Channel
Channel acts as a channel between
Processor s in the route graph. |
Modifier and Type | Method and Description |
---|---|
boolean |
AsyncProducerCallback.doInAsyncProducer(Producer producer,
AsyncProcessor asyncProducer,
Exchange exchange,
ExchangePattern exchangePattern,
AsyncCallback callback)
Performs operation on the given producer to send the given exchange.
|
Modifier and Type | Class and Description |
---|---|
class |
AbstractBeanProcessor
A
Processor which converts the inbound exchange to a method
invocation on a POJO |
class |
BeanExpressionProcessor
A bean processor that is optimised for being invoked one time from an
BeanExpression . |
class |
BeanProcessor |
class |
BeanProducer
Bean
Producer |
Modifier and Type | Class and Description |
---|---|
class |
ControlBusProducer
The control bus producer.
|
Modifier and Type | Class and Description |
---|---|
class |
DirectBlockingProducer
The direct producer.
|
class |
DirectProducer
The direct producer.
|
Modifier and Type | Class and Description |
---|---|
class |
DirectVmBlockingProducer
The direct producer.
|
class |
DirectVmProcessor |
class |
DirectVmProducer
The Direct-VM producer.
|
Modifier and Type | Class and Description |
---|---|
class |
LogProducer
Log producer.
|
Modifier and Type | Class and Description |
---|---|
class |
RestProducer
Rest producer for calling remote REST services.
|
class |
RestProducerBindingProcessor
A
Processor that binds the REST producer request and reply messages
from sources of json or xml to Java Objects. |
Modifier and Type | Method and Description |
---|---|
protected AsyncProcessor |
RestProducer.createBindingProcessor() |
Constructor and Description |
---|
RestProducerBindingProcessor(AsyncProcessor processor,
CamelContext camelContext,
DataFormat jsonDataFormat,
DataFormat xmlDataFormat,
DataFormat outJsonDataFormat,
DataFormat outXmlDataFormat,
String bindingMode,
boolean skipBindingOnErrorCode,
String outType) |
Modifier and Type | Class and Description |
---|---|
class |
SagaProducer
A producer that finalizes the current saga.
|
Modifier and Type | Class and Description |
---|---|
class |
CollectionProducer
Deprecated.
will be removed in a future Camel release
|
class |
SedaProducer |
Modifier and Type | Class and Description |
---|---|
class |
ValidatorProducer |
Modifier and Type | Class and Description |
---|---|
class |
DefaultAsyncProducer
|
class |
DeferProducer
A
Producer that defers being started, until CamelContext has been started, this
ensures that the producer is able to adapt to changes that may otherwise occur during starting
CamelContext. |
class |
InterceptSendToEndpointProcessor
Processor used to interceptor and detour the routing
when using the InterceptSendToEndpoint functionality. |
class |
InterceptSendToEndpointServicePoolProcessor
InterceptSendToEndpointProcessor used for producers that are ServicePoolAware . |
class |
SubscribeMethodProcessor
A
Processor which is used for POJO @Consume where you can have multiple @Consume on the same endpoint/consumer
and via predicate's can filter and call different methods. |
Modifier and Type | Method and Description |
---|---|
AsyncProcessor |
DefaultConsumer.getAsyncProcessor()
Provides an
AsyncProcessor interface to the configured
processor on the consumer. |
protected AsyncProcessor |
ProducerCache.prepareProducer(Producer producer) |
Modifier and Type | Class and Description |
---|---|
class |
DefaultServiceCallProcessor |
Modifier and Type | Method and Description |
---|---|
static AsyncProcessor |
AsyncProcessorTypeConverter.convert(Processor value)
Deprecated.
|
Modifier and Type | Class and Description |
---|---|
class |
InstrumentationProcessor
JMX enabled processor or advice that uses the
ManagedCounter for instrumenting
processing of exchanges. |
Modifier and Type | Interface and Description |
---|---|
interface |
ModelChannel |
Modifier and Type | Class and Description |
---|---|
class |
AOPProcessor
Deprecated.
|
class |
BatchProcessor
Deprecated.
may be removed in the future when we overhaul the resequencer EIP
|
class |
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
Transformer
... |
class |
CamelLogger
Deprecated.
This class has been split up into org.apache.camel.util.CamelLogger and org.apache.camel.processor.CamelLogProcessor
|
class |
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. |
class |
CatchProcessor
A processor which catches exceptions.
|
class |
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.
|
class |
ClaimCheckProcessor
ClaimCheck EIP implementation.
|
class |
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. |
class |
DeadLetterChannel
Implements a Dead Letter
Channel after attempting to redeliver the message using the
RedeliveryPolicy |
class |
DefaultErrorHandler
Default error handler
|
class |
Delayer
A Delayer which
delays processing the exchange until the correct amount of time has elapsed
using an expression to determine the delivery time.
|
class |
DelayProcessorSupport
A useful base class for any processor which provides some kind of throttling
or delayed processing.
|
class |
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. |
class |
DelegateSyncProcessor
|
class |
DynamicRouter
Implements a Dynamic Router pattern
where the destination(s) is computed at runtime.
|
class |
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. |
class |
EvaluateExpressionProcessor
A
Processor which evaluates an Expression
and stores the result as a property on the Exchange with the key
Exchange.EVALUATE_EXPRESSION_RESULT . |
class |
ExchangePatternProcessor
Processor to set
ExchangePattern on the Exchange . |
class |
FatalFallbackErrorHandler
An
ErrorHandler used as a safe fallback when
processing by other error handlers such as the OnExceptionDefinition . |
class |
FilterProcessor
The processor which implements the
Message Filter EIP pattern.
|
class |
FinallyProcessor
Processor to handle do finally supporting asynchronous routing engine
|
class |
InterceptEndpointProcessor
Endpoint intercept processor so we know the processor is supposed to intercept an endpoint.
|
class |
InterceptorToAsyncProcessorBridge
A bridge to have regular interceptors implemented as
Processor
work with the asynchronous routing engine without causing side effects. |
class |
LoggingErrorHandler
Deprecated.
use
DeadLetterChannel using a log endpoint instead |
class |
LogProcessor
A processor which evaluates an
Expression and logs it. |
class |
LoopProcessor
The processor which sends messages in a loop.
|
class |
MarshalProcessor
Marshals the body of the incoming message using the given
data format
|
class |
MulticastProcessor
Implements the Multicast pattern to send a message exchange to a number of
endpoints, each endpoint receiving a copy of the message exchange.
|
class |
OnCompletionProcessor
Processor implementing onCompletion.
|
class |
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
|
class |
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. |
class |
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.
|
class |
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.
|
class |
RedeliveryErrorHandler
Base redeliverable error handler that also supports a final dead letter queue in case
all redelivery attempts fail.
|
class |
RemoveHeaderProcessor
A processor which removes the header from the IN or OUT message
|
class |
RemoveHeadersProcessor
A processor which removes one ore more headers from the IN or OUT message
|
class |
RemovePropertiesProcessor
A processor which removes one ore more properties from the exchange
|
class |
RemovePropertyProcessor
A processor which removes the property from the exchange
|
class |
Resequencer
An implementation of the Resequencer
which can reorder messages within a batch.
|
class |
RollbackProcessor
Processor for marking an
Exchange to rollback. |
class |
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.
|
class |
SamplingThrottler
A
SamplingThrottler is a special kind of throttler. |
class |
ScriptProcessor
A processor which executes the script as an expression and does not change the message body.
|
class |
SendDynamicProcessor
Processor for forwarding exchanges to a dynamic endpoint destination.
|
class |
SendProcessor
Processor for forwarding exchanges to a static endpoint destination.
|
class |
SetBodyProcessor
A processor which sets the body on the IN or OUT message with an
Expression |
class |
SetHeaderProcessor
A processor which sets the header on the IN or OUT message with an
Expression |
class |
SetPropertyProcessor
A processor which sets the property on the exchange with an
Expression |
class |
SortProcessor<T>
A processor that sorts the expression using a comparator
|
class |
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.
|
class |
StopProcessor
Stops continue processing the route and marks it as complete.
|
class |
StreamResequencer
A resequencer that re-orders a (continuous) stream of
Exchange s. |
class |
ThreadsProcessor
Threads processor that leverage a thread pool for continue processing the
Exchange s
using the asynchronous routing engine. |
class |
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.
|
class |
ThroughputLogger
A logger for logging message throughput.
|
class |
ThrowExceptionProcessor
|
class |
TransformProcessor
A processor which sets the body on the OUT message with an
Expression . |
class |
TryProcessor
Implements try/catch/finally type processing
|
class |
UnmarshalProcessor
Unmarshals the body of the incoming message using the given
data format
|
class |
WireTapProcessor
Processor for wire tapping exchanges to an endpoint destination.
|
class |
WrapProcessor
A processor which ensures wrapping processors is having lifecycle handled.
|
Modifier and Type | Field and Description |
---|---|
protected AsyncProcessor |
RoutingSlip.errorHandler |
protected AsyncProcessor |
RedeliveryErrorHandler.outputAsync |
protected AsyncProcessor |
DelegateAsyncProcessor.processor |
protected AsyncProcessor |
SendProcessor.producer |
Modifier and Type | Method and Description |
---|---|
protected AsyncProcessor |
RoutingSlip.createErrorHandler(RouteContext routeContext,
Exchange exchange,
AsyncProcessor processor,
Endpoint endpoint) |
AsyncProcessor |
RoutingSlip.getErrorHandler() |
AsyncProcessor |
DelegateAsyncProcessor.getProcessor() |
AsyncProcessor |
RoutingSlip.newRoutingSlipProcessorForErrorHandler()
Creates the embedded processor to use when wrapping this routing slip in an error handler.
|
Modifier and Type | Method and Description |
---|---|
protected boolean |
SharedCamelInternalProcessor.continueProcessing(Exchange exchange,
AsyncProcessor processor)
Strategy to determine if we should continue processing the
Exchange . |
protected AsyncProcessor |
RoutingSlip.createErrorHandler(RouteContext routeContext,
Exchange exchange,
AsyncProcessor processor,
Endpoint endpoint) |
boolean |
SharedCamelInternalProcessor.process(Exchange exchange,
AsyncCallback callback,
AsyncProcessor processor,
Processor resultProcessor)
Asynchronous API
|
protected boolean |
TryProcessor.process(Exchange exchange,
AsyncCallback callback,
Iterator<Processor> processors,
AsyncProcessor processor,
Object lastHandled) |
void |
SharedCamelInternalProcessor.process(Exchange exchange,
AsyncProcessor processor,
Processor resultProcessor)
Synchronous API
|
void |
RoutingSlip.setErrorHandler(AsyncProcessor errorHandler) |
void |
DelegateAsyncProcessor.setProcessor(AsyncProcessor processor) |
Constructor and Description |
---|
DelegateAsyncProcessor(AsyncProcessor processor) |
InterceptorToAsyncProcessorBridge(Processor interceptor,
AsyncProcessor target)
Constructs the bridge
|
Modifier and Type | Class and Description |
---|---|
class |
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. |
Modifier and Type | Class and Description |
---|---|
class |
IdempotentConsumer
An implementation of the Idempotent Consumer pattern.
|
Modifier and Type | Class and Description |
---|---|
class |
DefaultChannel
DefaultChannel is the default
Channel . |
class |
DelayInterceptor
Deprecated.
no longer in use, will be removed in next Camel release.
|
class |
HandleFaultInterceptor |
class |
StreamCachingInterceptor
Deprecated.
no longer in use, will be removed in next Camel release.
|
class |
TraceInterceptor
Deprecated.
|
Modifier and Type | Interface and Description |
---|---|
interface |
LoadBalancer
A strategy for load balancing across a number of
Processor instances |
Modifier and Type | Class and Description |
---|---|
class |
CircuitBreakerLoadBalancer
Deprecated.
|
class |
FailOverLoadBalancer
This FailOverLoadBalancer will failover to use next processor when an exception occurred
This implementation mirrors the logic from the
Pipeline in the async variation
as the failover load balancer is a specialized pipeline. |
class |
LoadBalancerSupport
A default base class for a
LoadBalancer implementation. |
class |
QueueLoadBalancer
A base class for
LoadBalancer implementations which choose a single
destination for each exchange (rather like JMS Queues) |
class |
RandomLoadBalancer
Implements the random load balancing policy
|
class |
RoundRobinLoadBalancer
Implements the round robin load balancing policy
|
class |
SimpleLoadBalancerSupport
A default base class for a
LoadBalancer implementation. |
class |
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. |
class |
TopicLoadBalancer
A
LoadBalancer implementations which sends to all destinations
(rather like JMS Topics). |
class |
WeightedLoadBalancer |
class |
WeightedRandomLoadBalancer |
class |
WeightedRoundRobinLoadBalancer |
Modifier and Type | Class and Description |
---|---|
class |
MandatorySagaProcessor
Saga processor implementing the MANDATORY propagation mode.
|
class |
NeverSagaProcessor
Saga processor implementing the NEVER propagation mode.
|
class |
NotSupportedSagaProcessor
Saga processor implementing the NOT_SUPPORTED propagation mode.
|
class |
RequiredSagaProcessor
Saga processor implementing the REQUIRED propagation mode.
|
class |
RequiresNewSagaProcessor
Saga processor implementing the REQUIRES_NEW propagation mode.
|
class |
SagaProcessor
Processor for handling sagas.
|
class |
SupportsSagaProcessor
Saga processor implementing the SUPPORTS propagation mode.
|
Modifier and Type | Class and Description |
---|---|
class |
ValidatingProcessor
A processor which validates the XML version of the inbound message body
against some schema either in XSD or RelaxNG
|
Modifier and Type | Method and Description |
---|---|
static AsyncProcessor |
AsyncProcessorConverterHelper.convert(Processor value) |
Modifier and Type | Method and Description |
---|---|
static void |
AsyncProcessorHelper.process(AsyncProcessor processor,
Exchange exchange)
Calls the async version of the processor's process method and waits
for it to complete before returning.
|
static boolean |
AsyncProcessorHelper.process(AsyncProcessor processor,
Exchange exchange,
AsyncCallback callback)
Deprecated.
should no longer be needed, instead invoke the process method on the
AsyncProcessor directly,
instead of using this method. |
Modifier and Type | Class and Description |
---|---|
class |
AbstractApiProducer<E extends Enum<E> & ApiName,T>
Base class for API based Producers
|
Apache Camel