All Classes and Interfaces
Class
Description
To perform optional initialization on an element after its properties has been configured.
Access to a repository to store aggregated exchanges to support pluggable implementations.
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
Exception thrown in situations when a
Service has already been stopped.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.Marks the
Endpoint as an endpoint from an API based component.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.Marks the
Endpoint as support asynchronous non-blocking routing in its consumer and producer.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.
Asynchronous producer
A marker for defining the policy to be used for applying authorization to routes.
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.
A
.
Debugger that has easy debugging functionality which can be used from JMX with
invalid reference
org.apache.camel.api.management.mbean.ManagedBacklogDebuggerMBeanBacklog tracer that captures the last N messages during routing in a backlog.
Represents a traced message by the BacklogTracer.
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.
A consumer of a batch of message exchanges from an
EndpointUsed to indicate an injection point of a configuration bean (obtained from the
Registry,
or a new instance is created) into a POJO.Used to indicate an injection point of a bean obtained from the
Registry, into a POJO.Used for introspecting beans properties via Java reflection; such as extracting current property values, or updating
one or more properties etc.
Structure of an introspected class.
Structure of an introspected method.
Factory for creating a
Processor that can invoke a method on a bean and supporting using Camel bean parameter
bindings.A factory for creating a
Proxy for a bean.Represents a bean repository used to lookup components by name and type.
A predicate which evaluates a binary expression.
Used for binding a bean to the registry.
Marks a parameter as being the body of an inbound
MessageA marker interface for a service, or other kind of process that is only used during bootstrapping Camel.
Breakpoint are used by the Debugger API.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.Bulk type converters that often comes out of the box with Apache Camel.
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.
Bean post processor.
Used for custom injection when doing
CamelBeanPostProcessor bean post-processing.Marker interface for cluster events
Represents the View of the cluster at some given period of time.
Configuration class for Camel applications.
Interface used to represent the CamelContext used to configure routes and the policies to use during message
exchanges between endpoints.
An interface to represent an object which wishes to be injected with the
CamelContextTo apply custom configurations to
CamelContext instances.Lifecycle API for
CamelContext.Strategy for assigning name to a
CamelContext.A
CamelContext creation and destruction tracker.A factory which performs the task from Camel dependency injection annotations on a field, property or method
parameter of a specified type.
This interface is implemented by all events.
Special event only in use for camel-tracing / camel-opentelemetry.
This interface is implemented by all events that contain an exception and is used to retrieve the exception in a
universal way.
Base class for all Camel checked exceptions typically thrown by a
ProcessorAn exception caused by a specific message
ExchangeException occurred during execution/processing of an
Exchange.An advice (before and after) to execute cross-cutting functionality in the Camel routing engine.
A logger which logs to a slf4j
Logger.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 interface for the
CamelContextThis 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.
Access to a repository of keys to implement the Claim Check
pattern.
A class resolver for loading classes in a loosly coupled manner to cater for different platforms such as standalone,
Spring Boot, Quarkus, JBang etc.
Local
CliConnector that allows Camel CLI to manage local running Camel integrations.Factory for creating connector to CLI tooling.
Represents the options for the client authentication settings of a server socket.
Allows to plugin custom post processors that are processed after the DSL has loaded the source and compiled into a
Java object.
Strategy for runtime compiled languages and DSLs.
An interface to represent an object which wishes to be injected with a
Component.To apply custom configurations to
Component instances.A fluent builder to create a
ComponentCustomizer instance.Used as additional filer mechanism to control if customizers need to be applied or not.
Marker interface for component extensions.
Discovers which components are available on the classpath.
Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like
invalid reference
org.apache.camel.impl.DefaultComponentResolverDefines the interface used for validating component/endpoint parameters.
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).
An annotation used to mark classes to indicate code capable of configuring its options via a getter/setters that can
be called via Camels
PropertyConfigurer.A pluggable strategy for resolving different configurers in a loosely coupled manner
Strategy for configurers.
Internal annotation to mark a class as having constant fields for the source code generator.
A consumer of message exchanges from an
Endpoint.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.
SPI strategy for reloading
CamelContext.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
Represents a data format used to marshal objects to and from
streams such as Java Serialization or using JAXB2 to encode/decode objects using XML or using SOAP encoding.
Special accessor for a DataFormat
To apply custom configurations to
DataFormat instances.A fluent builder to create a
DataFormatCustomizer instance.Used as additional filer mechanism to control if customizers need to be applied or not.
A factory to create
DataFormat.The name of the
DataFormat which allows to know which kind of data format the
implementation is.Represents a resolver of data formats.
Represents the data type URN which is used for message data type contract.
Annotation to configure a data type transformer with either specifying its name or from/to data types.
A debugger which allows tooling to attach breakpoints which is being invoked when
Exchanges is being routed.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.An interface to represent an
Endpoint which are delegated.Interface to be used for processors that delegate to the real processor
Strategy when 3rd party dependencies are detected during 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
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).
Indicates that this method is to be used as a Dynamic
Router routing the incoming message through a series of processing steps.
An endpoint implements the
Message Endpoint pattern and represents an endpoint that
can send and receive message exchanges
An interface to represent an object that can be resolved as a consumer
EndpointAn interface to represent an object that can be resolved as a producer
EndpointRegistry to cache endpoints in memory.
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.
An interface used to represent an error handler
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 for creating
ErrorHandlers.Customizer for
ErrorHandler which supports redeliveries.Factory to create
events that are emitted when such an event occur.Notifier to send
events.A Strategy pattern for handling exceptions; particularly in asynchronous processes such as consumers.
Generated by camel build tools - do NOT edit this file!
Marks a parameter as being the exception set on an exchange
Manages
ExchangeFactory.A plugin used to turn an
Exchange into a String representation usually to be used for logging or tracing
purposes.Represents the kind of message exchange pattern
Marks a parameter as being an injection point of the exchange properties of an
ExchangeMarks a parameter as being an injection point of a property of an
ExchangeAn enum of common and known keys for exchange properties used by camel-core.
An exception thrown if an InOut exchange times out receiving the OUT message
Strategy to create thread pools.
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.
A factory for creating
ExpressionWhen 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.Extended
CamelContext which contains the methods and APIs that are not primary intended for Camel end users
but for SPI, custom components, or more advanced used-cases with Camel.A marker interface to identify the object as being a configurer which can provide details about the options the
configurer supports.
An extended
RoutesBuilderLoader that is capable of loading from multiple resources in one unit (such as
compiling them together).Extended
StartupListener that is invoked when the CamelContext is fully started.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).Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.
Represents a resolver for
FactoryFinderThrown if Camel failed to create a consumer for a given endpoint.
Thrown if Camel failed to create a producer for a given endpoint.
Exception when failing to create a
Route.Exception when failing to create a
Route from a RouteTemplateDefinition.Exception when failing to start a
Component.Exception when failing to start a
Route.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.
A auto generated
PropertyConfigurer for fast configuration of Camel components invalid input: '&' 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 allow objects to be injected with an group.
Marks a method on a POJO as being the preferred method to invoke when Camel looks for methods to invoke using the
.
invalid reference
BeanEndpointA simple marker interface for an object which holds a
CamelContext.A simple marker interface for an object which has belongs to a group Group which is useful for group related
operation such as clustering, JMX style API
An interface to represent an object which provides
HealthCheckConfiguration for access to Hashicorp Vault Secrets.
A simple marker interface for an object which has a unique ID which is useful for referring to objects in REST or JMX
style APIs
Marks a parameter as being a header on an inbound
MessageInterface to allow plug-able implementation to filter header 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 parameter as being an injection point of the headers of an inbound
MessageHealth 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.Represents an object which is aware of HTTP responses.
To allow objects to be injected with an id, such as EIP
Processors which has been defined
from Camel routes.Access to a repository of Message IDs to implement the
Idempotent Consumer pattern.
A repository which tracks in flight
Exchanges.Information about the inflight exchange.
A pluggable strategy for creating and possibly dependency injecting objects which could be implemented using straight
forward reflection or using Spring or Quarkus to perform dependency injection.
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.A factory to create
Endpoint which are intercepted.This is an endpoint when sending to it, is intercepted and is routed in a detour, with the following flow: before,
send to original endpoint (can be skipped), after (optional).
The purpose of this interface is to allow an implementation to wrap processors in a route with interceptors.
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
...A factory used internally by Camel to create
Processor and other internal building blocks.Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
Runtime version of the
InvalidPayloadException.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.Represents a language to be used for
Expression or Predicate instancesTo apply custom configurations to
Language instances.A fluent builder to create a
LanguageCustomizer instance.Used as additional filer mechanism to control if customizers need to be applied or not.
A pluggable strategy for resolving different languages in a loosely coupled manner
Validation result of parsing a language expression or predicate
Strategy for lifecycle notifications.
An entity that can point to a given line number from a source
Resource such as YAML and
XML DSL parsers.A source for properties that can be loaded all at once during initialization, such as loading .properties files.
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.Used to configure the logging levels
An event listener SPI for logging.
Camel JMX service agent
A specialized
InterceptStrategy which is used for JMX management for EIPs.An assembler to assemble a
RequiredModelMBean which can be used to register the
object in JMX.Level of mbeans for registration
Strategy for assigning the name part of the
ObjectName for a managed
CamelContext.Strategy for computing
ObjectName names for the various beans that Camel register for management.Strategy for creating the managed object for the various beans Camel register for management.
Level of granularity for performance statistics enabled
Strategy for management.
Service Factory for ManagementStrategy
A plugin used to mask a log String, for example security information like password or passphrase.
Represents the history of a Camel
Message how it was routed by the Camel routing engine.A factory to create
MessageHistory instances.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
Mime types known to Camel data types and its transformers.
Factory for intercepting sending to endpoint pattern and sending to mock component.
Factory for parsing camel-k modeline when running Camel 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 for dumping model definitions into XML representation.
SPI for dumping model definitions into YAML representation.
Endpoint can optionally implement this interface to indicate whether or not it supports
multiple consumers.Represents a node in the
which is identified by an id.
invalid reference
routesRepresents a node in the
which is identified as a route.
invalid reference
routesRepresents 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
Implementations support navigating a graph where you can traverse forward and each next returns a
List of
outputs of type T that can contain 0..n nodes.Factory to generate unique ids for model nodes.
Thrown if no factory resource is available for the given URI
A marker to indicate the
Service should not be registered in JMX for management.An Uri which has been normalized.
A runtime exception if a given bean could not be found in the
RegistryA runtime exception if a given bean type could not be found in the
RegistryA runtime exception thrown if a routing processor such as a recipient list is unable to resolve an
Endpoint
from a URI.An exception caused when a mandatory header is not available on a message
ExchangeA runtime exception thrown if an attempt is made to resolve an unknown language definition.
An exception caused when a mandatory property is not available on a message
ExchangeAllows to be used in combination with NotifyBuilder as external predicate implementations to compute if the
exchange matches.
An exception thrown if a value could not be converted to the required type
Generic offset without a concrete type
An interface to represent offset keys (addressable for an offset)
Marker interface used to make it easy to discover
CamelContext related event handlers from the registry.Notification on an initialized a
CamelContext.Notification on initializing a
CamelContext.Notification on a started
CamelContext.Notification on starting a
CamelContext.Notification on a stopped
CamelContext.Notification on stopping a
CamelContext.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.Interface to be implemented by objects that should be orderable, such as with a
Collection.A resolver that can find classes based on package scanning.
Filter that can be used with the
PackageScanClassResolver resolver.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.
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.A factory for creating
PredicateWhen 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
definitionProvides a channel on which clients can create and invoke message exchanges on an
Endpoint.Cache containing created
Producer.Callback for sending a exchange message to a endpoint using an
AsyncProcessor capable producer.Component for property placeholders and loading properties from sources (such as .properties file from classpath or
file system)
A function that is applied instead of looking up a property placeholder.
Listener to trigger when the properties component is looking up and found a property.
Listener for re-loading a
Properties such as a Camel route.A source for properties.
Factory for creating out of the box
PropertiesSource.Error binding property to a bean.
A marker interface to identify the object as being configurable via a configurer class.
An interface to represent an object which is capable of configuring via
PropertyConfigurer.A marker interface to identify the object as being a configurer which can provide details about the options the
configurer 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 to plugin different reactive engines in the Camel routing engine.
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.Strategy for reifiers.
SPI strategy for reloading.
A runtime exception thrown if an
Endpoint cannot be resolved via URIDescribe a resource, such as a file or class path resource.
An interface to represent an object which wishes to be injected with the
ResourceSPI for loading resources.
Listener for re-loading a
Resource such as a Camel route.SPI strategy for reloading
Resource in an existing running CamelContextSPI for loading resources.
Allows SPI to plugin a
RestApiConsumerFactory that creates the Camel Consumer responsible for
handling incoming HTTP GET requests from clients that request to access the REST API documentation.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 (JAXB) for rest-dsl.
Configuration use by
DSL.
RestConsumerFactory and
RestApiConsumerFactory for Camel components to support the Camel
invalid reference
restAllows 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
RestProducerFactory that creates the Camel Producer responsible for performing
HTTP requests to call a remote REST service.A registry of all REST services running within the
CamelContext which have been defined and
created using the Rest DSL.Details about the REST service
A factory for
RestRegistry.This provides an interface for resumable objects.
Provides and 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
Exception used for forcing an Exchange to be rolled back.
A Route defines the processing used on an inbound message exchange
from a specific
Endpoint within a CamelContext.A route configurations builder is capable of building route configurations using the builder and model classes.
Controller for managing the lifecycle of all the
Route's.The last error that happened during changing the route lifecycle, i.e.
A factory to create
RouteTo allow objects to be injected with the route id
Policy for a
Route which allows controlling the route at runtime.A factory to create
RoutePolicy and assign to routes automatic.A routes builder is capable of building routes using the builder and model classes.
SPI for loading
RoutesBuilder from a Resource.SPI for loading
RoutesBuilder from a list of Resource.Information about a route to be started where we want to control the order in which they are started by
CamelContext.The context used during creating a
Route from a route template.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.
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 Camel unchecked exceptions.
Various runtime configuration options used by
CamelContext and Route for cross
cutting functions such as tracing, delayer, stream cache and the like.A registry which listen for runtime usage of
Endpoint during routing in Camel.Statistics gathered about the endpoint.
A runtime exception caused by a specific message
ExchangeThrown 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.
A pluggable scheduler for
consumers.
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
Represents the core lifecycle API for services which can be initialized, started and stopped
Allows SPIs to implement custom Service Chooser.
An interface to represent an object which wishes to be injected with a
ServiceChooserA factory to create ServiceChooser
Represents a Service.
Allows SPIs to implement custom Service Discovery.
An interface to represent an object which wishes to be injected with a
ServiceDiscoveryA factory to create ServiceDiscovery
A factory to create Expression
Allows SPIs to implement custom Service Filter.
An interface to represent an object which wishes to be injected with a
ServiceFilterA factory to create ServiceFilter
A collection of helper methods for working with
Service objects.Represents a Load Balancer.
A factory to create LoadBalancer
Represents a load balancer function to be executed by the LoadBalancer.
A selector used to pick up a service among a list.
Represents the status of a
Service instanceA 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
...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.Represents the options available when shutting down routes.
Represents the kind of options for what to do with the current task when shutting down.
Pluggable shutdown strategy executed during shutdown of Camel and the active routes.
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.Configuration model for client side JSSE options.
Represents
SSLContext configuration options used in instantiating an SSLContext instance.Indicates that an object is able to use the global
SSLContextParameters if configured.Allows objects to be notified when
CamelContext has almost done all work when starting.Recording state of steps during startup to capture execution time, and being able to emit events to diagnostic tools
such as Java Flight Recorder.
To record
StartupStep during startup to allow to capture diagnostic information to help troubleshoot Camel
applications via various tooling such as Java Flight Recorder.Controls the level of information logged during startup (and shutdown) of
CamelContext.A
Service which has all the lifecycle events and offers details about its current state.This
StateRepository holds a set of key/value pairs for defining a particular state of a component.Marked if the
Expression or Predicate is based from a constant value (ie is static).Marker for indicating the
Service is a static service (only one instance per CamelContext).Tagging interface to indicate that a type is capable of caching the underlying data stream.
Strategy for using stream caching.
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
A supervising capable
RouteController that delays the startup of the routes after the camel context startup
and takes control of starting the routes in a safe manner.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.Provides a hook for custom
Processor or Component instances to
respond to completed or failed processing of an Exchange rather like Spring's
TransactionSynchronizationAn extension to
Synchronization which provides route awareness capabilities.A vetoable
Synchronization.Creates ExecutorService and ScheduledExecutorService objects that work with a thread pool for a given
ThreadPoolProfile and ThreadFactory.
A profile which defines thread pool settings.
Represents a map of values which timeout after a period of inactivity.
Listener for receiving timer events.
Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's
defined in the route model.
SPI for tracing messages.
A marker for defining the policy to be used for applying transaction to routes.
Transformer performs message transformation according to the
declared data type.
A pluggable strategy to load data types into a
TransformerRegistry.Registry to cache transformers in memory.
Resolves data type transformers from given transformer key.
Exception when failing during type conversion.
A pluggable strategy to be able to convert objects to different
types such as to and from String, InputStream/OutputStream, Reader/Writer, Document, byte[], ByteBuffer etc
What to do if attempting to add a duplicate type converter
Exception when failing to add type converters due there is already an existing type converter.
A pluggable strategy to load type converters into a
TypeConverterRegistry from some kind of mechanism.Exception when failing to load type converters.
Registry for type converters.
Utilization statistics of the registry.
A tagging interface to mark this class implements type converters using the
Converter annotations.Holds a type convertible pair.
An object representing the unit of work processing an
Exchange which allows the use of
Synchronization hooks.Factory to create
UnitOfWork.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.
The base class for any validation exception, such as
so that it is easy to treat all validation
errors in a similar way irrespective of the particular validation technology used.
invalid reference
org.apache.camel.processor.validation.SchemaValidationExceptionValidator performs message content validation according to the
declared data type.
Registry to cache validators in memory.
Holder object for a given value.
Base configuration for access to Vaults.
An exception to veto starting
CamelContext.Represent the kinds of options for wait for tasks to complete.
An interface to represent an object which wraps a
Processor.Wraps a file.
An interface to represent an object which wishes to be injected with the
HealthCheck