Package org.apache.camel.spi

@NullMarked package org.apache.camel.spi

Since:

4.21

Related Packages

Package	Description
org.apache.camel	The core Camel API.
org.apache.camel.spi.annotations	SPI annotations for plugins

Class	Description
AggregationRepository	Persistent store for in-progress aggregated Exchange instances, used by the Aggregator EIP.
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.
ApiMethod	Represents an API method as part of a parent API.
ApiParam	Used for annotating a UriParam 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.
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 this manager.
AuthorizationPolicy	A marker for defining the policy to be used for applying authorization to routes.
AutoMockInterceptStrategy	Strategy for intercepting messages sent to endpoints in order to auto-mock them during testing.
AutowiredLifecycleStrategy	Marker interface for LifecycleStrategy that are used for auto-wiring components, data formats and languages.
BacklogDebugger	High-level route debugger SPI that suspends Exchange processing at named breakpoints and exposes the suspended state for inspection, as described in the Debugger documentation.
BacklogErrorEventMessage	Represents an error event captured by the ErrorRegistry.
BacklogEventMessage	Base interface for backlog event messages that capture exchange snapshots at a point in time, without retaining references to the live Exchange.
BacklogTracer	Passive message capture mechanism that records a rolling window of the last N exchange snapshots as they pass through route nodes, as described in the Backlog Tracer documentation.
BacklogTracerEventMessage	Snapshot of a single exchange event captured by the BacklogTracer as a message transits a route node.
BackOffTimerFactory	SPI factory for creating BackOffTimer instances used to schedule retry or back-off tasks.
BeanIntrospection	Low-level SPI for reading and writing bean properties via Java reflection, used internally by Camel's property binding infrastructure.
BeanIntrospection.ClassInfo	Structure of an introspected class.
BeanIntrospection.MethodInfo	Structure of an introspected method.
BeanProcessorFactory	Factory for creating a Processor that invokes a method on a bean with full support for Camel bean parameter bindings.
BeanProxyFactory	Factory for creating a Proxy facade that routes method invocations to a Camel Endpoint as messages.
BeanRepository	Pluggable contract for looking up beans by name or type, forming the foundation of Camel's Registry.
BootstrapCloseable	Marker for a service (or other process) that is only needed while Camel is bootstrapping.
Breakpoint	Callback interface for a debugger breakpoint, registered with the Debugger and invoked as Exchanges pass through route nodes.
Breakpoint.State	State of the breakpoint as either active or suspended.
BrowsableEndpoint	An optional interface an Endpoint may choose to implement which allows it to expose a way of browsing the exchanges available.
BrowsableEndpoint.BrowseStatus	A quick status of the browse queue
BrowsableVariableRepository	A VariableRepository that can browse the variables.
BulkTypeConverters	A source-code-generated, compile-time-optimized bundle of TypeConverter instances for use with the type conversion infrastructure.
CamelBeanPostProcessor	Processes beans as they are created or registered, applying Camel's annotation-based dependency injection.
CamelBeanPostProcessorInjector	Pluggable injector that participates in CamelBeanPostProcessor bean post-processing to support custom, typically 3rd-party, dependency-injection annotations.
CamelContextCustomizer	Strategy for applying custom configuration to a CamelContext after it has been created.
CamelContextNameStrategy	Strategy for assigning the name of a CamelContext.
CamelContextTracker	Tracks the creation and destruction of CamelContext instances across the JVM.
CamelContextTracker.Filter	Decides which CamelContext instances a CamelContextTracker is notified about.
CamelDependencyInjectionAnnotationFactory	Factory that creates the task carrying out a Camel dependency-injection annotation, such as binding a BindToRegistry bean into the Registry.
CamelEvent	Base interface for all Camel events used by the EventNotifier for notifications about Exchange, Route, CamelContext, and Service lifecycle changes.
CamelEvent.CamelContextEvent	Event related to CamelContext lifecycle changes.
CamelEvent.CamelContextInitializedEvent	Fired when the CamelContext has been initialized.
CamelEvent.CamelContextInitializingEvent	Fired when the CamelContext is initializing.
CamelEvent.CamelContextReloadedEvent	Fired when the CamelContext has been reloaded.
CamelEvent.CamelContextReloadFailureEvent	Fired when the CamelContext failed to reload.
CamelEvent.CamelContextReloadingEvent	Fired when the CamelContext is reloading.
CamelEvent.CamelContextResumedEvent	Fired when the CamelContext has been resumed.
CamelEvent.CamelContextResumeFailureEvent	Fired when the CamelContext failed to resume.
CamelEvent.CamelContextResumingEvent	Fired when the CamelContext is resuming.
CamelEvent.CamelContextRoutesStartedEvent	Fired when routes have been started.
CamelEvent.CamelContextRoutesStartingEvent	Fired when routes are starting.
CamelEvent.CamelContextRoutesStoppedEvent	Fired when routes have been stopped.
CamelEvent.CamelContextRoutesStoppingEvent	Fired when routes are stopping.
CamelEvent.CamelContextStartedEvent	Fired when the CamelContext has been fully started.
CamelEvent.CamelContextStartingEvent	Fired when the CamelContext is starting.
CamelEvent.CamelContextStartupFailureEvent	Fired when the CamelContext failed to start.
CamelEvent.CamelContextStopFailureEvent	Fired when the CamelContext failed to stop cleanly.
CamelEvent.CamelContextStoppedEvent	Fired when the CamelContext has been stopped.
CamelEvent.CamelContextStoppingEvent	Fired when the CamelContext is stopping.
CamelEvent.CamelContextSuspendedEvent	Fired when the CamelContext has been suspended.
CamelEvent.CamelContextSuspendingEvent	Fired when the CamelContext is suspending.
CamelEvent.ExchangeAsyncProcessingStartedEvent	Deprecated.
CamelEvent.ExchangeCompletedEvent	Fired when an exchange has been completed successfully.
CamelEvent.ExchangeCreatedEvent	Fired when a new exchange has been created.
CamelEvent.ExchangeEvent	Event related to Exchange processing.
CamelEvent.ExchangeFailedEvent	Fired when an exchange has failed.
CamelEvent.ExchangeFailureEvent	Event providing details about how a failure was handled during exchange processing.
CamelEvent.ExchangeFailureHandledEvent	Fired after a failure has been handled by an error handler.
CamelEvent.ExchangeFailureHandlingEvent	Fired when a failure is about to be handled by an error handler.
CamelEvent.ExchangeRedeliveryEvent	Fired when an exchange is about to be redelivered.
CamelEvent.ExchangeSendingEvent	Fired when an exchange is about to be sent to an endpoint.
CamelEvent.ExchangeSentEvent	Fired when an exchange has been sent to an endpoint.
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	Fired when a route has been added.
CamelEvent.RouteEvent	Event related to Route lifecycle changes.
CamelEvent.RouteReloadedEvent
CamelEvent.RouteRemovedEvent	Fired when a route has been removed.
CamelEvent.RouteRestartingEvent
CamelEvent.RouteRestartingFailureEvent
CamelEvent.RouteStartedEvent	Fired when a route has been started.
CamelEvent.RouteStartingEvent	Fired when a route is starting.
CamelEvent.RouteStoppedEvent	Fired when a route has been stopped.
CamelEvent.RouteStoppingEvent	Fired when a route is stopping.
CamelEvent.ServiceEvent	Event related to Service lifecycle changes.
CamelEvent.ServiceStartupFailureEvent	Fired when a service failed to start.
CamelEvent.ServiceStopFailureEvent	Fired when a service failed to stop.
CamelEvent.StepCompletedEvent	Fired when a Step EIP has completed processing an exchange.
CamelEvent.StepEvent	Event related to a Step EIP processing.
CamelEvent.StepFailedEvent	Fired when a Step EIP has failed processing an exchange.
CamelEvent.StepStartedEvent	Fired when a Step EIP has started processing an exchange.
CamelEvent.Type
CamelInternalProcessorAdvice<T>	An advice (before and after) to execute cross-cutting functionality in the Camel routing engine.
CamelLogger	A configurable SLF4J logger wrapper that carries a LoggingLevel and an optional SLF4J Marker.
CamelMDCService	SPI that plugs a Mapped Diagnostic Context (MDC) propagation implementation into Camel's exchange processing pipeline.
CamelMetricsService	A Camel metrics service is a factory for micrometer metrics.
CamelTracingService	A Camel tracing service is a factory for telemetry tracers.
CircuitBreakerConstants
ClaimCheckRepository	Storage repository for the Claim Check EIP, which temporarily parks a message payload so that a lighter message can travel through an intermediate part of a route.
ClassResolver	Platform-neutral strategy for loading classes and classpath resources across the different runtimes that Camel supports (standalone JVM, Spring Boot, Quarkus, OSGi, JBang, and others).
CliConnector	SPI that exposes a Camel integration to the Camel CLI for local inspection and control.
CliConnectorFactory	SPI factory for creating a CliConnector that enables Camel CLI management of a live integration.
CompilePostProcessor	Allows to plugin custom post-processors that are processed after the DSL has loaded the source and compiled into a Java object.
CompilePreProcessor	Allows to plugin custom pre-processors that are processed before the DSL has loaded the source and compiled into a Java object.
CompileStrategy	Strategy for runtime compiled languages and DSLs.
ComponentCustomizer	Strategy for applying custom configuration to Component instances as they are created.
ComponentCustomizer.Builder<T extends Component>	A fluent builder to create a ComponentCustomizer instance.
ComponentCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
ComponentNameResolver	Discovers the names of all Component implementations available on the classpath at runtime.
ComponentResolver	Pluggable strategy for autoloading a Component instance from a URI scheme the first time that scheme is encountered by a CamelContext.
Condition	A condition to define when a given Exchange matches when is being routed.
Configurer	Marks a class as a candidate for build-time code generation of a PropertyConfigurer implementation by the camel-package-maven-plugin.
ConfigurerResolver	Pluggable strategy for resolving a PropertyConfigurer by the name of the target type (for example timer-component or timer-endpoint).
ConfigurerStrategy	Utility class for managing the lifecycle of bootstrap-phase PropertyConfigurer instances generated for @Configurer(bootstrap = true) types.
ConsumerCache	Cache containing created PollingConsumer.
ContentTypeAware	Represents an object that can have an associated content type.
ContextReloadStrategy	SPI strategy for reloading a running CamelContext in place.
ContextServiceLoaderPluginResolver	Service Provider Interface (SPI) for discovering and loading ContextServicePlugin implementations during CamelContext initialization.
ContextServicePlugin	A plugin interface that allows third-party components to perform initialization tasks when a CamelContext is being configured and started.
Contract	Declares the expected input and/or output DataType of an Endpoint or Processor.
DataFormat	Pluggable strategy for converting message bodies to and from a serialised byte-stream format, as described in the Data Format documentation.
DataFormatContentTypeHeader	Special accessor for a DataFormat
DataFormatCustomizer	Strategy for applying custom configuration to DataFormat instances as they are created.
DataFormatCustomizer.Builder<T extends DataFormat>	A fluent builder to create a DataFormatCustomizer instance.
DataFormatCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
DataFormatFactory	Factory for creating fresh DataFormat instances on demand, used when a data format requires per-use instantiation rather than sharing a single instance across the route.
DataFormatName	Marker interface that exposes the canonical name of a DataFormat implementation, enabling runtime lookup and catalog introspection without depending on the concrete class.
DataFormatResolver	SPI strategy for resolving a DataFormat implementation by name.
DataType	Represents the data type URN which is used for message data type contract.
DataTypeAware	Allows Message to store a DataType which represents the data type of the Message.
DataTypeTransformer	Marks a Transformer implementation as a data type transformer, identified by its name and/or its from/to DataTypes.
Debugger	Low-level debugger SPI that fires Breakpoint callbacks as Exchanges move through each route node, as described in the Debugger documentation.
DebuggerFactory	Factory for creating Debugger.
DeferServiceFactory	Factory to create services such as Producers and defer starting the created service, until CamelContext has been started.
DependencyStrategy	Strategy notified when a 3rd-party dependency is detected while loading routes.
DumpRoutesStrategy	Strategy for dumping routes during startup dump all loaded routes (incl rests and route templates).
EmbeddedHttpService	Information about embedded HTTP server such as when using the camel-platform-http component, that integrates with the Spring Boot or Quarkus HTTP server.
EndpointRegistry	Registry to cache endpoints in memory.
EndpointServiceLocation	Used for getting information about location to (hosted or external) network services.
EndpointServiceRegistry	Registry for EndpointServiceLocation to make it easy to find information about usage of external services such as databases, message brokers, cloud systems, that Camel is connecting to.
EndpointServiceRegistry.EndpointService	Details about the endpoint service
EndpointStrategy	Endpoint strategy with callback invoked when an Endpoint is about to be registered to the endpoint registry in CamelContext.
EndpointUriFactory	Factory to create Endpoint URI string from a Map of parameters.
EndpointUtilizationStatistics	Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.
ErrorHandler	Marker interface identifying a Processor as an error-handling wrapper, as described in the Error Handler documentation.
ErrorHandlerAware	An interface for Processor aware of its ErrorHandler which are wrapped via the Channel during route initialization, or specially used by RecipientList EIP annotation.
ErrorHandlerRedeliveryCustomizer	Customizer for ErrorHandler which supports redeliveries.
ErrorRegistry	A registry which captures exceptions that occurred during message routing and stores them in memory.
ErrorRegistryView	A scoped view over error entries in an ErrorRegistry, supporting browsing and clearing.
EventFactory	Factory that mints concrete CamelEvent instances for every significant lifecycle and messaging event in the Camel runtime.
EventNotifier	Observer that receives CamelEvent notifications fired by the Camel runtime.
ExceptionHandler	Strategy for handling exceptions that arise in asynchronous or background processing where a normal exception propagation path does not exist, such as in a Consumer's polling thread.
ExchangeFactory	Factory used by Consumer (and PollingConsumer) to create the Exchange that carries an incoming message into Camel.
ExchangeFactoryManager	Manages ExchangeFactory.
ExchangeFormatter	Strategy for rendering an Exchange as a human-readable String, used primarily for logging and tracing output.
ExecutorServiceManager	Strategy to create thread pools.
ExecutorServiceManager.ThreadFactoryListener	Listener when a new ThreadFactory is created, which allows to plugin custom behaviour.
ExpressionFactoryAware	When an instance is aware of ExpressionFactory.
ExpressionResultTypeAware	Represents an Expression or Predicate that supports a result type.
ExtendedPropertyConfigurerGetter	Extends PropertyConfigurerGetter with the ability to enumerate every option a target supports.
ExtendedRoutesBuilderLoader	An extended RoutesBuilderLoader that is capable of loading from multiple resources in one unit (such as compiling them together).
FactoryFinder	Looks up and instantiates SPI factory classes declared in resource files on the classpath, following the META-INF/services/org/apache/camel/ service-file convention used throughout Camel.
FactoryFinderResolver	Factory for creating and caching FactoryFinder instances, each scoped to a specific resource-path prefix on the classpath.
GeneratedPropertyConfigurer	Marker for a PropertyConfigurer that Camel generates at build time for fast configuration of components and endpoints.
GroovyScriptCompiler	To let camel-groovy pre-compile script files during bootstrap.
GroupAware	Marker for an object whose group can be injected.
HasCamelContext	A simple marker interface for an object which holds a CamelContext.
HasGroup	Marker for an object that belongs to a named group, useful for group-related operations such as clustering and JMX APIs.
HasId	Marker for an object that exposes a unique id, useful for referencing it in REST, JMX, and tooling APIs.
HeaderFilterStrategy	Interface to allow pluggable implementation to filter headers to and from Camel message.
HeaderFilterStrategy.Direction	The direction is either IN or OUT.
HeaderFilterStrategyAware	An interface to represent an object which can make use of injected HeaderFilterStrategy.
HeadersMapFactory	SPI factory that creates the Map implementation used to store headers on a Message.
HostedService	To use for identifying Consumer which can host a service, such as a TCP network server, or an embedded HTTP server.
HttpResponseAware	Represents an object which is aware of HTTP responses.
IdAware	Marker for an object whose id can be injected, such as EIP Processors created from Camel routes.
IdempotentRepository	Persistent store of message identifiers that implements the Idempotent Consumer pattern, ensuring each message is processed at most once.
InflightRepository	A live registry that tracks every Exchange that is currently being processed within the CamelContext.
InflightRepository.InflightExchange	Information about the inflight exchange.
Injector	Pluggable strategy for instantiating objects, optionally performing dependency injection as part of creation.
InterceptableProcessor	Implemented by a Processor to control whether it may be wrapped by an InterceptStrategy.
InterceptEndpointFactory	Factory for creating an InterceptSendToEndpoint that intercepts messages sent to an Endpoint.
InterceptSendToEndpoint	An Endpoint wrapper that, when sent to, detours the exchange: before, send to the original endpoint (which can be skipped), then after (optional).
InterceptStrategy	Strategy that wraps the Processors in a route with interceptors, for cross-cutting concerns such as gathering performance statistics at the processor level.
InternalProcessor	Internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching Transformer ... and more.
InternalProcessorFactory	A factory used internally by Camel to create Processor and other internal building blocks.
InvokeOnHeader	Marks a method as being invoked for a specific header value.
InvokeOnHeaderStrategy	Pluggable strategy for invoking InvokeOnHeader.
Language	SPI base for every Camel expression and predicate language.
LanguageCustomizer	Strategy for applying custom configuration to Language instances as they are created.
LanguageCustomizer.Builder<T extends Language>	A fluent builder to create a LanguageCustomizer instance.
LanguageCustomizer.Policy	Used as additional filer mechanism to control if customizers need to be applied or not.
LanguageResolver	SPI strategy for resolving a Language implementation by name in a loosely coupled way.
LifecycleStrategy	Observer SPI that receives callbacks for every significant lifecycle event in a CamelContext.
LoadablePropertiesSource	A PropertiesSource whose properties can be loaded all at once during initialization, such as a .properties file.
LocalBeanRepositoryAware	Allows a BeanRepository 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	Low-level JMX bridge that registers and unregisters Camel managed objects in a MBeanServer.
ManagementInterceptStrategy	SPI that wraps EIP Processors with instrumentation so that per-exchange statistics can be collected and exposed via JMX MBeans.
ManagementInterceptStrategy.InstrumentationProcessor<T>
ManagementMBeanAssembler	Assembles a ModelMBean from a Camel managed object so it can be registered in the MBeanServer.
ManagementNameStrategy	Strategy for assigning the name segment of the ObjectName for a managed CamelContext.
ManagementObjectNameStrategy	Strategy for computing the full ObjectName (domain plus all key-value properties) for every Camel artifact registered in JMX.
ManagementObjectStrategy	Strategy that creates the managed wrapper objects Camel registers in JMX for its internal artifacts.
ManagementStrategy	Top-level SPI for Camel's management and observability layer, coordinating JMX registration, lifecycle events, and statistics collection across all Camel artifacts.
ManagementStrategyFactory	SPI factory that creates the ManagementStrategy and its associated LifecycleStrategy for a CamelContext.
MaskingFormatter	A plugin used to mask a log String, for example security information like password or passphrase.
MessageHistoryFactory	Factory for creating MessageHistory entries, which together form the audit trail of a single Exchange as it passes through each node of a route.
MessageSizeStrategy	Strategy for computing the size of message payloads (body and headers) for observation purposes.
Metadata	Meta data for EIPs, components, data formats and other Camel concepts For example to associate labels to Camel components
MimeType	Mime types known to Camel data types and its transformers.
MockSendToEndpointStrategyFactory	Factory for intercepting sending to endpoint pattern and sending to mock component.
ModelDumpLine	Represents a line in a model dumper of the route structure (not with full details such as XML or YAML dump).
ModelineFactory	Factory for parsing modeline when running Camel CLI standalone with DSLs.
ModelJAXBContextFactory	Factory to abstract the creation of the Model's jakarta.xml.bind.JAXBContext.
ModelReifierFactory	Factory that uses reifiers to build an entity from a given model.
ModelToJavaDumper	SPI that serialises Camel route model definitions to their Java DSL representation (source code).
ModelToStructureDumper	SPI for dumping model definitions into textual structure
ModelToXMLDumper	SPI that serialises Camel route model definitions to their XML DSL representation.
ModelToYAMLDumper	SPI that serialises Camel route model definitions to their YAML DSL 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.
OAuthClientAuthenticationFactory	Factory for resolving OAuth 2.0 bearer tokens using the client_credentials grant.
OAuthClientConfig	Configuration for OAuth 2.0 Client Credentials grant.
OAuthTokenValidationConfig	Configuration for validating incoming OAuth 2.0 bearer tokens.
OAuthTokenValidationConfigResolver	Resolves OAuthTokenValidationConfig instances from Camel OAuth profile properties.
OAuthTokenValidationFactory	Factory for validating incoming OAuth 2.0 bearer tokens (JWT and opaque).
OAuthTokenValidationResult	Result of validating an incoming OAuth 2.0 bearer token.
OAuthTokenValidationResult.ErrorCode	Stable validation failure categories for rejected bearer tokens.
OnCamelContextEvent	Marker interface for event handlers that react to CamelContext lifecycle phases.
OnCamelContextInitialized	Event handler invoked after the CamelContext has been initialized, before it is started.
OnCamelContextInitializing	Event handler invoked while the CamelContext is initializing, before it is started.
OnCamelContextStarted	Event handler invoked after the CamelContext has fully started and its routes are running.
OnCamelContextStarting	Event handler invoked while the CamelContext is starting, before it has fully started.
OnCamelContextStopped	Event handler invoked after the CamelContext has fully stopped.
OnCamelContextStopping	Event handler invoked while the CamelContext is stopping, before it has fully stopped.
OptimisedComponentResolver	A Component resolver that are used in EIPs with dynamic behavior such as toD, enrich and others.
OptimisticLockingAggregationRepository	A specialized AggregationRepository which also supports optimistic locking.
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.
PackageScanClassResolver	Classpath scanning strategy for discovering classes by annotation, supertype, or custom predicate across one or more packages, used by Camel at startup to auto-detect components, type converters, and other pluggable types.
PackageScanFilter	Predicate applied by PackageScanClassResolver during classpath scanning to determine whether a discovered class should be included in the result set.
PackageScanResourceResolver	A resolver that can find resources based on package scanning.
PeriodTaskResolver	Finder to find PeriodicTask tasks.
PeriodTaskScheduler	A shared scheduler to run small period tasks, such as updating internal statistics, or for custom components to have a background task.
PluginManager	A manager for internal plugins.
Policy	A strategy capable of applying interceptors to a processor.
PollDynamicAware	Used for components that can optimise the usage of invalid reference org.apache.camel.processor.PollProcessor (poll/pollEnrich) to reuse a static Endpoint and DynamicPollingConsumer that supports using headers to provide the dynamic parts.
PollDynamicAware.DynamicAwareEntry	An entry of detailed information from the recipient uri, which allows the PollDynamicAware implementation to prepare the static uri to be used for the optimised poll.
PollingConsumerPollStrategy	Strategy for a PollingConsumer when polling an Endpoint.
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 a Predicate returning false, which can be used by camel-validator and other components.
PredicateFactoryAware	When an instance is aware of PredicateFactory.
ProcessorExchangeFactory	Factory used by Processor implementations (EIPs) when they create copies of the current Exchange for sub-routing.
ProcessorFactory	A factory to create Processor based on the invalid reference definition .
ProducerCache	Cache containing created Producer.
ProducerCache.AsyncProducerCallback	Callback for sending a exchange message to a endpoint using an AsyncProcessor capable producer.
PropertiesComponent	SPI for the Camel property-placeholder subsystem, which resolves {{key}} tokens in endpoint URIs, DSL expressions, and configuration values.
PropertiesFunction	Extension point for the PropertiesComponent that handles property placeholders of the form {{name:remainder}}, where name matches PropertiesFunction.getName().
PropertiesReload	Listener notified when a Properties source is re-loaded at runtime, for example after a properties file changes.
PropertiesResolvedValue	Captures how a single PropertiesComponent property placeholder was resolved, for inspection and tooling.
PropertiesSource	A source of property values for the Camel PropertiesComponent when resolving property placeholders.
PropertiesSourceFactory	Factory for creating the built-in PropertiesSource implementations used by the PropertiesComponent.
PropertyConfigurer	Configures a single property on a target object (such as a Component, Endpoint, or EIP) without using reflection.
PropertyConfigurerAware	Implemented by objects that can supply the PropertyConfigurer for a given bean instance.
PropertyConfigurerGetter	Extension of the configurer SPI that, in addition to setting properties, can describe the options a target supports.
ReactiveExecutor	SPI for plugging a custom reactive (non-blocking) dispatch engine into Camel's internal routing loop.
RecoverableAggregationRepository	A specialized AggregationRepository which also supports recovery.
Registry	Represents a BeanRepository which may also be capable of binding beans to its repository.
ReloadStrategy	SPI strategy for reloading Camel at runtime when a change is detected.
Resilience4jMicrometerFactory	A factory for using micrometer with resilience4j circuit breakers
Resource	Describes a loadable resource such as a file, classpath entry, or HTTP URL.
ResourceAware	Implemented by objects that want the Resource they originate from to be injected into them.
ResourceLoader	SPI for loading a Resource from a URI.
ResourceReload	Listener notified when a Resource is re-loaded at runtime, for example after a route file changes.
ResourceReloadStrategy	SPI strategy for reloading Resources in an already running CamelContext.
ResourceResolver	SPI for resolving a Resource for a specific URI scheme.
RestApiConsumerFactory	SPI that creates the Camel Consumer responsible for handling incoming HTTP GET requests to the REST API documentation endpoint.
RestApiProcessorFactory	Allows SPI to plugin a RestApiProcessorFactory that creates the Camel Processor responsible for servicing and generating the REST API documentation.
RestBindingJacksonXmlDataFormatFactory	SPI for setting up XML data format (jacksonXml) for rest-dsl.
RestBindingJaxbDataFormatFactory	SPI that configures a JAXB DataFormat pair for XML binding in the Camel REST DSL.
RestClientRequestValidator	Used for validating incoming client requests with Camel Rest DSL.
RestClientRequestValidator.ValidationContext	Validation context to use during validation
RestClientRequestValidator.ValidationError	Validation error
RestClientResponseValidator	Used for validating incoming client responses with Camel Rest DSL.
RestClientResponseValidator.ValidationContext	Validation context to use during validation
RestClientResponseValidator.ValidationError	Validation error
RestConfiguration	Central configuration bean for the Camel REST DSL, shared by RestConsumerFactory, RestProducerFactory, and RestApiConsumerFactory implementations.
RestConfiguration.RestBindingMode
RestConfiguration.RestHostNameResolver
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.
RestOpenApiConsumerFactory	Allows SPI to plugin a RestOpenApiConsumerFactory 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 for an entire open-api specification.
RestProducerFactory	SPI that creates the Camel Producer responsible for performing HTTP requests to call a remote REST service.
RestRegistry	A live registry of all REST services running within the CamelContext that were defined using the Camel REST DSL.
RestRegistry.RestService	Details about the REST service
RestRegistryFactory	A factory for RestRegistry.
RouteController	Central SPI for managing the start, stop, suspend, resume, and reload lifecycle of all Routes in a CamelContext, as described in the Route Controller documentation.
RouteDiagramDumper	To dump routes as visual diagrams as PNG images.
RouteDiagramDumper.NodeLabelMode
RouteDiagramDumper.Theme
RouteError	The last error that happened during changing the route lifecycle, i.e. such as when an exception was thrown during starting the route.
RouteError.Phase
RouteFactory	A factory to create Route
RouteIdAware	Marker for an object whose owning route id can be injected.
RoutePolicy	Per-route lifecycle hook that receives callbacks at each state change and at the beginning and end of every Exchange, enabling dynamic control of route behaviour at runtime.
RoutePolicyFactory	Factory that creates a RoutePolicy instance for each route automatically at startup, without requiring the policy to be declared per-route in the DSL.
RoutesBuilderLoader	SPI that loads RoutesBuilder instances from a Resource identified by file extension.
RoutesLoader	SPI for loading RoutesBuilder from a list of Resource.
RouteStartupOrder	Captures the resolved startup order and associated services for a Route, used by CamelContext and ShutdownStrategy to control start and shutdown sequencing.
RouteTemplateLoaderListener	Listener when route templates is loaded from a Resource.
RouteTemplateParameterSource	Source for parameters used when creating routes from route templates.
RouteTopologyDumper	SPI that analyses the active Camel routes and computes a graph describing how they interconnect through shared endpoints.
RouteTopologyDumper.TopologyEdge	An edge in the topology representing a connection between two routes via a shared endpoint.
RouteTopologyDumper.TopologyExternalEndpoint	An external endpoint representing a remote system that a route communicates with.
RouteTopologyDumper.TopologyNode	A node in the topology representing a route.
RouteTopologyDumper.TopologyResult	The result of computing route topology.
RuntimeEndpointRegistry	A registry which listen for runtime usage of Endpoint during routing in Camel.
RuntimeEndpointRegistry.Statistic	Statistics gathered about the endpoint.
ScheduledPollConsumerScheduler	Pluggable scheduler that controls when a invalid reference org.apache.camel.support.ScheduledPollConsumer wakes up to poll its source.
ScriptingLanguage	Represents a Language which is a general purpose scripting languages such as groovy, joor and others.
SendDynamicAware	Used for components that can optimise the usage of invalid reference org.apache.camel.processor.SendDynamicProcessor (toD) to reuse a static Endpoint and Producer that supports using headers to provide the dynamic parts.
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.
SharedInternalProcessor	A Shared (thread safe) internal Processor that Camel routing engine used during routing for cross cutting functionality such as: Execute UnitOfWork Keeping track which route currently is being routed Execute RoutePolicy Gather JMX performance statics Tracing Debugging Message History Stream Caching Transformer ... and more.
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 strategy that performs the actual graceful shutdown sequence when a CamelContext is stopping.
SimpleExecutorService	Marker interface to signal that a ExecutorService is simple and tasks are either only submitted via ExecutorService.submit(Runnable) or executed via Executor.execute(Runnable) methods.
SimpleFunction	A custom simple language function This allows to plugin custom functions to the built-in simple language.
SimpleFunctionRegistry	Registry for custom simple functions.
SimpleLanguageFunctionFactory	A factory for extending the simple language with functions from external components.
StartupCondition	Pluggable gate evaluated repeatedly before CamelContext finishes starting, allowing startup to be paused until an external prerequisite is satisfied.
StartupConditionStrategy	Strategy that runs StartupCondition checks during startup to decide whether Camel may start, optionally waiting until the conditions are satisfied.
StartupStepRecorder	Records named StartupStep spans during CamelContext startup to capture timing and diagnostic information for troubleshooting and performance analysis.
StateRepository<K,V>	This StateRepository holds a set of key/value pairs for defining a particular state of a component.
StepIdAware	Marker for an object whose owning step id can be injected.
StreamCachingStrategy	Strategy that controls when and how stream-based message bodies (such as InputStream) are buffered so they can be re-read, as described in the Stream Caching documentation.
StreamCachingStrategy.SpoolRule	Rule for determine if stream caching should be spooled to disk or kept in-memory.
StreamCachingStrategy.SpoolUsedHeapMemoryLimit	Used for selecting if the memory limit is committed or maximum heap memory setting.
StreamCachingStrategy.Statistics	Utilization statistics of stream caching.
SupervisingRouteController	Extension of RouteController that adds resilient, backoff-based startup supervision for routes, as described in the Route Controller documentation.
Synchronization	Provides a hook for custom Processor or Component instances to respond to completed or failed processing of an Exchange rather like Spring's org.springframework.transaction.support.TransactionSynchronization
SynchronizationRouteAware	An extension to Synchronization which provides route awareness capabilities.
SynchronizationVetoable	A vetoable Synchronization.
SyntheticBacklogTracer	Extended BacklogTracer API for components that process exchanges inline and bypass the normal route pipeline (e.g. mock mode in the rest-openapi consumer).
ThreadPoolFactory	Low-level SPI for constructing ExecutorService and ScheduledExecutorService instances from a ThreadPoolProfile and a ThreadFactory.
ThreadPoolProfile	A named, reusable configuration template for ThreadPoolExecutor settings managed by the ExecutorServiceManager.
Tokenizer	An interface for tokenizing text data.
Tokenizer.Configuration	A nested interface representing the configuration options for this tokenizer.
Tracer	SPI for intercepting Exchange flow at each EIP node in a route for tracing and debugging purposes.
TransactedPolicy	A marker for defining the policy to be used for applying transaction to routes.
Transformer	Performs message body transformation between two DataTypes as part of Camel's Transformer contract mechanism.
TransformerKey	Composite lookup key for the TransformerRegistry, encoding a from-DataType / to-DataType pair as a single string value for efficient map-based lookup.
TransformerLoader	A pluggable strategy to load data types into a TransformerRegistry.
TransformerRegistry	Registry that stores and resolves Transformer instances for Camel's data type contract mechanism.
TransformerResolver<K>	Resolves data type transformers from given transformer key.
TypeConverterLoader	Pluggable strategy for discovering and loading invalid reference TypeConverter instances into a TypeConverterRegistry during CamelContext startup.
TypeConverterRegistry	Central registry for all TypeConverter instances available in a Camel type-conversion context.
TypeConverterRegistry.Statistics	Utilization statistics of the registry.
TypeConvertible<F,T>	Holds a type convertible pair.
UnitOfWork	Tracks the lifecycle of a single Exchange as it flows through the routing engine, and provides hooks for Synchronization callbacks and async continuation coordination.
UnitOfWorkFactory	SPI factory that creates a UnitOfWork for each incoming Exchange.
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
UriFactoryResolver	A pluggable strategy for resolving different URI factories in a loosely coupled manner.
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)
UuidGenerator	Generator to generate UUID strings.
Validator	Validates message content against a declared DataType, as described in the Transformer and Validator documentation.
ValidatorKey	Key used in ValidatorRegistry in CamelContext, to ensure a consistent lookup.
ValidatorRegistry	Registry that stores and resolves Validator instances for Camel's data type validation mechanism.
VariableRepository	Repository for storing and accessing variables.
VariableRepositoryFactory	Factory for VariableRepository.
WrapAwareProcessor	An interface to represent an object which wraps a Processor.