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
Exchanges 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 |
Represents a Binding or contract
which can be applied to an Endpoint; such as ensuring that a particular
Data Format is used on messages in and out of an endpoint.
|
| 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.
|
| 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.
|
| DataFormatResolver |
Represents a resolver of data formats.
|
| Debugger |
A debugger which allows tooling to attach breakpoints which is is being invoked
when
Exchanges is being routed. |
| EndpointCompleter |
A helper interface used by the
ComponentConfiguration.completeEndpointPath(String) method
to allow endpoint paths to be completed. |
| 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. |
| 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 |
| HasBinding |
Allows objects such as Endpoints to expose that they have a
Binding.
|
| 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. |
| IdAware |
To allow objects to be injected with an id, such as EIP
Processors 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
Exchanges. |
| 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 |
| LanguageResolver |
A pluggable strategy for resolving different languages in a loosely coupled manner
|
| LifecycleStrategy |
Strategy for lifecycle notifications.
|
| 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.
|
| 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
|
| RestConsumerFactory | |
| 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
|
| 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. |
| ScheduledPollConsumerScheduler |
A pluggable scheduler for
ScheduledPollConsumer consumers. |
| ServicePool<Key,Service> |
A service pool is like a connection pool but can pool any kind of objects.
|
| 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.
|
| 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 Exchanges. |
| 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 |
Tracing information used by
TraceInterceptor
so we can trace the exact route path a given Exchange has been processed. |
| TransactedPolicy |
A marker for defining the policy to be used for applying transaction to routes.
|
| 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.
|
| Class | Description |
|---|---|
| CamelContextTracker |
A camel context creation tracker.
|
| Container.Instance |
The
Instance class holds a Container singleton. |
| RestConfiguration |
Configuration use by
RestConsumerFactory for Camel components to support
the Camel rest DSL. |
| ThreadPoolProfile |
A profile which defines thread pool settings.
|
| 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 | |
| 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