| Package | Description |
|---|---|
| org.apache.camel |
The core Camel API.
|
| org.apache.camel.api.management |
Service provider interfaces for management.
|
| org.apache.camel.api.management.mbean |
Camel management MBeans API
|
| org.apache.camel.builder | |
| org.apache.camel.builder.xml | |
| org.apache.camel.cloud |
Camel cloud
|
| org.apache.camel.cluster |
Camel Cluster support
|
| org.apache.camel.component |
Base classes for Components
|
| 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.beanclass |
The Class Component for invoking Java classes from Camel
|
| org.apache.camel.component.binding |
The Binding Component which is
a way of wrapping an Endpoint in a contract; such as a Data Format, a Content Enricher or validation step.
|
| org.apache.camel.component.browse |
The Browse Component which is a simple in memory
component which maintains a list of all message exchanges which can be useful for debugging, tooling or visualistion.
|
| org.apache.camel.component.controlbus |
The Control Bus Component which
allows to manage Camel at runtime.
|
| org.apache.camel.component.dataformat |
The DataFormat Component
allows to use Data Format as a Camel Component.
|
| org.apache.camel.component.dataset |
A DataSet Endpoint for testing of endpoints using defined DataSets
|
| 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.extension |
Component extension
|
| org.apache.camel.component.extension.metadata |
MetaData component extension
|
| org.apache.camel.component.extension.verifier |
Verifier component extension
|
| org.apache.camel.component.file |
The File Component for working with file systems.
|
| org.apache.camel.component.file.cluster | |
| org.apache.camel.component.file.strategy |
Strategies for the File Component.
|
| org.apache.camel.component.language |
The Language Component to send messages to language endpoints executing
the script.
|
| org.apache.camel.component.log |
The Log Component uses Jakarta Commons Logging to log message exchanges.
|
| org.apache.camel.component.mock |
The Mock Component which is used for testing of routing and mediation rules.
|
| org.apache.camel.component.properties |
The Properties Component for lookup of property
placeholders for endpoint URI.
|
| org.apache.camel.component.ref |
The Ref Component for lookup of existing
endpoints bound in the
Registry. |
| 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.scheduler |
The Scheduler Component to schedule routes
|
| org.apache.camel.component.seda | |
| org.apache.camel.component.stub |
The Stub Component which is used for stubbing endpoints.
|
| org.apache.camel.component.test |
A Test Endpoint for Pattern Based Testing
|
| org.apache.camel.component.timer |
The Timer Component provides a
simple timer
|
| org.apache.camel.component.validator |
The Validator Component for validating XML against some schema
|
| org.apache.camel.component.vm |
The VM Component for asynchronous
SEDA exchanges on a
BlockingQueue
within the current JVM; so across CamelContext instances.
|
| org.apache.camel.component.xslt |
The XSLT Component for transforming messages with XSLT
|
| org.apache.camel.converter |
A set of helper classes for converting from different types of Java object to be used by the
Type Conversion Support
|
| org.apache.camel.converter.jaxp |
A number of JAXP related helper classes for converting to and from various JAXP related classes like Document and Source to be used by a
TypeConverter
|
| org.apache.camel.converter.stream |
Package with converters for dealing with stream-based messages
|
| org.apache.camel.health |
Camel Health Check support
|
| org.apache.camel.impl |
Default implementation classes for Camel Core
|
| org.apache.camel.impl.cloud |
Base classes and implementation for Camel Cloud
|
| org.apache.camel.impl.cluster |
Base classes and implementation for Camel Cluster
|
| org.apache.camel.impl.converter |
Default implementation classes the Type Conversion Strategies
|
| org.apache.camel.impl.health |
Camel Health Check implementations.
|
| org.apache.camel.impl.osgi |
Camel OSGi Activator.
|
| org.apache.camel.impl.saga |
In-memory Saga coordinator.
|
| org.apache.camel.impl.transformer |
Transformer implementation classes.
|
| org.apache.camel.impl.validator |
Validator implementation classes.
|
| org.apache.camel.language.bean |
Camel Bean language.
|
| org.apache.camel.language.constant |
Camel Constant language.
|
| org.apache.camel.language.header |
Camel Header language.
|
| org.apache.camel.language.property |
Camel Exchange Property language.
|
| org.apache.camel.language.ref |
Camel Ref language.
|
| org.apache.camel.language.simple |
Camel Simple language.
|
| org.apache.camel.language.simple.ast |
AST for the Camel Simple language.
|
| org.apache.camel.language.simple.types |
Types for the Camel Simple language.
|
| org.apache.camel.language.tokenizer |
Camel Tokenizer language.
|
| org.apache.camel.language.xpath |
Camel XPath language support.
|
| org.apache.camel.main |
Application level classes that can be used to instantiate camel.
|
| org.apache.camel.management |
Camel management
|
| org.apache.camel.management.event |
Camel management events
|
| org.apache.camel.management.mbean |
Camel management JMX MBeans
|
| org.apache.camel.model |
The JAXB POJOs for the
XML Configuration
of the routing rules.
|
| org.apache.camel.model.cloud |
The JAXB POJOs for the remote service call DSL
|
| org.apache.camel.model.dataformat |
The JAXB POJOs for the
Data Formats used to marshal and unmarshal objects to
and from streams inside components
|
| org.apache.camel.model.language | |
| org.apache.camel.model.loadbalancer |
The JAXB POJOs for the
Load Balancer EIP pattern for the
XML Configuration.
|
| org.apache.camel.model.rest |
The JAXB POJOs for the REST DSL
|
| org.apache.camel.model.transformer |
The JAXB POJOs for the
Transformers used to transform message contents
according to declared data types inside components
|
| org.apache.camel.model.validator |
The JAXB POJOs for the
Transformers used to transform message contents
according to declared data types inside components
|
| 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.binding |
Helper classes for the Binding concept on Endpoints.
|
| org.apache.camel.processor.exceptionpolicy |
Exception policy startegies for Dead Letter Channel 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.resequencer |
Helper classes for the Resequencer pattern.
|
| org.apache.camel.processor.saga |
Saga EIP implementation.
|
| org.apache.camel.processor.validation |
Performs XML validation using JAXP for validating against XSD
|
| org.apache.camel.runtimecatalog |
Runtime Camel Catalog
|
| org.apache.camel.saga |
Camel Saga EIP
|
| org.apache.camel.spi |
Service Provider Interfaces used by the Camel runtime which are plugin strategies.
|
| org.apache.camel.support |
Base classes that help to implement the camel API and are expected to be extended by the user
|
| 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
|
| org.apache.camel.util.concurrent |
Concurrent utility classes
|
| org.apache.camel.util.jsse |
A collection of utility classes for configuring a JSSE SSLContext and other JSSE classes.
|
| org.apache.camel.util.toolbox |
Toolbox classes to create commonly used Aggregation Strategies in a fluent manner.
|
| Class and 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. |
| Attachment
Represents an attachment as part of a
Message. |
| 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 |
| 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. |
| Component |
| ComponentConfiguration
Deprecated.
|
| ComponentVerifier
Deprecated.
|
| Consumer
A consumer of message exchanges from an
Endpoint |
| ConsumerTemplate |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| EndpointConfiguration
Deprecated.
|
| EndpointConfiguration.UriFormat
Deprecated.
DataFormat operations. |
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| FluentProducerTemplate |
| InvalidPayloadException
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| LoggingLevel
Used to configure the logging levels
|
| ManagementStatisticsLevel
Level of granularity for performance statistics enabled
|
| Message |
| NamedNode
Represents a node in the
routes which is identified by an id. |
| Navigate
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. |
| NoFactoryAvailableException
Thrown if no factory resource is available for the given URI
|
| NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type
|
| 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. |
| PollingConsumer
Represents a Polling
Consumer where the caller polls for messages when it is ready.
|
| 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. |
| RoutesBuilder
A routes builder is capable of building routes using the builder and model classes.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| RuntimeConfiguration
Various runtime configuration options used by
CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the like. |
| RuntimeExchangeException
A runtime exception caused by a specific message
Exchange |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ServiceStatus
Represents the status of a
Service instance |
| ShutdownableService
A
Service which is capable of being shut down. |
| 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.
|
| StartupListener
Allows objects to be notified when
CamelContext has almost done all work when starting. |
| 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. |
| ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools.
|
| TypeConversionException
Exception when failing during type conversion.
|
| 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
|
| TypeConverterExists
What to do if attempting to add a duplicate type converter
|
| WaitForTaskToComplete
Represent the kinds of options for wait for tasks to complete.
|
| Class and Description |
|---|
| Exchange |
| Class and Description |
|---|
| Experimental
An experimental user-facing API.
|
| Class and Description |
|---|
| BinaryPredicate
A predicate which evaluates a binary expression.
|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| CamelExecutionException
Exception occurred during execution/processing of an
Exchange. |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| FluentProducerTemplate |
| LoggingLevel
Used to configure the logging levels
|
| Message |
| NoSuchEndpointException
A runtime exception thrown if a routing processor such as a
RecipientList is unable to resolve an
Endpoint from a URI. |
| 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.
|
| ProducerTemplate |
| RoutesBuilder
A routes builder is capable of building routes using the builder and model classes.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools.
|
| Class and Description |
|---|
| 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 |
| Exchange |
| 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.
|
| Message |
| 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.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| RuntimeExpressionException
Thrown if an expression evaluation fails
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| 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 |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| 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
|
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| 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.
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| NoSuchBeanException
A runtime exception if a given bean could not be found in the
Registry |
| 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. |
| 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 |
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| LoggingLevel
Used to configure the logging levels
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| RouteAware |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| RouteAware |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down.
|
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| Class and Description |
|---|
| 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. |
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Component |
| Consumer
A consumer of message exchanges 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
|
| EndpointAware |
| Exchange |
| 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.
|
| Navigate
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. |
| 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 |
| RouteAware |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Component |
| Class and Description |
|---|
| 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 |
| Component |
| ComponentAware
An interface to represent an object which wishes to be injected with
a
Component. |
| Class and Description |
|---|
| 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 |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| Component |
| ComponentAware
An interface to represent an object which wishes to be injected with
a
Component. |
| ComponentVerifier
Deprecated.
|
| Class and Description |
|---|
| BatchConsumer
A consumer of a batch of message exchanges from an
Endpoint |
| 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 |
| Component |
| ComponentConfiguration
Deprecated.
|
| Consumer
A consumer of message exchanges from an
Endpoint |
| 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
|
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| 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.
|
| 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.
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| LoggingLevel
Used to configure the logging levels
|
| Message |
| NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type
|
| 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 |
| RouteAware |
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down.
|
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| WrappedFile
Wraps a file.
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Exchange |
| 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.
|
| LoggingLevel
Used to configure the logging levels
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| 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.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| LoggingLevel
Used to configure the logging levels
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| BinaryPredicate
A predicate which evaluates a binary expression.
|
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| Handler
Marks a method on a POJO as being the preferred method to invoke when Camel looks
for methods to invoke using the
BeanEndpoint. |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| DelegateEndpoint
An interface to represent an
Endpoint which are delegated. |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| DelegateEndpoint
An interface to represent an
Endpoint which are delegated. |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| 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 |
| Component |
| ComponentAware
An interface to represent an object which wishes to be injected with
a
Component. |
| ComponentVerifier
Deprecated.
|
| Consumer
A consumer of message exchanges 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
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| Navigate
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. |
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| VerifiableComponent
Deprecated.
see
org.apache.camel.extension.ComponentExtension |
| Class and 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. |
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| PollingConsumerPollingStrategy
Strategy that allows
Consumers to influence the PollingConsumer. |
| 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 |
| RouteAware |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| Class and Description |
|---|
| 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. |
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
MultipleConsumersSupport
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
| PollingConsumer
Represents a Polling
Consumer where the caller polls for messages when it is ready.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down.
|
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| WaitForTaskToComplete
Represent the kinds of options for wait for tasks to complete.
|
| Class and Description |
|---|
| 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. |
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
MultipleConsumersSupport
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| WaitForTaskToComplete
Represent the kinds of options for wait for tasks to complete.
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Component |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| IsSingleton
Used for defining if a given class is singleton or not.
|
MultipleConsumersSupport
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
| 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 |
| RouteAware |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| 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. |
| 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. |
| Class and 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. |
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| 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 |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| AsyncEndpoint
Marks the
Endpoint as support asynchronous non-blocking routing in its consumer and producer. |
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
MultipleConsumersSupport
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| Class and Description |
|---|
| 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 |
| Component |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| Attachment
Represents an attachment as part of a
Message. |
| 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
|
| Exchange |
| 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.
|
| 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.
|
| Class and Description |
|---|
| BytesSource
A helper class which provides a JAXP
Source from a byte[] which can be read as many times as required. |
| 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
|
| Exchange |
| StringSource
A helper class which provides a JAXP
Source from a String which can be read as many times as required. |
| Class and Description |
|---|
| BytesSource
A helper class which provides a JAXP
Source from a byte[] which can be read as many times as required. |
| 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
|
| Exchange |
| StreamCache
Tagging interface to indicate that a type is capable of caching the underlying data stream.
|
| StringSource
A helper class which provides a JAXP
Source from a String which can be read as many times as required. |
| Class and Description |
|---|
| Builder |
| 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 |
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| Class and 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. |
| Attachment
Represents an attachment as part of a
Message. |
| BatchConsumer
A consumer of a batch of message exchanges from an
Endpoint |
| 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 |
| CamelExecutionException
Exception occurred during execution/processing of an
Exchange. |
| Component |
| ComponentConfiguration
Deprecated.
|
| Consumer
A consumer of message exchanges from an
Endpoint |
| ConsumerTemplate |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| EndpointConfiguration
Deprecated.
|
| EndpointConfiguration.UriFormat
Deprecated.
DataFormat operations. |
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| Experimental
An experimental user-facing API.
|
| 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.
|
| FluentProducerTemplate |
| InvalidPayloadException
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| LoggingLevel
Used to configure the logging levels
|
| Message |
| MessageHistory
Represents the history of a Camel
Message how it was routed by the Camel routing engine. |
| NamedNode
Represents a node in the
routes which is identified by an id. |
| Navigate
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. |
| NoFactoryAvailableException
Thrown if no factory resource is available for the given URI
|
| 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
Consumers to influence the PollingConsumer. |
| 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
Callback for sending a exchange message to a endpoint using a producer.
|
| ProducerTemplate |
| 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.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| 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
Deprecated.
favor not using non-singleton services
|
| ServiceStatus
Represents the status of a
Service instance |
| ShutdownableService
A
Service which is capable of being shut down. |
| 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.
|
| 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. |
| 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
|
| Class and 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. |
| 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 |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| 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.
|
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Experimental
An experimental user-facing API.
|
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| AsyncProcessor
An asynchronous processor which can process an
Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback. |
| 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 |
| 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
|
| Exchange |
| LoggingLevel
Used to configure the logging levels
|
| NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type
|
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| 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). |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| TypeConversionException
Exception when failing during type conversion.
|
| 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
|
| TypeConverterExists
What to do if attempting to add a duplicate type converter
|
| TypeConverterLoaderException
Exception when failing to load type converters.
|
| TypeConverters
A tagging interface to mark this class implements type converters using the
Converter annotations. |
| Class and Description |
|---|
| 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 |
| 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. |
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Component |
| TypeConverterLoaderException
Exception when failing to load type converters.
|
| Class and Description |
|---|
| 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 |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Message |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| 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 |
| Message |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| 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. |
| Class and Description |
|---|
| Exchange |
| 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.
|
| 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.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| RuntimeExpressionException
Thrown if an expression evaluation fails
|
| Class and Description |
|---|
| 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.
|
| 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.
|
| Class and Description |
|---|
| 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.
|
| 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.
|
| Class and Description |
|---|
| 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.
|
| 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.
|
| Class and Description |
|---|
| 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.
|
| 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.
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| 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.
|
| 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.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| StaticService
Marker for indicating the
Service is a static service (only one instance per CamelContext). |
| Class and Description |
|---|
| 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.
|
| Class and Description |
|---|
| ExpressionIllegalSyntaxException
An exception thrown if the expression contains illegal syntax.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| 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.
|
| 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.
|
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| 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.
|
| 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.
|
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| ProducerTemplate |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| 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 |
| Component |
| Consumer
A consumer of message exchanges 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
|
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| ManagementStatisticsLevel
Level of granularity for performance statistics enabled
|
| NamedNode
Represents a node in the
routes which is identified by an id. |
| Navigate
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. |
| 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 |
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| 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). |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| VetoCamelContextStartException
An exception to veto starting
CamelContext. |
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| 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 |
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| TimerListener
Listener for receiving timer events.
|
| Class and Description |
|---|
| AsyncProcessor
An asynchronous processor which can process an
Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback. |
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Channel
Channel acts as a channel between
Processors in the route graph. |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| LoggingLevel
Used to configure the logging levels
|
| NamedNode
Represents a node in the
routes which is identified by an id. |
| Navigate
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. |
| NoSuchEndpointException
A runtime exception thrown if a routing processor such as a
RecipientList is unable to resolve an
Endpoint from a URI. |
| 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.
|
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| 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
|
| 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.
|
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools.
|
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| NamedNode
Represents a node in the
routes which is identified by an id. |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Exchange |
| 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.
|
| 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.
|
| Class and Description |
|---|
| 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.
|
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| NamedNode
Represents a node in the
routes which is identified by an id. |
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Class and 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. |
| 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 |
| 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 |
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| LoggingLevel
Used to configure the logging levels
|
| Message |
| MessageHistory
Represents the history of a Camel
Message how it was routed by the Camel routing engine. |
| Navigate
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. |
| NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type
|
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| 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 |
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down.
|
| 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. |
| ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools.
|
| Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor
and where it's defined in the route model.
|
| Class and 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. |
| 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 |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Exchange |
| 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.
|
| Message |
| Navigate
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. |
| 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.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down.
|
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor
and where it's defined in the route model.
|
| Class and Description |
|---|
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Exchange |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and Description |
|---|
| Exchange |
| Class and 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. |
| 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 |
| Exchange |
| 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.
|
| Navigate
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. |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Channel
Channel acts as a channel between
Processors in the route graph. |
| 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
|
| Exchange |
| LoggingLevel
Used to configure the logging levels
|
| Navigate
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. |
| NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type
|
| 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.
|
| RouteNode
Represents a model of a node in the runtime route path.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| 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 |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| 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.
|
| Navigate
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. |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| RouteAware |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor
and where it's defined in the route model.
|
| Class and Description |
|---|
| Exchange |
| 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.
|
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Class and 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. |
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| DelegateProcessor
Interface to be used for processors that delegate to the real processor
|
| Exchange |
| Navigate
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. |
| Processor
A processor is used to implement the
Event Driven Consumer
and Message Translator
patterns and to process message exchanges.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Class and 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. |
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExchangeException
An exception caused by a specific message
Exchange |
| Exchange |
| 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.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor
and where it's defined in the route model.
|
| 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. |
| Class and Description |
|---|
| CamelContext
Interface used to represent the CamelContext used to configure routes and the
policies to use during message exchanges between endpoints.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| StaticService
Marker for indicating the
Service is a static service (only one instance per CamelContext). |
| Class and Description |
|---|
| CamelContextAware
An interface to represent an object which wishes to be injected with
a
CamelContext such as when working with Spring or Guice |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| 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.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| Class and Description |
|---|
| AsyncCallback
The callback interface for an
AsyncProcessor so that it can
notify you when an Exchange is done. |
| 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 |
| Component |
| ComponentConfiguration
Deprecated.
|
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| Experimental
An experimental user-facing API.
|
| 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.
|
| LoggingLevel
Used to configure the logging levels
|
| ManagementStatisticsLevel
Level of granularity for performance statistics enabled
|
| Message |
| MessageHistory
Represents the history of a Camel
Message how it was routed by the Camel routing engine. |
| NamedNode
Represents a node in the
routes which is identified by an id. |
| NoFactoryAvailableException
Thrown if no factory resource is available for the given URI
|
| NoSuchLanguageException
A runtime exception thrown if an attempt is made to resolve an unknown
language definition.
|
| 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 |
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| RouteNode
Represents a model of a node in the runtime route path.
|
| 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
|
| ShutdownableService
A
Service which is capable of being shut down. |
| ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down.
|
| 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. |
| ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools.
|
| 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
|
| TypeConverterExists
What to do if attempting to add a duplicate type converter
|
| TypeConverterLoaderException
Exception when failing to load type converters.
|
| TypeConverters
A tagging interface to mark this class implements type converters using the
Converter annotations. |
| 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. |
| Class and Description |
|---|
| AsyncCallback
The callback interface for an
AsyncProcessor so that it can
notify you when an Exchange is done. |
| 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 |
| Component |
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| ErrorHandlerFactory
Factory for creating
ErrorHandlers. |
| Exchange |
| 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.
|
| ExpressionIllegalSyntaxException
An exception thrown if the expression contains illegal syntax.
|
| IsSingleton
Used for defining if a given class is singleton or not.
|
| NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type
|
| Ordered
Interface to be implemented by objects that should be orderable, such as with a
Collection. |
| 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.
|
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ServiceStatus
Represents the status of a
Service instance |
| ShutdownableService
A
Service which is capable of being shut down. |
| 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). |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
| TimeoutMap
Represents a map of values which timeout after a period of inactivity.
|
| TimerListener
Listener for receiving timer events.
|
| TypeConversionException
Exception when failing during type conversion.
|
| 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
|
| VetoCamelContextStartException
An exception to veto starting
CamelContext. |
| Class and 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. |
| Attachment
Represents an attachment as part of a
Message. |
| 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 |
| CamelException
Base class for all Camel checked exceptions typically thrown by a
Processor |
| CamelExecutionException
Exception occurred during execution/processing of an
Exchange. |
| Component |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| Exchange |
| ExchangePattern
Represents the kind of message exchange pattern
|
| 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.
|
| InvalidPayloadException
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
|
| Message |
| 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 |
| 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
|
| 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.
|
| Route
A Route
defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext. |
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| TypeConversionException
Exception when failing during type conversion.
|
| 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
|
| Class and 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. |
| 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 |
| Component |
| ComponentConfiguration
Deprecated.
|
| Consumer
A consumer of message exchanges from an
Endpoint |
| Endpoint
An endpoint
implements the Message
Endpoint pattern and represents an endpoint that can send and receive
message exchanges
|
| EndpointAware |
| Exchange |
| IsSingleton
Used for defining if a given class is singleton or not.
|
| PollingConsumerPollingStrategy
Strategy that allows
Consumers to influence the PollingConsumer. |
| 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 |
| RouteAware |
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| 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. |
| Class and Description |
|---|
| Rejectable
Reject executing or processing some task.
|
| Class and Description |
|---|
| 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 |
| RuntimeCamelException
Base class for all Camel unchecked exceptions.
|
| Class and Description |
|---|
| 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 |
| Exchange |
| 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.
|
| 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.
|
| Service
Represents the core lifecycle API for POJOs which can be started and stopped
|
| ShutdownableService
A
Service which is capable of being shut down. |
| StatefulService
A
Service which has all the lifecycle events and offers details about its current state. |
| SuspendableService
A
Service which is also capable of suspending and resuming. |
Apache Camel