Interface | Description |
---|---|
AfterPropertiesConfigured |
To perform optional initialization on an element after its properties has been configured.
|
AggregationStrategy |
A strategy for aggregating two exchanges together into a single exchange.
|
AsyncCallback |
The callback interface for an
AsyncProcessor so that it can
notify you when an Exchange is done. |
AsyncEndpoint |
Marks the
Endpoint as support asynchronous non-blocking routing in its consumer and producer. |
AsyncProcessor |
An asynchronous processor which can process an
Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
AsyncProducer |
Asynchronous producer
|
Attachment |
Represents an attachment as part of a
Message . |
BatchConsumer |
A consumer of a batch of message exchanges from an
Endpoint |
BinaryPredicate |
A predicate which evaluates a binary expression.
|
Builder<T> | |
CamelContext |
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
CamelContextAware |
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
CatalogCamelContext |
Catalog level interface for the
CamelContext |
Channel |
Channel acts as a channel between
Processor s in the route graph. |
Component | |
ComponentAware |
An interface to represent an object which wishes to be injected with
a
Component . |
Consumer |
A consumer of message exchanges from an
Endpoint |
ConsumerTemplate | |
DelegateEndpoint |
An interface to represent an
Endpoint which are delegated. |
DelegateProcessor |
Interface to be used for processors that delegate to the real processor
|
Endpoint |
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
EndpointAware | |
ErrorHandlerFactory |
Factory for creating
org.apache.camel.processor.ErrorHandler s. |
Exchange | |
ExecutorServiceAware |
Is used for easy configuration of
ExecutorService . |
Expression |
An expression
provides a plugin strategy for evaluating expressions on a message exchange to support things like
scripting languages,
XQuery
or SQL as well
as any arbitrary Java expression.
|
ExpressionFactory |
A factory for creating
Expression |
ExtendedCamelContext |
Extended
CamelContext which contains the methods and APIs that are not primary intended for Camel end users
but for SPI, custom components, or more advanced used-cases with Camel. |
ExtendedStartupListener |
Extended
StartupListener that is invoked when the CamelContext is fully started. |
FluentProducerTemplate | |
IsSingleton |
Used for defining if a given class is singleton or not.
|
Message | |
MessageHistory |
Represents the history of a Camel
Message how it was routed by the Camel routing engine. |
MultipleConsumersSupport |
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
NamedNode |
Represents a node in the
routes which is identified by an id. |
Navigate<T> |
Implementations support navigating a graph where you can traverse forward and each next
returns a
List of outputs of type T that can contain 0..n nodes. |
NonManagedService |
A marker to indicate the
Service should not be registered in JMX for management. |
Ordered |
Interface to be implemented by objects that should be orderable, such as with a
Collection . |
PollingConsumer |
Represents a Polling
Consumer where the caller polls for messages when it is ready.
|
PollingConsumerPollingStrategy |
Strategy that allows
Consumer s to influence the PollingConsumer . |
Predicate |
Evaluates a binary predicate on the
message exchange to support things like scripting
languages, XQuery
or SQL as well as
any arbitrary Java expression.
|
Processor |
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
Producer |
Provides a channel on which clients can create and invoke message exchanges
on an
Endpoint |
ProducerTemplate | |
Route |
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext . |
RouteAware | |
RoutesBuilder |
A routes builder is capable of building routes using the builder and model classes.
|
RuntimeConfiguration |
Various runtime configuration options used by
CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the like. |
Service |
Represents the core lifecycle API for services which can be initialized, started and stopped
|
ShutdownableService |
A
Service which is capable of being shut down. |
SSLContextParametersAware |
Indicates that an object is able to use the global
SSLContextParameters if configured. |
StartupListener |
Allows objects to be notified when
CamelContext has almost done all work when starting. |
StatefulService |
A
Service which has all the lifecycle events and offers details about its current state. |
StaticService |
Marker for indicating the
Service is a static service (only one instance per CamelContext ). |
StreamCache |
Tagging interface to indicate that a type is capable of caching the underlying data stream.
|
Suspendable |
Marker interface to indicate a custom component has custom implementation for suspending the
SuspendableService service. |
SuspendableService |
A
Service which is also capable of suspending and resuming. |
TimeoutMap<K,V> |
Represents a map of values which timeout after a period of inactivity.
|
TimeoutMap.Listener<K,V> | |
TimerListener |
Listener for receiving timer events.
|
Traceable |
Traceable processors allowing easier tracing using constructed labels to help identify the processor
and where it's defined in the route model.
|
TypeConverter |
A pluggable strategy to be able to convert objects to different
types such as to and from String, InputStream/OutputStream,
Reader/Writer, Document, byte[], ByteBuffer etc
|
TypeConverters |
A tagging interface to mark this class implements type converters using the
Converter annotations. |
WrappedFile<T> |
Wraps a file.
|
Class | Description |
---|---|
ValueHolder<V> |
Holder object for a given value.
|
Enum | Description |
---|---|
ExchangePattern |
Represents the kind of message exchange pattern
|
LoggingLevel |
Used to configure the logging levels
|
ManagementStatisticsLevel |
Level of granularity for performance statistics enabled
|
ServiceStatus |
Represents the status of a
Service instance |
ShutdownRoute |
Represents the options available when shutting down routes.
|
ShutdownRunningTask |
Represents the kind of options for what to do with the current task when shutting down.
|
TimeoutMap.Listener.Type | |
TypeConverterExists |
What to do if attempting to add a duplicate type converter
|
WaitForTaskToComplete |
Represent the kinds of options for wait for tasks to complete.
|
Exception | Description |
---|---|
AlreadyStoppedException |
Exception thrown in situations when a
Service has already been stopped. |
CamelAuthorizationException |
An exception thrown for either authentication or authorization errors occurring
in a Camel exchange.
|
CamelException |
Base class for all Camel checked exceptions typically thrown by a
Processor |
CamelExchangeException |
An exception caused by a specific message
Exchange |
CamelExecutionException |
Exception occurred during execution/processing of an
Exchange . |
CamelUnitOfWorkException |
A
UnitOfWork failed with a number of caused exceptions. |
ExchangeTimedOutException |
An exception thrown if an InOut exchange times out receiving the OUT message
|
ExpectedBodyTypeException |
Thrown if the body could not be converted to the required type
|
ExpressionEvaluationException |
An exception thrown if evaluation of the expression failed.
|
ExpressionIllegalSyntaxException |
An exception thrown if the expression contains illegal syntax.
|
FailedToCreateConsumerException |
Thrown if Camel failed to create a consumer for a given endpoint.
|
FailedToCreateProducerException |
Thrown if Camel failed to create a producer for a given endpoint.
|
FailedToCreateRouteException |
Exception when failing to create a
Route . |
FailedToStartRouteException |
Exception when failing to start a
Route . |
InvalidPayloadException |
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
|
InvalidPayloadRuntimeException |
Runtime version of the
InvalidPayloadException . |
InvalidPropertyException |
An exception caused when an invalid property name is used on an object
|
LoadPropertiesException |
Represents a failure to open a Properties file at a given URL
|
NoFactoryAvailableException |
Thrown if no factory resource is available for the given URI
|
NoSuchBeanException |
A runtime exception if a given bean could not be found in the
Registry |
NoSuchEndpointException |
A runtime exception thrown if a routing processor such as a
recipient list is unable to resolve an
Endpoint from a URI. |
NoSuchHeaderException |
An exception caused when a mandatory header is not available on a message
Exchange |
NoSuchLanguageException |
A runtime exception thrown if an attempt is made to resolve an unknown
language definition.
|
NoSuchPropertyException |
An exception caused when a mandatory property is not available on a message
Exchange |
NoTypeConversionAvailableException |
An exception thrown if a value could not be converted to the required type
|
PropertyBindingException |
Error binding property to a bean.
|
ProxyInstantiationException |
Exception indicating a failure while trying to create a proxy of a given type and on a given endpoint
|
ResolveEndpointFailedException |
A runtime exception thrown if an
Endpoint cannot be resolved via URI |
RollbackExchangeException |
Exception used for forcing an Exchange to be rolled back.
|
RuntimeCamelException |
Base class for all Camel unchecked exceptions.
|
RuntimeExchangeException |
A runtime exception caused by a specific message
Exchange |
RuntimeExpressionException |
Thrown if an expression evaluation fails
|
RuntimeTransformException |
Thrown if a message transformation fails
|
TypeConversionException |
Exception when failing during type conversion.
|
TypeConverterExistsException |
Exception when failing to add type converters due there is already an existing type converter.
|
TypeConverterLoaderException |
Exception when failing to load type converters.
|
ValidationException |
The base class for any validation exception, such as
org.apache.camel.processor.validation.SchemaValidationException so
that it is easy to treat all validation errors in a similar way irrespective
of the particular validation technology used. |
VetoCamelContextStartException |
An exception to veto starting
CamelContext . |
Annotation Type | Description |
---|---|
AttachmentObjects |
Marks a parameter as being Map of attachments as
Attachment objects
of an inbound Message |
Attachments |
Marks a parameter as being Map of attachments as
DataHandler objects of an inbound Message |
BeanInject |
Used to indicate an injection point of a bean obtained from the
Registry , into a POJO. |
BindToRegistry |
Used for binding a bean to the registry
If no name is specified then the bean will have its name auto computed based on the
class name, field name, or method name where the annotation is configured.
|
Body |
Marks a parameter as being the body of an inbound
Message |
Consume | |
Converter |
An annotation used to mark classes and methods to indicate code capable of
converting from a type to another type which are then auto-discovered using
the Type
Conversion Support
|
DeferredContextBinding |
Used to indicate that if the target type is
CamelContextAware , the
context does not need to be mandatory injected during bean post processing but
can be injected later on as example during Camel Context configuration. |
DynamicRouter |
Indicates that this method is to be used as a
Dynamic Router routing the incoming message
through a series of processing steps.
|
EndpointInject | |
ExchangeException |
Marks a parameter as being the exception set on an exchange
|
ExchangeProperties |
Marks a parameter as being an injection point of the exchange properties of an
Exchange |
ExchangeProperty |
Marks a parameter as being an injection point of a property of an
Exchange |
FallbackConverter | Deprecated
use @Converter(fallback = true) instead
|
Handler |
Marks a method on a POJO as being the preferred method to invoke when Camel looks
for methods to invoke using the
BeanEndpoint . |
Header |
Marks a parameter as being a header on an inbound
Message |
Headers |
Marks a parameter as being an injection point of the headers of an inbound
Message |
InOnly |
Marks methods as being
ExchangePattern.InOnly
for one way asynchronous invocation when using
Bean Integration or
Spring Remoting
to overload the default value which is ExchangePattern.InOut for request/reply if no annotations are used. |
InOut |
Marks a method as being
ExchangePattern.InOut when a class or interface has been annotated with
InOnly when using
Bean Integration or
Spring Remoting. |
InvokeOnHeader |
Marks a method as being invoked for a specific header value.
|
InvokeOnHeaders |
Marks a method as being invoked for a specific header value.
|
OutHeaders |
Marks a parameter as being an injection point of the headers of an outbound
Message |
Pattern |
Marks a method as having a specific kind of
ExchangePattern for use with
Bean Integration or
Spring Remoting
to overload the default value which is ExchangePattern.InOut for request/reply if no annotations are used. |
Produce | |
PropertyInject |
Used to indicate an injection point of a
property placeholder into a POJO.
|
RecipientList |
Indicates that this method is to be used as a
Dynamic Recipient List routing the incoming message
to one or more endpoints.
|
RoutingSlip |
Indicates that this method is to be used as a
Routing Slip routing the incoming message
through a series of processing steps.
|
Apache Camel