See: Description
Interface | Description |
---|---|
AggregationRepository |
Access to a repository to store aggregated exchanges to support pluggable implementations.
|
AsyncProcessorAwaitManager |
A manager to handle async routing engine, when
Exchange s are being handed over from one thread to another, while
the callee thread is blocked waiting for the other threads to complete, before it can continue. |
AsyncProcessorAwaitManager.AwaitThread |
Information about the thread and exchange that are inflight.
|
AsyncProcessorAwaitManager.Statistics |
Utilization statistics of the this manager.
|
AuthorizationPolicy |
A marker for defining the policy to be used for applying authorization to routes.
|
Binding | Deprecated |
Breakpoint |
Breakpoint are used by the Debugger API. |
BrowsableEndpoint |
An optional interface an
Endpoint may choose to implement which allows it to
expose a way of browsing the exchanges available. |
CamelContextNameStrategy |
Strategy for assigning name to a
CamelContext . |
CamelContextTracker.Filter | |
ClassResolver |
A class resolver for loading classes in a loosly coupled manner to cater for different platforms such
as standalone, web container, j2ee container and OSGi platforms.
|
ComponentCustomizer<T extends Component> | |
ComponentResolver |
Represents a resolver of components from a URI to be able to auto-load them using some
discovery mechanism like
DefaultComponentResolver |
Condition |
A condition to define when a given
Exchange matches when is being routed. |
Container | Deprecated |
DataFormat |
Represents a
data format
used to marshal objects to and from streams
such as Java Serialization or using JAXB2 to encode/decode objects using XML
or using SOAP encoding.
|
DataFormatCustomizer<T extends DataFormat> | |
DataFormatFactory |
A factory to create
DataFormat . |
DataFormatName |
The name of the
DataFormat which allows to know which kind of data format the implementation is. |
DataFormatResolver |
Represents a resolver of data formats.
|
DataTypeAware | |
Debugger |
A debugger which allows tooling to attach breakpoints which is is being invoked
when
Exchange s is being routed. |
EndpointCompleter | Deprecated |
EndpointRegistry<K> |
Registry to cache endpoints in memory.
|
EndpointStrategy |
Endpoint strategy with callback invoked when an
Endpoint is about to be registered to the
endpoint registry in CamelContext . |
EndpointUtilizationStatistics |
Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.
|
EventFactory |
Factory to create
events that are emitted when such an event occur. |
EventNotifier |
Notifier to send
events . |
ExceptionHandler |
A Strategy pattern for handling exceptions; particularly in asynchronous processes such as consumers.
|
ExchangeFormatter |
A plugin used to turn an
Exchange into a String representation
usually to be used for logging or tracing purposes. |
ExchangeIdempotentRepository<E> |
Access to a repository of Message IDs to implement the
Idempotent Consumer pattern.
|
ExecutorServiceManager |
Strategy to create thread pools.
|
ExecutorServiceStrategy | Deprecated
use
ExecutorServiceManager instead, will be removed in a future Camel release |
FactoryFinder |
Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.
|
FactoryFinderResolver |
Represents a resolver for
FactoryFinder |
GroupAware |
To allow objects to be injected with an group.
|
HasBinding | Deprecated |
HasCamelContext |
A simple marker interface for an object which holds a CamelContext
|
HasGroup |
A simple marker interface for an object which has belongs to a group Group
which is useful for group related operation such as clustering, JMX style API
|
HasId |
A simple marker interface for an object which has a unique ID which is useful for referring to objects
in REST or JMX style APIs
|
HeaderFilterStrategy |
Interface to allow plug-able implementation to filter header to and from Camel message.
|
HeaderFilterStrategyAware |
An interface to represent an object which can make use of
injected
HeaderFilterStrategy . |
HeadersMapFactory | |
IdAware |
To allow objects to be injected with an id, such as EIP
Processor s which has been defined from Camel routes. |
IdempotentRepository<E> |
Access to a repository of Message IDs to implement the
Idempotent Consumer pattern.
|
InflightRepository |
A repository which tracks in flight
Exchange s. |
InflightRepository.InflightExchange |
Information about the inflight exchange.
|
Injector |
A pluggable strategy for creating and possibly dependency injecting objects
which could be implemented using straight forward reflection or using Spring
or Guice to perform dependency injection.
|
InterceptStrategy |
The purpose of this interface is to allow an implementation to wrap
processors in a route with interceptors.
|
Language |
Represents a language to be used for
Expression or Predicate instances |
LanguageCustomizer<T extends Language> | |
LanguageResolver |
A pluggable strategy for resolving different languages in a loosely coupled manner
|
LifecycleStrategy |
Strategy for lifecycle notifications.
|
LogListener |
An event listener SPI for logging.
|
ManagementAgent |
Camel JMX service agent
|
ManagementAware<T> | Deprecated
will be removed in Camel 3.0.
|
ManagementMBeanAssembler |
An assembler to assemble a
RequiredModelMBean which can be used
to register the object in JMX. |
ManagementNameStrategy |
Strategy for assigning the name part of the
ObjectName
for a managed CamelContext . |
ManagementNamingStrategy |
Strategy for computing
ObjectName names for the various beans that Camel register for management. |
ManagementObjectStrategy |
Strategy for creating the managed object for the various beans Camel register for management.
|
ManagementStrategy |
Strategy for management.
|
MaskingFormatter |
A plugin used to mask a log String, for example security information
like password or passphrase.
|
MessageHistoryFactory |
A factory to create
MessageHistory instances. |
ModelJAXBContextFactory |
Factory to abstract the creation of the Model's JAXBContext.
|
NamespaceAware |
Represents an object which is aware of the namespaces in which its used such as
XPath and XQuery type expressions so that the current namespace context can be injected
|
NodeIdFactory |
Factory to generate unique ids for model nodes.
|
OptimisticLockingAggregationRepository |
A specialized
AggregationRepository which also supports
optimistic locking. |
PackageScanClassResolver |
A resolver that can find resources based on package scanning.
|
PackageScanFilter |
Filter that can be used with the
PackageScanClassResolver resolver. |
Policy |
A strategy capable of applying interceptors to a processor.
|
PollingConsumerPollStrategy |
Strategy for a
PollingConsumer when polling an Endpoint . |
ProcessorFactory |
A factory to create
Processor based on the definition . |
RecoverableAggregationRepository |
A specialized
AggregationRepository which also supports
recovery. |
Registry |
Represents a service registry which may be implemented via a Spring ApplicationContext,
via JNDI, a simple Map or the OSGi Service Registry
|
ReloadStrategy |
SPI strategy for reloading Camel routes in an existing running
CamelContext |
RestApiConsumerFactory |
Allows SPI to plugin a
RestApiConsumerFactory that creates the Camel Consumer responsible
for handling incoming HTTP GET requests from clients that request to access the REST API documentation. |
RestApiProcessorFactory |
Allows SPI to plugin a
RestApiProcessorFactory that creates the Camel Processor responsible
for servicing and generating the REST API documentation. |
RestConsumerFactory |
Allows SPI to plugin a
RestConsumerFactory that creates the Camel Consumer responsible
for handling incoming HTTP requests from clients that request to access REST services which has been created using
the rest-dsl. |
RestProducerFactory |
Allows SPI to plugin a
RestProducerFactory that creates the Camel Producer responsible
for performing HTTP requests to call a remote REST service. |
RestRegistry |
A registry of all REST services running within the
CamelContext which have been defined and created
using the Rest DSL. |
RestRegistry.RestService |
Details about the REST service
|
RouteContext |
The context used to activate new routing rules
|
RouteController | |
RouteError | |
RoutePolicy |
Policy for a
Route which allows controlling the route at runtime. |
RoutePolicyFactory |
A factory to create
RoutePolicy and assign to routes automatic. |
RouteStartupOrder |
Information about a route to be started where we want to control the order
in which they are started by
CamelContext . |
RuntimeEndpointRegistry |
A registry which listen for runtime usage of
Endpoint during routing in Camel. |
RuntimeEndpointRegistry.Statistic |
Statistics gathered about the endpoint.
|
ScheduledPollConsumerScheduler |
A pluggable scheduler for
ScheduledPollConsumer consumers. |
ServicePool<Key,Service> | Deprecated |
ShutdownAware |
Allows
Consumer to fine grained control on shutdown which mostly
have to cater for in-memory based components. |
ShutdownPrepared |
Allows a
Service to prepare for shutdown. |
ShutdownStrategy |
Pluggable shutdown strategy executed during shutdown of routes.
|
StateRepository<K,V> |
This
StateRepository holds a set of key/value pairs for defining a particular state of a component. |
StreamCachingStrategy |
Strategy for using stream caching.
|
StreamCachingStrategy.SpoolRule |
Rule for determine if stream caching should be spooled to disk or kept in-memory.
|
StreamCachingStrategy.Statistics |
Utilization statistics of stream caching.
|
SubUnitOfWork |
A sub unit of work is a way of implement sub-transactions in Camel routing.
|
SubUnitOfWorkCallback |
To allow unit of work for the
UnitOfWork while processing a number of Exchange s. |
Synchronization |
Provides a hook for custom
Processor or Component
instances to respond to completed or failed processing of an Exchange rather like Spring's
TransactionSynchronization |
SynchronizationRouteAware |
An extended
Synchronization which is route aware. |
SynchronizationVetoable |
A vetoable
Synchronization . |
ThreadPoolFactory |
Creates ExecutorService and ScheduledExecutorService objects that work with a thread pool for a given ThreadPoolProfile and ThreadFactory.
|
TracedRouteNodes | Deprecated
use
Exchange.MESSAGE_HISTORY instead. |
TransactedPolicy |
A marker for defining the policy to be used for applying transaction to routes.
|
TransformerRegistry<K> |
Registry to cache transformers in memory.
|
TypeConverterAware |
An interface for an object which is interested in being injected with the root
TypeConverter
such as for implementing a fallback type converter |
TypeConverterLoader |
A pluggable strategy to load type converters into a
TypeConverterRegistry from some kind of mechanism. |
TypeConverterRegistry |
Registry for type converters.
|
TypeConverterRegistry.Statistics |
Utilization statistics of the this registry.
|
UnitOfWork |
An object representing the unit of work processing an
Exchange
which allows the use of Synchronization hooks. |
UnitOfWorkFactory |
Factory to create
UnitOfWork . |
UuidGenerator |
Generator to generate UUID strings.
|
ValidatorRegistry<K> |
Registry to cache validators in memory.
|
Class | Description |
---|---|
CamelContextTracker |
A
CamelContext creation tracker. |
Container.Instance |
The
Instance class holds a Container singleton. |
Contract | |
DataType |
Represents the data type URN which is used for message data type contract.
|
RestConfiguration |
Configuration use by
RestConsumerFactory and RestApiConsumerFactory
for Camel components to support the Camel rest DSL. |
ThreadPoolProfile |
A profile which defines thread pool settings.
|
Transformer |
Transformer
performs message transformation according to the declared data type.
|
Validator |
Validator
performs message content validation according to the declared data type.
|
Enum | Description |
---|---|
Breakpoint.State |
State of the breakpoint as either active or suspended.
|
HeaderFilterStrategy.Direction |
The direction is either IN or OUT.
|
RestConfiguration.RestBindingMode | |
RestConfiguration.RestHostNameResolver | |
RouteError.Phase | |
StreamCachingStrategy.SpoolUsedHeapMemoryLimit |
Used for selecting if the memory limit is committed or maximum heap memory setting.
|
Exception | Description |
---|---|
OptimisticLockingAggregationRepository.OptimisticLockingException |
Exception used by an AggregationRepository to indicate that an optimistic
update error has occurred and that the operation should be retried by the caller. |
Annotation Type | Description |
---|---|
Required | Deprecated
use
Metadata |
Apache Camel