Package org.apache.camel.spi

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

See: Description

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 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.
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>
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 Exchanges is being routed.
DeferServiceFactory	Factory to create services such as Producers 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 Processors 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 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 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 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.
NotifyBuilderMatcher	Allows to be used in combination with NotifyBuilder as external predicate implementations to compute if the exchange matches.
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)
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.
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.
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.
RouteContext	The context used to activate new routing rules
RouteController	Controller for managing the lifecycle of all the Route's.
RouteError
RouteIdAware	To allow objects to be injected with the route id This allows access to the route id of the processor at runtime, to know which route its associated with.
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.
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.
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 For example to associate labels to Camel components
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 Description

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