Package org.apache.camel.spi
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 createProcessor
for annotation based EIPs.AnnotationScanTypeConverters ATypeConverter
which is capable of annotation scanning forConverter
classes and add these as type converters.AsyncProcessorAwaitManager A manager to handle async routing engine, whenExchange
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 this manager.AuthorizationPolicy A marker for defining the policy to be used for applying authorization to routes.AutowiredLifecycleStrategy Marker interface forLifecycleStrategy
that are used for auto-wiring components, data formats and languages.BacklogTracer Backlog tracer that captures the last N messages during routing in a backlog.BacklogTracerEventMessage Represents a traced message by the BacklogTracer.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 aProcessor
that can invoke a method on a bean and supporting using Camel bean parameter bindings.BeanProxyFactory A factory for creating aProxy
for a bean.BeanRepository Represents a bean repository used to lookup components by name and type.BootstrapCloseable A marker interface for a service, or other kind of process that is only used during bootstrapping Camel.Breakpoint Breakpoint
are used by theDebugger
API.BrowsableEndpoint An optional interface anEndpoint
may choose to implement which allows it to expose a way of browsing the exchanges available.BulkTypeConverters Bulk type converters that often comes out of the box with Apache Camel.CamelBeanPostProcessor Bean post processor.CamelBeanPostProcessorInjector Used for custom injection when doingCamelBeanPostProcessor
bean post-processing.CamelContextCustomizer To apply custom configurations toCamelContext
instances.CamelContextNameStrategy Strategy for assigning name to aCamelContext
.CamelContextTracker.Filter CamelDependencyInjectionAnnotationFactory A factory which performs the task from Camel dependency injection annotations on a field, property or method parameter of a specified type.CamelEvent This interface is implemented by all events.CamelEvent.CamelContextEvent CamelEvent.CamelContextInitializedEvent CamelEvent.CamelContextInitializingEvent CamelEvent.CamelContextReloadedEvent CamelEvent.CamelContextReloadFailureEvent CamelEvent.CamelContextReloadingEvent 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.ExchangeAsyncProcessingStartedEvent Special event only in use for camel-tracing / camel-opentelemtry.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.RouteReloadedEvent CamelEvent.RouteRemovedEvent CamelEvent.RouteStartedEvent CamelEvent.RouteStartingEvent CamelEvent.RouteStoppedEvent CamelEvent.RouteStoppingEvent 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.CliConnector LocalCliConnector
that allows Camel CLI to manage local running Camel integrations.CliConnectorFactory Factory for creating connector to CLI tooling.CompilePostProcessor Allows to plugin custom post processors that are processed after the DSL has loaded the source and compiled into a Java object.ComponentCustomizer To apply custom configurations toComponent
instances.ComponentCustomizer.Policy Used as additional filer mechanism to control if customizers need to be applied or not.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 likeorg.apache.camel.impl.DefaultComponentResolver
Condition A condition to define when a givenExchange
matches when is being routed.ConfigurerResolver A pluggable strategy for resolving different configurers in a loosely coupled mannerConsumerCache Cache containing createdPollingConsumer
.ContentTypeAware Represents an object that can have an associated content type.ContextReloadStrategy SPI strategy for reloadingCamelContext
.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 DataFormatDataFormatCustomizer To apply custom configurations toDataFormat
instances.DataFormatCustomizer.Policy Used as additional filer mechanism to control if customizers need to be applied or not.DataFormatFactory A factory to createDataFormat
.DataFormatName The name of theDataFormat
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 being invoked whenExchange
s is being routed.DebuggerFactory Factory for creatingDebugger
.DeferServiceFactory Factory to create services such asProducer
s and defer starting the created service, untilCamelContext
has been started.DependencyStrategy Strategy when 3rd party dependencies are detected during loading routes.EndpointRegistry<K> Registry to cache endpoints in memory.EndpointStrategy Endpoint strategy with callback invoked when anEndpoint
is about to be registered to the endpoint registry inCamelContext
.EndpointUriFactory EndpointUtilizationStatistics Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.ErrorHandler An interface used to represent an error handlerErrorHandlerAware An interface forProcessor
aware of itsErrorHandler
which are wrapped via theChannel
during route initialization, or specially used byRecipientList
EIP annotation.ErrorHandlerRedeliveryCustomizer Customizer forErrorHandler
which supports redeliveries.EventFactory Factory to createevents
that are emitted when such an event occur.EventNotifier Notifier to sendevents
.ExceptionHandler A Strategy pattern for handling exceptions; particularly in asynchronous processes such as consumers.ExchangeFactory ExchangeFactoryManager ManagesExchangeFactory
.ExchangeFormatter A plugin used to turn anExchange
into a String representation usually to be used for logging or tracing purposes.ExecutorServiceManager Strategy to create thread pools.ExpressionFactoryAware When an instance is aware ofExpressionFactory
.ExpressionResultTypeAware Represents anExpression
orPredicate
that supports a result type.ExtendedPropertyConfigurerGetter A marker interface to identify the object as being a configurer which can provide details about the options the configurer supports.ExtendedRoutesBuilderLoader An extendedRoutesBuilderLoader
that is capable of loading from multiple resources in one unit (such as compiling them together).FactoryFinder Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.FactoryFinderResolver Represents a resolver forFactoryFinder
GeneratedPropertyConfigurer A auto generatedPropertyConfigurer
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 aCamelContext
.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 APIHasId A simple marker interface for an object which has a unique ID which is useful for referring to objects in REST or JMX style APIsHeaderFilterStrategy 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 injectedHeaderFilterStrategy
.HeadersMapFactory HttpResponseAware Represents an object which is aware of HTTP responses.IdAware To allow objects to be injected with an id, such as EIPProcessor
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 flightExchange
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.InterceptEndpointFactory A factory to createEndpoint
which are intercepted.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.InternalProcessor InternalProcessor
that Camel routing engine used during routing for cross cutting functionality such as: ExecuteUnitOfWork
Keeping track which route currently is being routed ExecuteRoutePolicy
Gather JMX performance statics Tracing Debugging Message History Stream CachingTransformer
...InternalProcessorFactory A factory used internally by Camel to createProcessor
and other internal building blocks.InvokeOnHeaderStrategy Pluggable strategy for invokingInvokeOnHeader
.Language Represents a language to be used forExpression
orPredicate
instancesLanguageCustomizer To apply custom configurations toLanguage
instances.LanguageCustomizer.Policy Used as additional filer mechanism to control if customizers need to be applied or not.LanguageResolver A pluggable strategy for resolving different languages in a loosely coupled mannerLifecycleStrategy Strategy for lifecycle notifications.LoadablePropertiesSource A source for properties that can be loaded all at once during initialization, such as loading .properties files.LocalBeanRepositoryAware Allows aBeanRepository
to temporary have a local repository take precedence, such as when creating route templates to give more flexibility.LogListener An event listener SPI for logging.ManagementAgent Camel JMX service agentManagementInterceptStrategy A specializedInterceptStrategy
which is used for JMX management for EIPs.ManagementInterceptStrategy.InstrumentationProcessor<T> ManagementMBeanAssembler An assembler to assemble aRequiredModelMBean
which can be used to register the object in JMX.ManagementNameStrategy Strategy for assigning the name part of theObjectName
for a managedCamelContext
.ManagementObjectNameStrategy Strategy for computingObjectName
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 ManagementStrategyMaskingFormatter A plugin used to mask a log String, for example security information like password or passphrase.MessageHistoryFactory A factory to createMessageHistory
instances.MockSendToEndpointStrategyFactory Factory for intercepting sending to endpoint pattern and sending to mock component.ModelineFactory Factory for parsing camel-k modeline when running Camel standalone with DSLs.ModelJAXBContextFactory Factory to abstract the creation of the Model's javax.xml.bind.JAXBContext.ModelReifierFactory Factory that uses reifiers to build an entity from a given model.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 injectedNodeIdFactory 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 discoverCamelContext
related event handlers from the registry.OnCamelContextInitialized Notification on an initialized aCamelContext
.OnCamelContextInitializing Notification on initializing aCamelContext
.OnCamelContextStart Notification on starting aCamelContext
.OnCamelContextStarted Notification on a startedCamelContext
.OnCamelContextStarting Notification on starting aCamelContext
.OnCamelContextStop Notification on stopping aCamelContext
.OnCamelContextStopped Notification on a stoppedCamelContext
.OnCamelContextStopping Notification on stopping aCamelContext
.OptimisticLockingAggregationRepository A specializedAggregationRepository
which also supports optimistic locking.PackageScanClassResolver A resolver that can find classes based on package scanning.PackageScanFilter Filter that can be used with thePackageScanClassResolver
resolver.PackageScanResourceResolver A resolver that can find resources based on package scanning.PeriodTaskResolver Finder to findPeriodicTask
tasks.PeriodTaskScheduler A shared scheduler to run small period tasks, such as updating internal statistics, or for custom components to have a background task.Policy A strategy capable of applying interceptors to a processor.PollingConsumerPollStrategy Strategy for aPollingConsumer
when polling anEndpoint
.PooledObjectFactory<T> Factory for pooled objects or tasks.PooledObjectFactory.Statistics Utilization statistics of the this factory.PredicateExceptionFactory A factory that can be used to create a specific exception when aPredicate
returning false, which can be used by camel-validator and other components.PredicateFactoryAware When an instance is aware ofPredicateFactory
.ProcessorExchangeFactory ProcessorFactory A factory to createProcessor
based on thedefinition
.ProducerCache Cache containing createdProducer
.ProducerCache.AsyncProducerCallback Callback for sending a exchange message to a endpoint using anAsyncProcessor
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.PropertiesReload Listener for re-loading aProperties
such as a Camel route.PropertiesSource A source for properties.PropertiesSourceFactory Factory for creating out of the boxPropertiesSource
.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 viaPropertyConfigurer
.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 specializedAggregationRepository
which also supports recovery.Registry Represents aBeanRepository
which may also be capable of binding beans to its repository.ReloadStrategy SPI strategy for reloading.Resource Describe a resource, such as a file or class path resource.ResourceAware An interface to represent an object which wishes to be injected with theResource
ResourceLoader SPI for loading resources.ResourceReload Listener for re-loading aResource
such as a Camel route.ResourceReloadStrategy SPI strategy for reloadingResource
in an existing runningCamelContext
ResourceResolver SPI for loading resources.RestApiConsumerFactory Allows SPI to plugin aRestApiConsumerFactory
that creates the CamelConsumer
responsible for handling incoming HTTP GET requests from clients that request to access the REST API documentation.RestApiProcessorFactory Allows SPI to plugin aRestApiProcessorFactory
that creates the CamelProcessor
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 aRestConsumerFactory
that creates the CamelConsumer
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 aRestProducerFactory
that creates the CamelProducer
responsible for performing HTTP requests to call a remote REST service.RestRegistry A registry of all REST services running within theCamelContext
which have been defined and created using the Rest DSL.RestRegistry.RestService Details about the REST serviceRestRegistryFactory A factory forRestRegistry
.RouteController Controller for managing the lifecycle of all theRoute
's.RouteError The last error that happened during changing the route lifecycle, i.e.RouteFactory A factory to createRoute
RouteIdAware To allow objects to be injected with the route idRoutePolicy Policy for aRoute
which allows controlling the route at runtime.RoutePolicyFactory A factory to createRoutePolicy
and assign to routes automatic.RoutesBuilderLoader SPI for loadingRoutesBuilder
from aResource
.RoutesLoader SPI for loadingRoutesBuilder
from a list ofResource
.RouteStartupOrder Information about a route to be started where we want to control the order in which they are started byCamelContext
.RouteTemplateLoaderListener Listener when route templates is loaded from aResource
.RouteTemplateParameterSource Source for parameters used when creating routes from route templates.RuntimeEndpointRegistry A registry which listen for runtime usage ofEndpoint
during routing in Camel.RuntimeEndpointRegistry.Statistic Statistics gathered about the endpoint.ScheduledPollConsumerScheduler A pluggable scheduler fororg.apache.camel.support.ScheduledPollConsumer
consumers.ScriptingLanguage Represents aLanguage
which is a general purpose scripting languages such as groovy, joor and others.SendDynamicAware SharedInternalProcessor A Shared (thread safe) internalProcessor
that Camel routing engine used during routing for cross cutting functionality such as: ExecuteUnitOfWork
Keeping track which route currently is being routed ExecuteRoutePolicy
Gather JMX performance statics Tracing Debugging Message History Stream CachingTransformer
...ShutdownAware AllowsConsumer
to fine grained control on shutdown which mostly have to cater for in-memory based components.ShutdownPrepared Allows aService
to prepare for shutdown.ShutdownStrategy Pluggable shutdown strategy executed during shutdown of Camel and the active routes.SimpleExecutorService Marker interface to signal that aExecutorService
is simple and tasks are either only submitted viaExecutorService.submit(Runnable)
or executed viaExecutor.execute(Runnable)
methods.StartupStepRecorder To recordStartupStep
during startup to allow to capture diagnostic information to help troubleshoot Camel applications via various tooling such as Java Flight Recorder.StateRepository<K,V> ThisStateRepository
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 capableRouteController
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 customProcessor
orComponent
instances to respond to completed or failed processing of anExchange
rather like Spring's TransactionSynchronizationSynchronizationRouteAware An extendedSynchronization
which is route aware.SynchronizationVetoable A vetoableSynchronization
.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 aTypeConverterRegistry
from some kind of mechanism.TypeConverterRegistry Registry for type converters.TypeConverterRegistry.Statistics Utilization statistics of the registry.UnitOfWork An object representing the unit of work processing anExchange
which allows the use ofSynchronization
hooks.UnitOfWorkFactory Factory to createUnitOfWork
.UriFactoryResolver A pluggable strategy for resolving different URI factories in a loosely coupled manner.UuidGenerator Generator to generate UUID strings.ValidatorRegistry<K> Registry to cache validators in memory.WrapAwareProcessor An interface to represent an object which wraps aProcessor
.XMLRoutesDefinitionLoader Deprecated. useRoutesLoader
-
Class Summary Class Description BeanIntrospection.ClassInfo Structure of an introspected class.BeanIntrospection.MethodInfo Structure of an introspected method.CamelContextTracker ACamelContext
creation and destruction tracker.CamelLogger A logger which logs to a slf4jLogger
.ComponentCustomizer.Builder<T extends Component> A fluent builder to create aComponentCustomizer
instance.ConfigurerStrategy Strategy for configurers.Contract DataFormatCustomizer.Builder<T extends DataFormat> A fluent builder to create aDataFormatCustomizer
instance.DataType Represents the data type URN which is used for message data type contract.LanguageCustomizer.Builder<T extends Language> A fluent builder to create aLanguageCustomizer
instance.ReifierStrategy Strategy for reifiers.RestConfiguration Configuration use byRestConsumerFactory
andRestApiConsumerFactory
for Camel components to support the Camelrest
DSL.SendDynamicAware.DynamicAwareEntry An entry of detailed information from the recipient uri, which allows theSendDynamicAware
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 anAggregationRepository
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 ApiMethod Represents an API method as part of a parent API.ApiParam Used for annotating aUriParam
parameter that its for use by API based endpoints.ApiParams Used to annotate a nested configuration parameter type (such as a nested Configuration object) which can then be used on a API based component, endpoint.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 CamelsPropertyConfigurer
.InvokeOnHeader Marks a method as being invoked for a specific header value.Metadata Meta data for EIPs, components, data formats and other Camel conceptsUriEndpoint 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 parametersUriParam 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 URIUriParams 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)