| Interface | Description |
|---|---|
| AsyncCallback |
The callback interface for an
AsyncProcessor so that it can
notify you when an Exchange is done. |
| AsyncProcessor |
An asynchronous processor which can process an
Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback. |
| AsyncProducerCallback |
Callback for sending a exchange message to a endpoint using an
AsyncProcessor capable producer. |
| BatchConsumer |
A consumer of a batch of message exchanges from an
Endpoint |
| BinaryPredicate |
A predicate which evaluates a binary expression.
|
| CamelContext |
Interface used to represent the context 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 |
| Channel |
Channel acts as a channel between
Processors in the route graph. |
| Component | |
| ComponentConfiguration |
Represents a set of configuration values for an endpoint URI which can be created from a URI string
or a base URI string and a set of parameter names and values.
|
| 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 | |
| EndpointConfiguration |
Holds an
Endpoint configuration as a pojo that can be manipulated and validated. |
| ErrorHandlerFactory |
Factory for creating
ErrorHandlers. |
| 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.
|
| 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. |
| 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
Consumers 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 |
| ProducerCallback<T> |
Callback for sending a exchange message to a endpoint using a producer.
|
| ProducerTemplate | |
| Rejectable |
Reject executing or processing some task.
|
| Route |
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| RouteAware | |
| RouteNode |
Represents a model of a node in the runtime route path.
|
| 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 POJOs which can be started and stopped
|
| ServicePoolAware |
Marker interface to indicate this service can be pooled using a
ServicePool. |
| ShutdownableService |
A
Service which is capable of being shut down. |
| StartupListener |
Allows objects to be notified when
CamelContext has 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.
|
| 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.
|
| 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
|
| WrappedFile<T> |
Wraps a file.
|
| Class | Description |
|---|---|
| BytesSource |
A helper class which provides a JAXP
Source from a byte[] which can be read as many times as required. |
| Main | Deprecated
use org.apache.camel.main.Main instead
|
| StringSource |
A helper class which provides a JAXP
Source from a String which can be read as many times as required. |
| Enum | Description |
|---|---|
| EndpointConfiguration.UriFormat |
DataFormat operations. |
| 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.
|
| ThreadPoolRejectedPolicy |
Represent the kinds of options for rejection handlers for thread pools.
|
| 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
|
| 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
RecipientList 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
|
| 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.
|
| TypeConverterLoaderException |
Exception when failing to load type converters.
|
| ValidationException |
The base class for any validation exception, such as
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 |
|---|---|
| Attachments |
Marks a parameter as being Map of attachments of an inbound
Message |
| BeanInject |
Used to indicate an injection point of a bean obtained from the
Registry, into a POJO. |
| 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
|
| 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
|
| ExchangeProperty |
Marks a parameter as being an injection point of a property of an
Exchange |
| FallbackConverter |
An annotation used to mark methods to indicate code capable of being a
fallback converter which are then auto-discovered using
the Type
Conversion Support.
|
| 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. |
| 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 | |
| Properties |
Marks a parameter as being an injection point of the properties of an
Exchange |
| Property | Deprecated
use
ExchangeProperty instead |
| 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.
|
| URIField |
Used to indicate the field of an
EndpointConfiguration. |
Apache Camel