Uses of Package
org.apache.camel.spi

Packages that use org.apache.camel.spi

Package	Description
org.apache.camel	The core Camel API.
org.apache.camel.catalog	Runtime catalog API for validating endpoint URIs, configuration properties, and language expressions.
org.apache.camel.cluster	Cluster API for leader election, namespace-based partitioning, and cluster membership management.
org.apache.camel.console	Developer console API for exposing runtime operational information in text and JSON formats.
org.apache.camel.health	Health check API for readiness and liveness monitoring of the CamelContext, routes, and components.
org.apache.camel.spi
org.apache.camel.support.jsse	Configuration classes for Java Secure Socket Extension (JSSE) SSL/TLS setup.

Classes in org.apache.camel.spi used by org.apache.camel

Class	Description
AutoMockInterceptStrategy	Strategy for intercepting messages sent to endpoints in order to auto-mock them during testing.
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.
CamelContextNameStrategy	Strategy for assigning the name of a CamelContext.
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).
DataFormat	Pluggable strategy for converting message bodies to and from a serialised byte-stream format, as described in the Data Format documentation.
DataType	Represents the data type URN which is used for message data type contract.
Debugger	Low-level debugger SPI that fires Breakpoint callbacks as Exchanges move through each route node, as described in the Debugger documentation.
EndpointRegistry	Registry to cache endpoints in memory.
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.
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.
ErrorRegistry	A registry which captures exceptions that occurred during message routing and stores them in memory.
ExchangeFactory	Factory used by Consumer (and PollingConsumer) to create the Exchange that carries an incoming message into Camel.
ExchangeFactoryManager	Manages ExchangeFactory.
ExecutorServiceManager	Strategy to create thread pools.
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.
HasCamelContext	A simple marker interface for an object which holds a CamelContext.
HeadersMapFactory	SPI factory that creates the Map implementation used to store headers on a Message.
InflightRepository	A live registry that tracks every Exchange that is currently being processed within the CamelContext.
Injector	Pluggable strategy for instantiating objects, optionally performing dependency injection as part of creation.
InterceptStrategy	Strategy that wraps the Processors in a route with interceptors, for cross-cutting concerns such as gathering performance statistics at the processor level.
Language	SPI base for every Camel expression and predicate language.
LifecycleStrategy	Observer SPI that receives callbacks for every significant lifecycle event in a CamelContext.
LogListener	An event listener SPI for logging.
ManagementInterceptStrategy	SPI that wraps EIP Processors with instrumentation so that per-exchange statistics can be collected and exposed via JMX MBeans.
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.
ManagementStrategy	Top-level SPI for Camel's management and observability layer, coordinating JMX registration, lifecycle events, and statistics collection across all Camel artifacts.
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
NormalizedEndpointUri	An Uri which has been normalized.
ProcessorExchangeFactory	Factory used by Processor implementations (EIPs) when they create copies of the current Exchange for sub-routing.
PropertiesComponent	SPI for the Camel property-placeholder subsystem, which resolves {{key}} tokens in endpoint URIs, DSL expressions, and configuration values.
PropertyConfigurer	Configures a single property on a target object (such as a Component, Endpoint, or EIP) without using reflection.
ReactiveExecutor	SPI for plugging a custom reactive (non-blocking) dispatch engine into Camel's internal routing loop.
Registry	Represents a BeanRepository which may also be capable of binding beans to its repository.
Resource	Describes a loadable resource such as a file, classpath entry, or HTTP URL.
RestConfiguration	Central configuration bean for the Camel REST DSL, shared by RestConsumerFactory, RestProducerFactory, and RestApiConsumerFactory implementations.
RestRegistry	A live registry of all REST services running within the CamelContext that were defined using the Camel REST DSL.
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.
RouteError	The last error that happened during changing the route lifecycle, i.e. such as when an exception was thrown during starting the route.
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.
RouteStartupOrder	Captures the resolved startup order and associated services for a Route, used by CamelContext and ShutdownStrategy to control start and shutdown sequencing.
RuntimeEndpointRegistry	A registry which listen for runtime usage of Endpoint during routing in Camel.
ShutdownStrategy	Pluggable strategy that performs the actual graceful shutdown sequence when a CamelContext is stopping.
StartupStepRecorder	Records named StartupStep spans during CamelContext startup to capture timing and diagnostic information for troubleshooting and performance analysis.
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.
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
Tracer	SPI for intercepting Exchange flow at each EIP node in a route for tracing and debugging purposes.
Transformer	Performs message body transformation between two DataTypes as part of Camel's Transformer contract mechanism.
TransformerRegistry	Registry that stores and resolves Transformer instances for Camel's data type contract mechanism.
TypeConverterRegistry	Central registry for all TypeConverter instances available in a Camel type-conversion context.
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.
UuidGenerator	Generator to generate UUID strings.
Validator	Validates message content against a declared DataType, as described in the Transformer and Validator documentation.
ValidatorRegistry	Registry that stores and resolves Validator instances for Camel's data type validation mechanism.

Classes in org.apache.camel.spi used by org.apache.camel.catalog

Class	Description
HasCamelContext	A simple marker interface for an object which holds a CamelContext.

Classes in org.apache.camel.spi used by org.apache.camel.cluster

Class	Description
HasCamelContext	A simple marker interface for an object which holds a CamelContext.
HasId	Marker for an object that exposes a unique id, useful for referencing it in REST, JMX, and tooling APIs.
IdAware	Marker for an object whose id can be injected, such as EIP Processors created from Camel routes.

Classes in org.apache.camel.spi used by org.apache.camel.console

Class	Description
HasCamelContext	A simple marker interface for an object which holds a CamelContext.
HasId	Marker for an object that exposes a unique id, useful for referencing it in REST, JMX, and tooling APIs.
IdAware	Marker for an object whose id can be injected, such as EIP Processors created from Camel routes.

Classes in org.apache.camel.spi used by org.apache.camel.health

Class	Description
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.
IdAware	Marker for an object whose id can be injected, such as EIP Processors created from Camel routes.

Classes in org.apache.camel.spi used by org.apache.camel.spi

Class	Description
AggregationRepository	Persistent store for in-progress aggregated Exchange instances, used by the Aggregator EIP.
AsyncProcessorAwaitManager.AwaitThread	Information about the thread and exchange that are inflight.
AsyncProcessorAwaitManager.Statistics	Utilization statistics of this manager.
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.
BeanIntrospection.ClassInfo	Structure of an introspected class.
BeanIntrospection.MethodInfo	Structure of an introspected method.
BeanRepository	Pluggable contract for looking up beans by name or type, forming the foundation of Camel's Registry.
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.BrowseStatus	A quick status of the browse queue
BulkTypeConverters	A source-code-generated, compile-time-optimized bundle of TypeConverter instances for use with the type conversion infrastructure.
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.
CamelContextTracker.Filter	Decides which CamelContext instances a CamelContextTracker is notified about.
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.ExchangeEvent	Event related to Exchange processing.
CamelEvent.ExchangeFailureEvent	Event providing details about how a failure was handled during exchange processing.
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.RouteEvent	Event related to Route lifecycle changes.
CamelEvent.ServiceEvent	Event related to Service lifecycle changes.
CamelEvent.StepEvent	Event related to a Step EIP processing.
CamelEvent.Type
CamelInternalProcessorAdvice	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.
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.
ComponentCustomizer	Strategy for applying custom configuration to Component instances as they are created.
ComponentCustomizer.Builder	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.
Condition	A condition to define when a given Exchange matches when is being routed.
DataFormat	Pluggable strategy for converting message bodies to and from a serialised byte-stream format, as described in the Data Format documentation.
DataFormatCustomizer	Strategy for applying custom configuration to DataFormat instances as they are created.
DataFormatCustomizer.Builder	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.
DataType	Represents the data type URN which is used for message data type contract.
Debugger	Low-level debugger SPI that fires Breakpoint callbacks as Exchanges move through each route node, as described in the Debugger documentation.
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.
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.
ExchangeFactory	Factory used by Consumer (and PollingConsumer) to create the Exchange that carries an incoming message into Camel.
ExchangeFormatter	Strategy for rendering an Exchange as a human-readable String, used primarily for logging and tracing output.
ExecutorServiceManager.ThreadFactoryListener	Listener when a new ThreadFactory is created, which allows to plugin custom behaviour.
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.
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.
IdAware	Marker for an object whose id can be injected, such as EIP Processors created from Camel routes.
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.
InterceptSendToEndpoint	An Endpoint wrapper that, when sent to, detours the exchange: before, send to the original endpoint (which can be skipped), then after (optional).
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.
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	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.
LifecycleStrategy	Observer SPI that receives callbacks for every significant lifecycle event in a CamelContext.
ManagementAgent	Low-level JMX bridge that registers and unregisters Camel managed objects in a MBeanServer.
ManagementInterceptStrategy.InstrumentationProcessor
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.
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.
ModelDumpLine	Represents a line in a model dumper of the route structure (not with full details such as XML or YAML dump).
NormalizedEndpointUri	An Uri which has been normalized.
OAuthClientConfig	Configuration for OAuth 2.0 Client Credentials grant.
OAuthTokenValidationConfig	Configuration for validating incoming OAuth 2.0 bearer tokens.
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.
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.
PackageScanFilter	Predicate applied by PackageScanClassResolver during classpath scanning to determine whether a discovered class should be included in the result set.
Policy	A strategy capable of applying interceptors to a processor.
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.
PooledObjectFactory	Factory for pooled objects or tasks.
PooledObjectFactory.Statistics	Utilization statistics of the this factory.
ProcessorExchangeFactory	Factory used by Processor implementations (EIPs) when they create copies of the current Exchange for sub-routing.
ProducerCache.AsyncProducerCallback	Callback for sending a exchange message to a endpoint using an AsyncProcessor capable producer.
PropertiesFunction	Extension point for the PropertiesComponent that handles property placeholders of the form {{name:remainder}}, where name matches PropertiesFunction.getName().
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.
PropertyConfigurerGetter	Extension of the configurer SPI that, in addition to setting properties, can describe the options a target supports.
ReloadStrategy	SPI strategy for reloading Camel at runtime when a change is detected.
Resource	Describes a loadable resource such as a file, classpath entry, or HTTP URL.
ResourceReload	Listener notified when a Resource is re-loaded at runtime, for example after a route file changes.
RestClientRequestValidator.ValidationContext	Validation context to use during validation
RestClientRequestValidator.ValidationError	Validation error
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
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
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.NodeLabelMode
RouteDiagramDumper.Theme
RouteError.Phase
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.
RoutesBuilderLoader	SPI that loads RoutesBuilder instances from a Resource identified by file extension.
RouteStartupOrder	Captures the resolved startup order and associated services for a Route, used by CamelContext and ShutdownStrategy to control start and shutdown sequencing.
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.Statistic	Statistics gathered about the endpoint.
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.
ShutdownPrepared	Allows a Service to prepare for shutdown.
SimpleFunction	A custom simple language function This allows to plugin custom functions to the built-in simple language.
StartupCondition	Pluggable gate evaluated repeatedly before CamelContext finishes starting, allowing startup to be paused until an external prerequisite is satisfied.
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.
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.Configuration	A nested interface representing the configuration options for this tokenizer.
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.
TransformerRegistry	Registry that stores and resolves Transformer instances for Camel's data type contract mechanism.
TypeConverterRegistry	Central registry for all TypeConverter instances available in a Camel type-conversion context.
TypeConverterRegistry.Statistics	Utilization statistics of the registry.
TypeConvertible	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.
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.
VariableRepository	Repository for storing and accessing variables.

Classes in org.apache.camel.spi used by org.apache.camel.support.jsse

Class	Description
HasCamelContext	A simple marker interface for an object which holds a CamelContext.