org.apache.camel.spi (Camel

Service Provider Interfaces used by the Camel runtime which are plugin strategies.

Interface Summary
Interface	Description
AggregationRepository	Access to a repository to store aggregated exchanges to support pluggable implementations.
AnnotationBasedProcessorFactory	Factory to create `Processor` for annotation based EIPs.
AnnotationScanTypeConverters	A `TypeConverter` which is capable of annotation scanning for `Converter` classes and add these as type converters.
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.
BeanIntrospection	Used for introspecting beans properties via Java reflection; such as extracting current property values, or updating one or more properties etc.
BeanProcessorFactory	Factory for creating a `Processor` that can invoke a method on a bean and supporting using Camel bean parameter bindings.
BeanProxyFactory	A factory for creating a `Proxy` for a bean.
BeanRepository	Represents a bean repository used to lookup components by name and type.
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.
CamelBeanPostProcessor	Bean post processor.
CamelContextNameStrategy	Strategy for assigning name to a `CamelContext`.
CamelContextTracker.Filter
CamelEvent	This interface is implemented by all events.
CamelEvent.CamelContextEvent
CamelEvent.CamelContextResumedEvent
CamelEvent.CamelContextResumeFailureEvent
CamelEvent.CamelContextResumingEvent
CamelEvent.CamelContextRoutesStartedEvent
CamelEvent.CamelContextRoutesStartingEvent
CamelEvent.CamelContextRoutesStoppedEvent
CamelEvent.CamelContextRoutesStoppingEvent
CamelEvent.CamelContextStartedEvent
CamelEvent.CamelContextStartingEvent
CamelEvent.CamelContextStartupFailureEvent
CamelEvent.CamelContextStopFailureEvent
CamelEvent.CamelContextStoppedEvent
CamelEvent.CamelContextStoppingEvent
CamelEvent.CamelContextSuspendedEvent
CamelEvent.CamelContextSuspendingEvent
CamelEvent.ExchangeCompletedEvent
CamelEvent.ExchangeCreatedEvent
CamelEvent.ExchangeEvent
CamelEvent.ExchangeFailedEvent
CamelEvent.ExchangeFailureEvent
CamelEvent.ExchangeFailureHandledEvent
CamelEvent.ExchangeFailureHandlingEvent
CamelEvent.ExchangeRedeliveryEvent
CamelEvent.ExchangeSendingEvent
CamelEvent.ExchangeSentEvent
CamelEvent.FailureEvent	This interface is implemented by all events that contain an exception and is used to retrieve the exception in a universal way.
CamelEvent.RouteAddedEvent
CamelEvent.RouteEvent
CamelEvent.RouteRemovedEvent
CamelEvent.RouteStartedEvent
CamelEvent.RouteStoppedEvent
CamelEvent.ServiceEvent
CamelEvent.ServiceStartupFailureEvent
CamelEvent.ServiceStopFailureEvent
CamelEvent.StepCompletedEvent
CamelEvent.StepEvent
CamelEvent.StepFailedEvent
CamelEvent.StepStartedEvent
CamelInternalProcessorAdvice<T>	An advice (before and after) to execute cross cutting functionality in the Camel routing engine.
CircuitBreakerConstants
ClaimCheckRepository	Access to a repository of keys to implement the Claim Check pattern.
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>
ComponentNameResolver	Discovers which components are available on the classpath.
ComponentResolver	Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like `org.apache.camel.impl.DefaultComponentResolver`
Condition	A condition to define when a given `Exchange` matches when is being routed.
ConfigurerResolver	A pluggable strategy for resolving different configurers in a loosely coupled manner
ConsumerCache	Cache containing created `PollingConsumer`.
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.
DataFormatContentTypeHeader	Special accessor for a DataFormat
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	Allows `Message` to store a `DataType` which represents the data type of the Message.
Debugger	A debugger which allows tooling to attach breakpoints which is is being invoked when `Exchange`s is being routed.
DeferServiceFactory	Factory to create services such as `Producer`s and defer starting the created service, until `CamelContext` has been started.
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.
ExecutorServiceManager	Strategy to create thread pools.
ExpressionResultTypeAware	Represents an `Expression` or `Predicate` that supports a result type.
FactoryFinder	Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.
FactoryFinderResolver	Represents a resolver for `FactoryFinder`
GeneratedPropertyConfigurer	A auto generated `PropertyConfigurer` for fast configuration of Camel components & endpoints.
GroupAware	To allow objects to be injected with an group.
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	Factory to create the `Map` implementation to use for storing headers on `Message`.
IdAware	To allow objects to be injected with an id, such as EIP `Processor`s which has been defined from Camel routes.
IdempotentRepository	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 CDI to perform dependency injection.
InterceptSendToEndpoint	This is an endpoint when sending to it, is intercepted and is routed in a detour, with the following flow: before, send to original endpoint (can be skipped), after (optional).
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.
LoadablePropertiesSource	A source for properties that can be loaded all at once during initialization, such as loading .properties files.
LogListener	An event listener SPI for logging.
ManagementAgent	Camel JMX service agent
ManagementInterceptStrategy
ManagementInterceptStrategy.InstrumentationProcessor<T>
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`.
ManagementObjectNameStrategy	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.
ManagementStrategyFactory	Service Factory for ManagementStrategy
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 javax.xml.bind.JAXBContext.
ModelToXMLDumper	SPI for dumping model definitions into XML representation.
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.
NormalizedEndpointUri	An Uri which has been normalized.
NotifyBuilderMatcher	Allows to be used in combination with `NotifyBuilder` as external predicate implementations to compute if the exchange matches.
OnCamelContextEvent	Marker interface used to make it easy to discover `CamelContext` related event handlers from the registry.
OnCamelContextInitialized	Notification on initializing a `CamelContext`.
OnCamelContextStart	Notification on starting a `CamelContext`.
OnCamelContextStop	Notification on stopping a `CamelContext`.
OptimisticLockingAggregationRepository	A specialized `AggregationRepository` which also supports optimistic locking.
PackageScanClassResolver	A resolver that can find classes based on package scanning.
PackageScanFilter	Filter that can be used with the `PackageScanClassResolver` resolver.
PackageScanResourceResolver	A resolver that can find resources based on package scanning.
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`.
ProducerCache	Cache containing created `Producer`.
ProducerCache.AsyncProducerCallback	Callback for sending a exchange message to a endpoint using an `AsyncProcessor` capable producer.
PropertiesComponent	Component for property placeholders and loading properties from sources (such as .properties file from classpath or file system)
PropertiesFunction	A function that is applied instead of looking up a property placeholder.
PropertiesSource	A source for properties.
PropertyConfigurer	A marker interface to identify the object as being configurable via a configurer class.
PropertyConfigurerAware	An interface to represent an object which is capable of configuring via `PropertyConfigurer`.
PropertyConfigurerGetter	A marker interface to identify the object as being a configurer which can provide details about the options the configurer supports.
ReactiveExecutor	SPI to plugin different reactive engines in the Camel routing engine.
RecoverableAggregationRepository	A specialized `AggregationRepository` which also supports recovery.
Registry	Represents a `BeanRepository` which may also be capable of binding beans to its repository.
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.
RestBindingJaxbDataFormatFactory	SPI for setting up XML data format (JAXB) for rest-dsl.
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
RestRegistryFactory	A factory for `RestRegistry`.
RouteController	Controller for managing the lifecycle of all the `Route`'s.
RouteError
RouteIdAware	To allow objects to be injected with the route id
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 `org.apache.camel.support.ScheduledPollConsumer` consumers.
SendDynamicAware	Used for components that can optimise the usage of `org.apache.camel.processor.SendDynamicProcessor` (toD) to reuse a static `Endpoint` and `Producer` that supports using headers to provide the dynamic parts.
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.
SupervisingRouteController	A supervising capable `RouteController` that delays the startup of the routes after the camel context startup and takes control of starting the routes in a safe manner.
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.
Tracer	SPI for tracing messages.
TransactedPolicy	A marker for defining the policy to be used for applying transaction to routes.
TransformerRegistry<K>	Registry to cache transformers in memory.
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.
XMLRoutesDefinitionLoader	SPI for loading routes/rests from XML input streams and parsing this to model definition classes.

Class Summary
Class	Description
BeanIntrospection.ClassInfo	Structure of an introspected class.
BeanIntrospection.MethodInfo	Structure of an introspected method.
CamelContextTracker	A `CamelContext` creation and destruction tracker.
CamelLogger	A logger which logs to a slf4j `Logger`.
Contract	A Contract which represents the input type and/or output type of the `Endpoint` or `Processor`.
DataType	Represents the data type URN which is used for message data type contract.
ReifierStrategy	Strategy for reifiers.
RestConfiguration	Configuration use by `RestConsumerFactory` and `RestApiConsumerFactory` for Camel components to support the Camel `rest` DSL.
SendDynamicAware.DynamicAwareEntry	An entry of detailed information from the recipient uri, which allows the `SendDynamicAware` implementation to prepare pre- and post- processor and the static uri to be used for the optimised dynamic to.
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 Summary
Enum	Description
Breakpoint.State	State of the breakpoint as either active or suspended.
CamelEvent.Type
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 Summary
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 Types Summary
Annotation Type	Description
AsEndpointUri	Indicates that the Camel string/expression should be used as an endpoint uri.
AsPredicate	Indicates that the Camel language/expression should be used as predicate.
Configurer	An annotation used to mark classes to indicate code capable of configuring its options via a getter/setters that can be called via Camels `PropertyConfigurer`.
InvokeOnHeader	Marks a method as being invoked for a specific header value.
InvokeOnHeaders	Marks a method as being invoked for a specific header value.
Metadata	Meta data for EIPs, components, data formats and other Camel concepts
UriEndpoint	Represents an annotated Camel Endpoint which can have its properties (and the properties on its consumer) injected from the Camel URI path and its query parameters
UriParam	Represents an injection point of a Camel Uri parameter value on an Endpoint or Consumer, usually configured via a URI style query parameter in a URI
UriParams	Used to annotate a nested configuration parameter type (such as a nested Configuration object) which can then be used on a Component, Endpoint and/or Consumer and then be configured via Camel URI query arguments.
UriPath	Represents an injection point of a Camel Uri path value (the remaining part of a Camel URI without any query arguments)

Package org.apache.camel.spi