|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
Interface Summary | |
---|---|
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 | A component is
a factory of Endpoint objects. |
Consumer | A consumer of message exchanges from an Endpoint |
ConsumerTemplate | Template (named like Spring's TransactionTemplate & JmsTemplate
et al) for working with Camel and consuming Message instances in an
Exchange from an Endpoint . |
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 |
EndpointConfiguration | Holds an Endpoint configuration as a pojo that can be manipulated and validated. |
ErrorHandlerFactory | |
Exchange | An Exchange is the message container holding the information during the entire routing of
a Message received by a Consumer . |
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 | Implements the Message pattern and
represents an inbound or outbound message as part of an Exchange . |
MultipleConsumersSupport | Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
NamedNode | |
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 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 | Template (named like Spring's TransactionTemplate & JmsTemplate
et al) for working with Camel and sending Message instances in an
Exchange to an Endpoint . |
Route | A Route
defines the processing used on an inbound message exchange
from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
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 just been started. |
StatefulService | A Service which has all the lifecycle events and offers details about its current state. |
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 Summary | |
---|---|
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 Summary | |
---|---|
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 Summary | |
---|---|
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 | Deprecated. will be removed in Camel 3.0 |
InvalidPayloadRuntimeException | Runtime version of the InvalidPayloadException . |
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 Types Summary | |
---|---|
Attachments | Marks a parameter as being Map of attachments of an inbound Message |
Body | Marks a parameter as being the body of an inbound Message |
Consume | Subscribes a method to an Endpoint either via its
URI or via the name of the endpoint reference
which is then resolved in a registry such as the Spring Application Context. |
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 | Used to indicate an injection point of an Endpoint , Producer or
ProducerTemplate into a POJO. |
ExchangeException | Marks a parameter as being the exception set on 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 | Marks a field or property as being a producer to an Endpoint either via its
URI or via the name of the endpoint reference
which is then resolved in a registry such as the Spring Application Context. |
Properties | Marks a parameter as being an injection point of the properties of an Exchange |
Property | Marks a parameter as being an injection point of a property of an Exchange |
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 . |
The core Camel API.
|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |