Interface | Description |
---|---|
AfterPropertiesConfigured |
To perform optional initialization on an element after its properties has been configured.
|
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
Processor s 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
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.
|
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 |
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.
|
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.
|
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 |
---|---|
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.
|
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
|
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.
|
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
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