|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |
See:
Description
Interface Summary | |
---|---|
AggregationRepository | Access to a repository to store aggregated exchanges to support pluggable implementations. |
AuthorizationPolicy | A marker for defining the policy to be used for applying authorization to routes. |
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 . |
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. |
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 Exchange s is being routed. |
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 Its important to not throw any exceptions when handling exceptions as they handler is often invoked in a try .. |
ExchangeFormatter | A plugin used to turn an Exchange into a String representation
usually to be used for logging or tracing purposes. |
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 |
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 . |
IdempotentRepository<E> | Access to a repository of Message IDs to implement the Idempotent Consumer pattern. |
InflightRepository | A repository which tracks in flight Exchange s. |
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. |
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. |
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. |
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
Its strongly adviced to use an AsyncProcessor as the returned wrapped
Processor which ensures the policy works well with the asynchronous routing engine. |
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 |
RouteContext | The context used to activate new routing rules |
RoutePolicy | Policy for a Route which allows controlling the route at runtime. |
RouteStartupOrder | Information about a route to be started where we want to control the order
in which they are started by CamelContext . |
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. |
ShutdownStrategy | Pluggable shutdown strategy executed during shutdown of routes. |
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 |
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. |
UnitOfWork | An object representing the unit of work processing an Exchange
which allows the use of Synchronization hooks. |
UuidGenerator | Generator to generate UUID strings. |
Class Summary | |
---|---|
ThreadPoolProfile | A profile which defines thread pool settings. |
Enum Summary | |
---|---|
Breakpoint.State | |
HeaderFilterStrategy.Direction | The direction is either IN or OUT. |
Annotation Types Summary | |
---|---|
Required | Used to denote fields which are required to be specified for validation purposes particularly in tooling. |
Service Provider Interfaces used internally by the Camel runtime which are plugin strategies.
|
||||||||||
PREV PACKAGE NEXT PACKAGE | FRAMES NO FRAMES |