All Classes and Interfaces
Class
Description
To perform optional initialization on an element after its properties has been configured.
Persistent store for in-progress aggregated
Exchange instances, used by the
Aggregator EIP.A strategy for aggregating two exchanges together into a single exchange.
KeyManager to select a key with desired alias while delegating processing to specified KeyManager Can be used both
with server and client sockets
Thrown when an operation is attempted on a
Service that has already been stopped and therefore cannot service
the call.Factory to create
Processor for annotation based EIPs.A
TypeConverter which is capable of annotation scanning for
Converter classes and add these as type converters.Marker interface indicating that an
Endpoint belongs to an API-based component, where the endpoint URI
encodes an API name and method name rather than a plain scheme and path.Represents an API method as part of a parent API.
Used for annotating a
UriParam parameter that its for use by API based endpoints.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.
Indicates that the Camel string/expression should be used as an endpoint uri.
Indicates that the Camel language/expression should be used as predicate.
The callback interface for an
AsyncProcessor so that it can notify you when an Exchange is done.Marker interface indicating that the
Endpoint's consumer and producer support asynchronous, non-blocking
routing.An asynchronous processor which can process an
Exchange in an asynchronous fashion and signal
completion by invoking the AsyncCallback.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.Information about the thread and exchange that are inflight.
Utilization statistics of this manager.
A marker for defining the policy to be used for applying authorization to routes.
Strategy for intercepting messages sent to endpoints in order to auto-mock them during testing.
Marker interface for
LifecycleStrategy that are used for auto-wiring components, data formats and languages.Configuration for access to AWS Secret.
Configuration for access to Azure Key Vault.
Represents an error event captured by the
ErrorRegistry.Base interface for backlog event messages that capture exchange snapshots at a point in time, without retaining
references to the live
Exchange.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.
Snapshot of a single exchange event captured by the
BacklogTracer as a message transits a route node.SPI factory for creating
BackOffTimer instances used to schedule retry or
back-off tasks.A useful base class which ensures that a service is only initialized once and provides some helper methods for
enquiring of its status.
Represents configuration options that can be applied in the client-side or server-side context depending on what they
are applied to.
Configures a
T based on the related configuration options.Makes a decorated
SSLContext appear as a normal SSLContext.Class needed to provide decoration of an existing
SSLContext.A decorator that enables the application of configuration options to be applied to created sockets even after
this factory has been created and turned over to client code.
A decorator that enables the application of configuration options to be applied to created sockets even after
this factory has been created and turned over to client code.
Marks a field, method, constructor, or parameter as an injection point for a configuration bean.
Marks a field, method, constructor, or parameter as an injection point for a bean obtained from the Camel
Registry.Low-level SPI for reading and writing bean properties via Java reflection, used internally by Camel's property
binding infrastructure.
Structure of an introspected class.
Structure of an introspected method.
Factory for creating a
Processor that invokes a method on a bean with full support for
Camel bean parameter bindings.Pluggable contract for looking up beans by name or type, forming the foundation of Camel's
Registry.
Defines the scope for bean lookups in the
Registry.A predicate which evaluates a binary expression.
Used for binding a bean to the registry.
Marks a method parameter as the payload of the inbound
Message when Camel performs
bean binding.Marker for a service (or other process) that is only needed while Camel is bootstrapping.
State of the breakpoint as either active or suspended.
An optional interface an
Endpoint may choose to implement which allows it to expose a way of browsing the
exchanges available.A quick status of the browse queue
A
VariableRepository that can browse the variables.Generic builder contract for objects that are assembled in multiple steps before being produced.
A source-code-generated, compile-time-optimized bundle of
TypeConverter instances for use with the
type conversion infrastructure.Used to identify objects that can cache their resume state or data
The cache fill policy can be used to determine how this cache should be filled with data.
An exception thrown for either authentication or authorization errors occurring in a Camel exchange.
Processes beans as they are created or registered, applying Camel's annotation-based dependency injection.
Pluggable injector that participates in
CamelBeanPostProcessor bean post-processing to support custom,
typically 3rd-party, dependency-injection annotations.Marker interface for cluster events
Represents a cluster service providing distributed operations such as leader election and view-based namespace
partitioning.
Represents the View of the cluster at some given period of time.
Configuration class for Camel applications.
The CamelContext is the runtime container of an
Apache Camel application: it owns the registries of
s,
Components, Endpoints, Routes,
invalid reference
org.apache.camel.spi.TypeConverterLanguages, DataFormats and the
configuration that governs how Exchanges flow between them.Marker for objects that wish to receive the owning
CamelContext.Strategy for applying custom configuration to a
CamelContext after it has been created.Lifecycle API for
CamelContext: the methods used to start, stop, suspend and resume a Camel runtime.Strategy for assigning the name of a
CamelContext.Tracks the creation and destruction of
CamelContext instances across the JVM.Decides which
CamelContext instances a CamelContextTracker is notified about.Factory that creates the task carrying out a Camel dependency-injection annotation, such as binding a
BindToRegistry bean into the Registry.Base interface for all Camel events used by the
EventNotifier for notifications about
Exchange, Route, CamelContext, and
Service lifecycle changes.Event related to
CamelContext lifecycle changes.Fired when the CamelContext has been initialized.
Fired when the CamelContext is initializing.
Fired when the CamelContext has been reloaded.
Fired when the CamelContext failed to reload.
Fired when the CamelContext is reloading.
Fired when the CamelContext has been resumed.
Fired when the CamelContext failed to resume.
Fired when the CamelContext is resuming.
Fired when routes have been started.
Fired when routes are starting.
Fired when routes have been stopped.
Fired when routes are stopping.
Fired when the CamelContext has been fully started.
Fired when the CamelContext is starting.
Fired when the CamelContext failed to start.
Fired when the CamelContext failed to stop cleanly.
Fired when the CamelContext has been stopped.
Fired when the CamelContext is stopping.
Fired when the CamelContext has been suspended.
Fired when the CamelContext is suspending.
Deprecated.
Fired when an exchange has been completed successfully.
Fired when a new exchange has been created.
Event related to
Exchange processing.Fired when an exchange has failed.
Event providing details about how a failure was handled during exchange processing.
Fired after a failure has been handled by an error handler.
Fired when a failure is about to be handled by an error handler.
Fired when an exchange is about to be redelivered.
Fired when an exchange is about to be sent to an endpoint.
Fired when an exchange has been sent to an endpoint.
This interface is implemented by all events that contain an exception and is used to retrieve the exception in a
universal way.
Fired when a route has been added.
Event related to
Route lifecycle changes.Fired when a route has been removed.
Fired when a route has been started.
Fired when a route is starting.
Fired when a route has been stopped.
Fired when a route is stopping.
Event related to
Service lifecycle changes.Fired when a service failed to start.
Fired when a service failed to stop.
Fired when a Step EIP has completed processing an exchange.
Event related to a Step EIP processing.
Fired when a Step EIP has failed processing an exchange.
Fired when a Step EIP has started processing an exchange.
Base class for all Camel checked exceptions, typically thrown from a
Processor or other lifecycle step
that already declares throws Exception.A
CamelException that carries the Exchange whose processing triggered the failure.Exception occurred during execution/processing of an
Exchange.An advice (before and after) to execute cross-cutting functionality in the Camel routing engine.
Common Langchain4j Attributes shared by multiple components
A configurable SLF4J logger wrapper that carries a
LoggingLevel and an optional SLF4J Marker.SPI that plugs a Mapped Diagnostic Context (MDC) propagation implementation into Camel's exchange processing
pipeline.
A Camel metrics service is a factory for micrometer metrics.
A
CamelPreemptiveClusterView is a CamelClusterView that can be externally disabled by another
controller.A Camel tracing service is a factory for telemetry tracers.
A
UnitOfWork failed with a number of caused exceptions.Catalog-level extension of
CamelContext that exposes the JSON schema metadata Camel publishes for the
Components, DataFormats, Languages and EIPs available at runtime.This enum set various categories options into the UriEndpoint.
Channel acts as a channel between
Processors in the route graph.Represents a list of TLS/SSL cipher suite names.
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.
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).
SPI that exposes a Camel integration to the Camel CLI for local inspection and control.
SPI factory for creating a
CliConnector that enables Camel CLI management of a live integration.Represents the options for the client authentication settings of a server socket.
A clock abstraction used to track pass of time
Deprecated.
Allows to plugin custom post-processors that are processed after the DSL has loaded the source and compiled into a
Java object.
Allows to plugin custom pre-processors that are processed before the DSL has loaded the source and compiled into a
Java object.
Strategy for runtime compiled languages and DSLs.
Strategy for applying custom configuration to
Component instances as they are created.A fluent builder to create a
ComponentCustomizer instance.Used as additional filer mechanism to control if customizers need to be applied or not.
Deprecated.
Discovers the names of all
Component implementations available on the classpath at runtime.Pluggable strategy for autoloading a
Component instance from a URI scheme the first time
that scheme is encountered by a CamelContext.Deprecated.
The result of a verification
Status of the verification
The scope defines how the parameters should be verified.
This interface represents a detailed error in case when the verification fails.
Interface defining an attribute which is a key for the detailed error messages.
Interface defining an error code.
Attributes for details about an exception that was raised
Group related details
HTTP related error details
Standard set of error codes
A condition to define when a given
Exchange matches when is being routed.Marks the class as a
CamelConfiguration class.Details result of validating configuration properties (eg application.properties for camel-main).
Marks a class as a candidate for build-time code generation of a
PropertyConfigurer implementation by the
camel-package-maven-plugin.Pluggable strategy for resolving a
PropertyConfigurer by the name of the target type (for example
timer-component or timer-endpoint).Utility class for managing the lifecycle of bootstrap-phase
PropertyConfigurer instances generated for
@Configurer(bootstrap = true) types.Internal annotation to mark a class as having constant fields for the source code generator.
Cache containing created
PollingConsumer.An interface for listening to consumer events and allow proxying between a consumer predicate and the Camel
component.
An interface to represent an object which wishes to support listening for consumer events using the
ConsumerListener.Represents an object that can have an associated content type.
An event clock that tracks the pass of time for different types of context-related events (see
ContextEvents)Lifecycle events of a
CamelContext that can be timestamped via an EventClock.SPI strategy for reloading a running
CamelContext in place.Service Provider Interface (SPI) for discovering and loading
ContextServicePlugin implementations during
CamelContext initialization.A plugin interface that allows third-party components to perform initialization tasks when a CamelContext is being
configured and started.
An annotation used to mark classes and methods to indicate code capable of converting from a type to another type
which are then auto-discovered using the Type Conversion
Support
Configuration for access to CyberArk Conjur Vault.
Pluggable strategy for converting message bodies to and from a serialised byte-stream format, as described in the
Data Format documentation.
Special accessor for a DataFormat
Strategy for applying custom configuration to
DataFormat instances as they are created.A fluent builder to create a
DataFormatCustomizer instance.Used as additional filer mechanism to control if customizers need to be applied or not.
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.Marker interface that exposes the canonical name of a
DataFormat implementation, enabling runtime lookup and
catalog introspection without depending on the concrete class.SPI strategy for resolving a
DataFormat implementation by name.Represents the data type URN which is used for message data type contract.
Marks a
Transformer implementation as a data type transformer, identified by its name and/or its from/to
DataTypes.Low-level debugger SPI that fires
Breakpoint callbacks as Exchanges move through each route node, as
described in the Debugger documentation.Factory for creating
Debugger.Used to indicate that if the target type is
CamelContextAware, the context does not need to be mandatory
injected during bean post processing but can be injected later on as example during Camel Context configuration.Factory to create services such as
Producers and defer starting the created service, until
CamelContext has been started.Strategy notified when a 3rd-party dependency is detected while loading routes.
Developer Console
Marks a class as a custom developer console.
A registry for dev console.
A pluggable strategy for resolving dev consoles in a loosely coupled manner
State for whether a processor or service is disabled.
Marks a field in a Camel model Definition class as a primary argument for the Java DSL method call.
Internal annotation used to include fields otherwise excluded because annotate with XmlTransient.
Strategy for dumping routes during startup dump all loaded routes (incl rests and route templates).
A
PollingConsumer used by the dynamic poll and pollEnrich EIPs, allowing the component to use
data from the current Exchange (such as headers or properties) to parameterise the poll operation at runtime.Indicates that this method is to be used as a Dynamic
Router routing the incoming message through a series of processing steps.
Information about embedded HTTP server such as when using the camel-platform-http component, that integrates with the
Spring Boot or Quarkus HTTP server.
An endpoint implements the
Message Endpoint pattern and represents an endpoint that
can send and receive message exchanges
Implemented by objects that can be resolved to a consumer-facing
Endpoint.Implemented by objects that can be resolved to a producer-facing
Endpoint.Registry to cache endpoints in memory.
Used for getting information about location to (hosted or external) network services.
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.Details about the endpoint service
Endpoint strategy with callback invoked when an
Endpoint is about to be registered to the
endpoint registry in CamelContext.Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.
Details result of validating endpoint uri.
Marker interface identifying a
Processor as an error-handling wrapper, as described in the
Error Handler documentation.An interface for
Processor aware of its ErrorHandler which are wrapped via the
Channel during route initialization, or specially used by
RecipientList EIP annotation.Factory that creates and configures an error handler
for a
Route.Customizer for
ErrorHandler which supports redeliveries.A registry which captures exceptions that occurred during message routing and stores them in memory.
A scoped view over error entries in an
ErrorRegistry, supporting browsing and clearing.A specialized clock that tracks the pass of time for one or more types of events
Factory that mints concrete
CamelEvent instances for every significant lifecycle and messaging event in the
Camel runtime.Observer that receives
CamelEvent notifications fired by the Camel runtime.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.Generated by camel build tools - do NOT edit this file!
Marks a parameter as being the exception set on an exchange
Internal extension surface of
Exchange exposing methods and APIs not intended for Camel end users, but used
inside Camel for optimization, SPI integration, custom component development, and advanced use cases.Factory used by
Consumer (and PollingConsumer) to create the Exchange that
carries an incoming message into Camel.Manages
ExchangeFactory.The message exchange pattern of an
Exchange, indicating whether the caller expects a reply.Marks a method parameter as the entire exchange-property map of the current
Exchange when Camel performs
bean binding.Marks a method parameter as a named exchange property when Camel performs
bean binding.
Typed enum of the well-known
Exchange property keys used by camel-core.An exception thrown if an InOut exchange times out receiving the OUT message
Strategy to create thread pools.
Listener when a new
ThreadFactory is created, which allows to plugin custom behaviour.Thrown if the body could not be converted to the required type
An experimental user-facing API.
An expression provides a plugin strategy for evaluating
expressions on a message exchange.
An exception thrown if evaluation of the expression failed.
Deferred factory for creating an
Expression within a CamelContext.When an instance is aware of
ExpressionFactory.An exception thrown if the expression contains illegal syntax.
Represents an
Expression or Predicate that supports a result type.Internal extension surface of
CamelContext: methods and SPI hooks that custom components, data formats,
languages, route policies and tooling may need, but that are not part of the end-user facing API.Extends
PropertyConfigurerGetter with the ability to enumerate every option a target supports.An extended
RoutesBuilderLoader that is capable of loading from multiple resources in one unit (such as
compiling them together).A
StartupListener variant whose callback is guaranteed to fire exactly once, after all route consumers are
fully started and the CamelContext is considered completely running.Annotation to be used for JAXB property (field or method) annotated with
@XmlAnyElement to highlight which
actual elements do we expect (not to be enforced by JAXB, but by Camel itself).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.Factory for creating and caching
FactoryFinder instances, each scoped to a specific resource-path prefix on
the classpath.Thrown when Camel cannot build a
Route from a RoutesBuilder or route model, for example because an
Endpoint cannot be resolved, a referenced bean or processor is missing, or DSL validation fails.Thrown when the
CamelContext fails to instantiate a Route from a route template definition, for
example because a required template parameter is missing or the generated route is invalid.Thrown when a
Component fails to start as part of the CamelContext startup sequence.Thrown when a previously built
Route fails to start as part of the CamelContext startup or a
RouteController startRoute call.Represents a set of regular expression based filter patterns for including and excluding content of some type.
An immutable collection of compiled includes and excludes filter
Patterns.Configuration for access to GCP Secret Manager.
Marker for a
PropertyConfigurer that Camel generates at build time for fast configuration of components and
endpoints.Global endpoint configurations which can be set as defaults when Camel creates new
Endpoints.A global
Supplier of SSLContextParameters to be used in Camel registry.To let camel-groovy pre-compile script files during bootstrap.
Marker for an object whose group can be injected.
Marks a method on a bean as the preferred handler for
bean binding.
A simple marker interface for an object which holds a
CamelContext.Marker for an object that belongs to a named group, useful for group-related operations such as clustering and JMX
APIs.
An interface to represent an object which provides
HealthCheckConfiguration for access to Hashicorp Vault Secrets.
Marker for an object that exposes a unique id, useful for referencing it in REST, JMX, and tooling APIs.
Marks a method parameter as a named header from the inbound
Message when Camel performs
bean binding.Interface to allow pluggable implementation to filter headers to and from Camel message.
The direction is either IN or OUT.
An interface to represent an object which can make use of injected
HeaderFilterStrategy.Marks a method parameter as the entire header map of the inbound
Message when Camel performs
bean binding.Health check
Marks a class as a custom health-check or health-check repository.
Response to a health check invocation.
An interface to represent an object which wishes to be injected with the
HealthCheckHelper for invoking
HealthCheck's.A registry for health checks.
A repository for health checks.
A pluggable strategy for resolving health checks in a loosely coupled manner
A builder helper to create a
HealthCheck result.A strategy that allows SPI to process
HealthCheck results and enrich and manipulate the result.To use for identifying
Consumer which can host a service, such as a TCP network server, or
an embedded HTTP server.Represents an object which is aware of HTTP responses.
Configuration for access to IBM Secrets Manager Vault Secrets.
Marker for an object whose id can be injected, such as EIP
Processors created from Camel
routes.Persistent store of message identifiers that implements the
Idempotent Consumer pattern, ensuring each
message is processed at most once.
A live registry that tracks every
Exchange that is currently being processed within the
CamelContext.Information about the inflight exchange.
Marks a class as a Service that can be used by Camel CLI infra
The marked class is analyzed by the mojo CamelTestInfraGenerateMetadataMojo
Pluggable strategy for instantiating objects, optionally performing dependency injection as part of creation.
Marks methods as being
ExchangePattern.InOnly for one way asynchronous invocation when using
Bean Integration to overload the default value which is
ExchangePattern.InOut for request/reply if no annotations are used.Marks a method as being
ExchangePattern.InOut when a class or interface has been annotated with
InOnly when using Bean Integration.Implemented by a
Processor to control whether it may be wrapped by an InterceptStrategy.Factory for creating an
InterceptSendToEndpoint that intercepts messages sent to an Endpoint.An
Endpoint wrapper that, when sent to, detours the exchange: before, send to the original endpoint (which
can be skipped), then after (optional).Strategy that wraps the
Processors in a route with interceptors, for cross-cutting concerns such as gathering
performance statistics at the processor level.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.A factory used internally by Camel to create
Processor and other internal building blocks.Thrown when the body of a
Message cannot be converted to the expected type, for example because the body is
null or its runtime type is incompatible with the requested type.Unchecked variant of
InvalidPayloadException, thrown when the body of a Message cannot be converted
to the expected type.An exception caused when an invalid property name is used on an object
Marks a method as being invoked for a specific header value.
Pluggable strategy for invoking
InvokeOnHeader.Used for defining if a given class is singleton or not.
Pluggable resolver to load JSON schema files for components, data formats, languages etc.
Base class that provides optional integration with core Camel capabilities.
A representation of configuration options for creating and loading
KeyManager instance(s).A representation of configuration options for creating and loading a
KeyStore instance.Configuration for access to Kubernetes Confimaps
Configuration for access to Kubernetes Secrets
SPI base for every Camel expression and predicate language.
Strategy for applying custom configuration to
Language instances as they are created.A fluent builder to create a
LanguageCustomizer instance.Used as additional filer mechanism to control if customizers need to be applied or not.
SPI strategy for resolving a
Language implementation by name in a loosely coupled way.Validation result of parsing a language expression or predicate
Observer SPI that receives callbacks for every significant lifecycle event in a
CamelContext.An entity that can point to a given line number from a source
Resource such as YAML and
XML DSL parsers.A
PropertiesSource whose properties can be loaded all at once during initialization, such as a .properties
file.Represents a failure to open a Properties file at a given URL
Allows a
BeanRepository to temporary have a local repository take precedence, such as when creating route
templates to give more flexibility.Logging severity levels used throughout Camel to control the verbosity of diagnostic output.
An event listener SPI for logging.
Low-level JMX bridge that registers and unregisters Camel managed objects in a
MBeanServer.SPI that wraps EIP
Processors with instrumentation so that per-exchange statistics can be
collected and exposed via JMX MBeans.Assembles a
ModelMBean from a Camel managed object so it can be registered in the
MBeanServer.Controls which Camel objects are registered as JMX MBeans for management and monitoring.
Strategy for computing the full
ObjectName (domain plus all key-value properties) for every Camel artifact
registered in JMX.Strategy that creates the managed wrapper objects Camel registers in JMX for its internal artifacts.
Controls the granularity of JMX performance statistics collected for a running
CamelContext.Top-level SPI for Camel's management and observability layer, coordinating JMX registration, lifecycle events, and
statistics collection across all Camel artifacts.
SPI factory that creates the
ManagementStrategy and its associated LifecycleStrategy for a
CamelContext.A plugin used to mask a log String, for example security information like password or passphrase.
A breadcrumb record that captures the route id and processing node an
Exchange visited at a given point in
time, together with the elapsed processing time at that node.Factory for creating
MessageHistory entries, which together form the audit trail of a single
Exchange as it passes through each node of a route.Strategy for computing the size of message payloads (body and headers) for observation purposes.
Message traits are runtime traits that can be associated with a message (for instance, the redelivery state, a data
type, etc).
Meta data for EIPs, components, data formats and other Camel concepts
For example to associate labels to Camel components
Deprecated.
Mime types known to Camel data types and its transformers.
Factory for intercepting sending to endpoint pattern and sending to mock component.
Represents a line in a model dumper of the route structure (not with full details such as XML or YAML dump).
Factory for parsing modeline when running Camel CLI standalone with DSLs.
Factory to abstract the creation of the Model's jakarta.xml.bind.JAXBContext.
Factory that uses reifiers to build an entity from a given model.
SPI that serialises Camel route model definitions to their Java DSL representation (source code).
SPI for dumping model definitions into textual structure
SPI that serialises Camel route model definitions to their XML DSL representation.
SPI that serialises Camel route model definitions to their YAML DSL representation.
Endpoint can optionally implement this interface to indicate whether or not it supports
multiple consumers.Represents a list of TLS/SSL named groups (also known as elliptic curves or key exchange groups) for use in TLS
handshakes.
Represents an identifiable node in the Camel route model.
Represents a route-level node in the Camel route model, identified by a route id.
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
Supports forward traversal of a directed graph where each step returns a
List of successor nodes of type
T (0 to n nodes per step).Factory to generate unique ids for model nodes.
Thrown by the Camel
FactoryFinder mechanism when no implementation class can be located for a given service
URI.Marker interface that excludes a
Service from JMX management registration.An Uri which has been normalized.
Thrown when a bean cannot be found in the Camel
Registry by name or by type.A runtime exception if a given bean type could not be found in the
RegistryThrown when a routing processor (such as a recipient list or dynamic router) cannot resolve a URI to a known
Endpoint, typically because the required Camel component is missing from the classpath.Thrown when neither a mandatory header nor a mandatory exchange property is available on an
Exchange, and at
least one of them is required for processing to continue.A runtime exception thrown if an attempt is made to resolve an unknown language definition.
Thrown when a mandatory exchange property is not available on an
Exchange.A runtime exception if a given service could not be found in the classpath
An exception caused when a mandatory variable is not available
Allows to be used in combination with NotifyBuilder as external predicate implementations to compute if the
exchange matches.
Thrown when the Camel type-converter registry cannot find a converter capable of transforming a given value to the
requested target type.
Factory for resolving OAuth 2.0 bearer tokens using the client_credentials grant.
Configuration for OAuth 2.0 Client Credentials grant.
Configuration for validating incoming OAuth 2.0 bearer tokens.
Resolves
OAuthTokenValidationConfig instances from Camel OAuth profile properties.Factory for validating incoming OAuth 2.0 bearer tokens (JWT and opaque).
Result of validating an incoming OAuth 2.0 bearer token.
Stable validation failure categories for rejected bearer tokens.
Generic offset without a concrete type
An interface to represent offset keys (addressable for an offset)
Marker interface for event handlers that react to
CamelContext lifecycle phases.Event handler invoked after the
CamelContext has been initialized, before it is started.Event handler invoked while the
CamelContext is initializing, before it is started.Event handler invoked after the
CamelContext has fully started and its routes are running.Event handler invoked while the
CamelContext is starting, before it has fully started.Event handler invoked after the
CamelContext has fully stopped.Event handler invoked while the
CamelContext is stopping, before it has fully stopped.A
Component resolver that are used in EIPs with dynamic behavior such as toD, enrich and others.A specialized
AggregationRepository which also supports optimistic locking.Exception used by an AggregationRepository to indicate that an optimistic update error has
occurred and that the operation should be retried by the caller.Implemented by objects that carry an explicit ordering position within a sorted collection.
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.
Predicate applied by
PackageScanClassResolver during classpath scanning to determine whether a discovered
class should be included in the result set.A resolver that can find resources based on package scanning.
Marks a method as having a specific kind of
ExchangePattern for use with
Bean Integration to overload the default value which is
ExchangePattern.InOut for request/reply if no annotations are used.Finder to find
PeriodicTask tasks.A shared scheduler to run small period tasks, such as updating internal statistics, or for custom components to have
a background task.
A manager for internal plugins.
A strategy capable of applying interceptors to a processor.
Used for components that can optimise the usage of
(poll/pollEnrich)
to reuse a static
invalid reference
org.apache.camel.processor.PollProcessorEndpoint and DynamicPollingConsumer that supports using headers to
provide the dynamic parts.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.Represents a Polling Consumer where the caller polls for
messages when it is ready.
Strategy that allows
Consumers to influence the PollingConsumer.Strategy for a
PollingConsumer when polling an Endpoint.Pooled
Exchange which contains the methods and APIs that are not intended for Camel end users but used
internally by Camel for optimizing memory footprint by reusing exchanges created by Consumers via
ExchangeFactory.Task to execute when the exchange is done.
Factory for pooled objects or tasks.
Utilization statistics of the this factory.
Evaluates a binary predicate on the message exchange.
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.Deferred factory for creating a
Predicate within a CamelContext.When an instance is aware of
PredicateFactory.A processor is used to implement the
Event Driven Consumer and
Message Translator patterns and to process message
exchanges.
A factory to create
.
Processor based on the
invalid reference
definitionCache containing created
Producer.Callback for sending a exchange message to a endpoint using an
AsyncProcessor capable producer.SPI for the Camel property-placeholder subsystem, which resolves
{{key}} tokens in endpoint URIs, DSL
expressions, and configuration values.Extension point for the
PropertiesComponent that handles property placeholders of the form
{{name:remainder}}, where name matches PropertiesFunction.getName().Listener to trigger when the properties component is looking up and found a property.
Listener notified when a
Properties source is re-loaded at runtime, for example after a properties
file changes.Captures how a single
PropertiesComponent property placeholder was resolved, for inspection and tooling.A source of property values for the Camel
PropertiesComponent when resolving property placeholders.Factory for creating the built-in
PropertiesSource implementations used by the PropertiesComponent.Error binding property to a bean.
Implemented by objects that can supply the
PropertyConfigurer for a given bean instance.Extension of the configurer SPI that, in addition to setting properties, can describe the options a target supports.
Used to indicate an injection point of a property
placeholder into a POJO.
Exception indicating a failure while trying to create a proxy of a given type and on a given endpoint
SPI for plugging a custom reactive (non-blocking) dispatch engine into Camel's internal routing loop.
Indicates that this method is to be used as a Dynamic
Recipient List routing the incoming message to one or more endpoints.
A specialized
AggregationRepository which also supports recovery.Some messages can carry redelivery details which might affect routing (i.e; JMS messages).
Represents a
BeanRepository which may also be capable of binding beans to its repository.SPI strategy for reloading Camel at runtime when a change is detected.
A factory for using micrometer with resilience4j circuit breakers
Thrown when the
CamelContext fails to resolve a URI to an Endpoint, for example because the scheme is
unknown, the component is not on the classpath, or the URI contains invalid parameters.Describes a loadable resource such as a file, classpath entry, or HTTP URL.
Implemented by objects that want the
Resource they originate from to be injected into them.SPI for loading a
Resource from a URI.Listener notified when a
Resource is re-loaded at runtime, for example after a route file changes.SPI strategy for reloading
Resources in an already running CamelContext.SPI for resolving a
Resource for a specific URI scheme.SPI that creates the Camel
Consumer responsible for handling incoming HTTP GET requests to
the REST API documentation endpoint.Allows SPI to plugin a
RestApiProcessorFactory that creates the Camel Processor responsible for
servicing and generating the REST API documentation.SPI for setting up XML data format (jacksonXml) for rest-dsl.
SPI that configures a JAXB
DataFormat pair for XML binding in the Camel REST DSL.Used for validating incoming client requests with Camel Rest DSL.
Validation context to use during validation
Validation error
Used for validating incoming client responses with Camel Rest DSL.
Validation context to use during validation
Validation error
Central configuration bean for the Camel REST DSL, shared by
RestConsumerFactory,
RestProducerFactory, and RestApiConsumerFactory implementations.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.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.SPI that creates the Camel
Producer responsible for performing HTTP requests to call a
remote REST service.A live registry of all REST services running within the
CamelContext that were defined using
the Camel REST DSL.Details about the REST service
A factory for
RestRegistry.This provides an interface for resumable objects.
Provides an interface for integrations to run actions during resume
Provides an interface for adapters and other resume-related code to allow them to offer a way to set actions to be
executed during the resume process.
A resume adapter provides the component-specific logic that plugs the more generic strategic with the lower level
requirements of the component being used.
An interface to represent an object which wishes to support resume operations using a
ResumeStrategy.This cache stored the resumed data from a
ResumeStrategy.Defines a strategy for handling resume operations.
A callback that can be executed after the last offset is updated
Basic configuration holder for resume strategies
Provides a basic interface for implementing component-specific configuration builder
Thrown (or explicitly constructed and set on an
Exchange) to signal that the current exchange should be
rolled back by the error handler.A Route defines the processing applied to an inbound
Exchange arriving at a specific Endpoint within a CamelContext.Implemented by objects that wish to receive a reference to the
Route they belong to.Low-level SPI interface for objects that can contribute route configurations to a
CamelContext.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.To dump routes as visual diagrams as PNG images.
The last error that happened during changing the route lifecycle, i.e. such as when an exception was thrown during
starting the route.
A factory to create
RouteMarker for an object whose owning route id can be injected.
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.Factory that creates a
RoutePolicy instance for each route automatically at startup, without requiring the
policy to be declared per-route in the DSL.Low-level SPI interface for objects that can contribute
Routes to a CamelContext.SPI that loads
RoutesBuilder instances from a Resource identified by file extension.SPI for loading
RoutesBuilder from a list of Resource.Captures the resolved startup order and associated services for a
Route, used by
CamelContext and ShutdownStrategy to control start and shutdown sequencing.Contextual environment provided to a route template
while it is being instantiated into a concrete
Route.Used for template beans to supply the local bean the route template should use when creating route(s).
Listener when route templates is loaded from a
Resource.Source for parameters used when creating routes from route templates.
SPI that analyses the active Camel routes and computes a graph describing how they interconnect through shared
endpoints.
An edge in the topology representing a connection between two routes via a shared endpoint.
An external endpoint representing a remote system that a route communicates with.
A node in the topology representing a route.
The result of computing route topology.
Indicates that this method is to be used as a Routing Slip
routing the incoming message through a series of processing steps.
Runtime catalog which limited API needed by components that supports
ComponentVerifierExtension.Base class for all unchecked exceptions thrown by Camel itself.
Cross-cutting runtime configuration options shared by
CamelContext and individual Routes.A registry which listen for runtime usage of
Endpoint during routing in Camel.Statistics gathered about the endpoint.
Unchecked base exception carrying the
Exchange whose processing triggered the failure.Thrown if an expression evaluation fails
Thrown if a message transformation fails
An interface that allows safe copy (deep clone) of property value object when creating copy of Exchange objects.
Pluggable scheduler that controls when a
wakes up to poll its
source.
invalid reference
org.apache.camel.support.ScheduledPollConsumerRepresents a
Language which is a general purpose scripting languages such as groovy, joor and others.Represents a list of TLS/SSL cipher suite names.
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.An interface that represents resumable objects that can be serialized to a medium
Core lifecycle contract for every managed object inside a
CamelContext: build → init → start →
stop → close.A collection of helper methods for working with
Service objects.The current lifecycle state of a
Service (or StatefulService) as it transitions between Initializing,
Started, Suspended and Stopped.A useful base class which ensures that a service is only initialized once and provides some helper methods for
enquiring of its status.
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.A
Service which is capable of being shut down.Allows
Consumer to fine grained control on shutdown which mostly have to cater for in-memory
based components.Allows a
Service to prepare for shutdown.Per-route policy controlling whether the route stops immediately or defers during
graceful shutdown.
Per-consumer policy controlling how many pending tasks are processed before the consumer stops during
graceful shutdown.
Pluggable strategy that performs the actual graceful
shutdown sequence when a
CamelContext is stopping.Represents a list of TLS/SSL signature schemes for use in TLS handshakes.
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.A custom simple language function
This allows to plugin custom functions to the built-in simple language.
Registry for custom simple functions.
A factory for extending the simple language with functions from external components.
Configuration for Spring Cloud Config
Configuration model for client side JSSE options.
Represents
SSLContext configuration options used in instantiating an SSLContext instance.Marker interface for Camel components and endpoints that can consume the context-wide
SSLContextParameters configured on the CamelContext.Pluggable gate evaluated repeatedly before
CamelContext finishes starting, allowing startup
to be paused until an external prerequisite is satisfied.Strategy that runs
StartupCondition checks during startup to decide whether Camel may start, optionally
waiting until the conditions are satisfied.Allows objects to be notified when
CamelContext has almost done all work when starting.Represents a single timed step in the
CamelContext startup sequence, used for diagnostics and performance
profiling.Records named
StartupStep spans during CamelContext startup to capture timing and
diagnostic information for troubleshooting and performance analysis.Controls how much information
CamelContext logs in its startup (and shutdown) summary.A
Service that exposes its current ServiceStatus together with the full lifecycle, including
suspend/resume from SuspendableService and shutdown from ShutdownableService.This
StateRepository holds a set of key/value pairs for defining a particular state of a component.Marker for an
Expression whose value is a compile-time or configuration-time constant.Marker interface indicating that a
Service is a "static" service: a singleton within a CamelContext
that is created once at context startup and shared for the context lifetime.Marker for an object whose owning step id can be injected.
Tagging interface to indicate that a type is capable of caching the underlying data stream.
Thrown when stream caching of a message body fails.
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.Rule for determine if stream caching should be spooled to disk or kept in-memory.
Used for selecting if the memory limit is committed or maximum heap memory setting.
Utilization statistics of stream caching.
Strategy to provide suggestions for unknown endpoint options
Extension of
RouteController that adds resilient, backoff-based startup supervision for routes, as described
in the Route Controller documentation.Marker interface to indicate a custom component has custom implementation for suspending the
SuspendableService service.A
Service which is also capable of suspending and resuming.An extension to
Synchronization which provides route awareness capabilities.A vetoable
Synchronization.Extended
BacklogTracer API for components that process exchanges inline and bypass the normal route pipeline
(e.g. mock mode in the rest-openapi consumer).Low-level SPI for constructing
ExecutorService and
ScheduledExecutorService instances from a ThreadPoolProfile and a
ThreadFactory.A named, reusable configuration template for
ThreadPoolExecutor settings managed by the
ExecutorServiceManager.A map whose entries expire automatically after a configurable period of inactivity.
Callback interface for objects that need to perform work on a recurring internal timer tick.
An interface for tokenizing text data.
A nested interface representing the configuration options for this tokenizer.
Implemented by
Processors that want to expose a human-readable label used by the Camel tracing infrastructure
to identify them in trace output and log messages.SPI for intercepting
Exchange flow at each EIP node in a route for tracing and debugging
purposes.A marker for defining the policy to be used for applying transaction to routes.
Performs message body transformation between two
DataTypes as part of Camel's
Transformer contract mechanism.Composite lookup key for the
TransformerRegistry, encoding a from-DataType / to-DataType pair
as a single string value for efficient map-based lookup.A pluggable strategy to load data types into a
TransformerRegistry.Registry that stores and resolves
Transformer instances for Camel's
data type contract mechanism.Resolves data type transformers from given transformer key.
A TrustManager that accepts all X509 certificates without any validation.
Unchecked exception thrown when a type converter is found but fails to convert a value to the required type.
Pluggable strategy for converting objects to different
types such as String, InputStream/OutputStream, Reader/Writer, Document, byte[], and ByteBuffer.
Policy controlling what happens when a
TypeConverterRegistry receives a request to
register a type converter whose from-to type pair
is already registered.Exception when failing to add type converters due there is already an existing type converter.
Pluggable strategy for discovering and loading
instances into a
invalid reference
TypeConverterTypeConverterRegistry
during CamelContext startup.Exception when failing to load type converters.
Central registry for all
TypeConverter instances available in a
Camel type-conversion context.Utilization statistics of the registry.
Marker interface indicating that a class contains type
converter methods annotated with
Converter.Holds a type convertible pair.
Tracks the lifecycle of a single
Exchange as it flows through the routing engine, and
provides hooks for Synchronization callbacks and async continuation coordination.SPI factory that creates a
UnitOfWork for each incoming Exchange.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
A pluggable strategy for resolving different URI factories in a loosely coupled manner.
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
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.
Represents an injection point of a Camel Uri path value (the remaining part of a Camel URI without any query
arguments)
Generator to generate UUID strings.
Base class for all validation exceptions, such as
, so that callers can catch all
validation failures in a single handler irrespective of the particular validation technology used.
invalid reference
org.apache.camel.support.processor.validation.SchemaValidationExceptionValidates message content against a declared
DataType, as described in the
Transformer and Validator documentation.Key used in
ValidatorRegistry in CamelContext, to ensure a consistent lookup.Registry that stores and resolves
Validator instances for Camel's
data type validation mechanism.Holder object for a given value.
Marks a method parameter as a named variable when Camel
performs bean binding.
Implemented by objects that carry a variables store.
Repository for storing and accessing variables.
Factory for
VariableRepository.Marks a method parameter as the entire variables map of
the current
Exchange when Camel performs bean
binding.Base configuration for access to Vaults.
Thrown by a
LifecycleStrategy to abort the startup of a CamelContext.Represent the kinds of options for wait for tasks to complete.
An interface to represent an object which wraps a
Processor.Abstraction over a file-like object consumed by a file-oriented
Consumer (such as camel-file, camel-ftp, or
camel-sftp), providing uniform access to the underlying file handle, its content, and its length.A
HealthCheckRepository that supports adding and removing health checks at runtime.