Package org.apache.camel

@NullMarked package org.apache.camel

The core Camel API.

Related Packages

Package	Description
org.apache.camel.ai
org.apache.camel.catalog	Runtime catalog API for validating endpoint URIs, configuration properties, and language expressions.
org.apache.camel.clock
org.apache.camel.cloudevents
org.apache.camel.cluster	Cluster API for leader election, namespace-based partitioning, and cluster membership management.
org.apache.camel.console	Developer console API for exposing runtime operational information in text and JSON formats.
org.apache.camel.health	Health check API for readiness and liveness monitoring of the CamelContext, routes, and components.
org.apache.camel.resume	Resume strategy API for offset-based message consumption, allowing consumers to resume processing from a previously saved position.
org.apache.camel.spi
org.apache.camel.vault	Configuration classes for accessing external secret vaults such as AWS Secrets Manager, GCP Secret Manager, Azure Key Vault, and HashiCorp Vault.

Class	Description
AfterPropertiesConfigured	To perform optional initialization on an element after its properties has been configured.
AggregationStrategy	A strategy for aggregating two exchanges together into a single exchange.
AlreadyStoppedException	Thrown when an operation is attempted on a Service that has already been stopped and therefore cannot service the call.
ApiEndpoint	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.
AsyncCallback	The callback interface for an AsyncProcessor so that it can notify you when an Exchange is done.
AsyncEndpoint	Marker interface indicating that the Endpoint's consumer and producer support asynchronous, non-blocking routing.
AsyncProcessor	An asynchronous processor which can process an Exchange in an asynchronous fashion and signal completion by invoking the AsyncCallback.
AsyncProducer	A Producer that can dispatch an Exchange to an Endpoint without blocking the calling thread.
BatchConsumer	A Consumer that receives messages from an Endpoint in discrete batches rather than one at a time.
BeanConfigInject	Marks a field, method, constructor, or parameter as an injection point for a configuration bean.
BeanInject	Marks a field, method, constructor, or parameter as an injection point for a bean obtained from the Camel Registry.
BeanScope	Defines the scope for bean lookups in the Registry.
BinaryPredicate	A predicate which evaluates a binary expression.
BindToRegistry	Used for binding a bean to the registry.
Body	Marks a method parameter as the payload of the inbound Message when Camel performs bean binding.
Builder<T>	Generic builder contract for objects that are assembled in multiple steps before being produced.
CamelAuthorizationException	An exception thrown for either authentication or authorization errors occurring in a Camel exchange.
CamelConfiguration	Configuration class for Camel applications.
CamelContext	The CamelContext is the runtime container of an Apache Camel application: it owns the registries of Components, Endpoints, Routes, invalid reference org.apache.camel.spi.TypeConverter s, Languages, DataFormats and the configuration that governs how Exchanges flow between them.
CamelContextAware	Marker for objects that wish to receive the owning CamelContext.
CamelContextLifecycle	Lifecycle API for CamelContext: the methods used to start, stop, suspend and resume a Camel runtime.
CamelException	Base class for all Camel checked exceptions, typically thrown from a Processor or other lifecycle step that already declares throws Exception.
CamelExchangeException	A CamelException that carries the Exchange whose processing triggered the failure.
CamelExecutionException	Exception occurred during execution/processing of an Exchange.
CamelUnitOfWorkException	A UnitOfWork failed with a number of caused exceptions.
CatalogCamelContext	Catalog-level extension of CamelContext that exposes the JSON schema metadata Camel publishes for the Components, DataFormats, Languages and EIPs available at runtime.
Category	This enum set various categories options into the UriEndpoint.
Channel	Channel acts as a channel between Processors in the route graph.
Component	A component is a factory of Endpoint objects.
ComponentAware	Implemented by objects, such as Endpoint, that are associated with and can expose their parent Component.
Configuration	Marks the class as a CamelConfiguration class.
Consume	Subscribes a method to an Endpoint either via its URI or via the name of the endpoint reference which is then resolved in a registry such as the Spring Application Context.
Consumer	A service that receives messages from an Endpoint and routes them as Exchanges through the Camel processing pipeline.
ConsumerTemplate	Template for working with Camel and consuming Message instances in an Exchange from an Endpoint.
ContextEvents	Lifecycle events of a CamelContext that can be timestamped via an EventClock.
Converter	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
DeferredContextBinding	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.
DelegateEndpoint	An Endpoint that delegates all operations to another underlying Endpoint, following the Decorator pattern.
DelegateProcessor	A Processor that wraps another Processor and delegates Exchange processing to it, following the Decorator pattern.
DisabledAware	State for whether a processor or service is disabled.
DynamicPollingConsumer	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.
DynamicRouter	Indicates that this method is to be used as a Dynamic Router routing the incoming message through a series of processing steps.
Endpoint	An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges
EndpointAware	Implemented by objects that are associated with a specific Endpoint, such as a Producer sending to an endpoint or a Consumer reading from one.
EndpointConsumerResolver	Implemented by objects that can be resolved to a consumer-facing Endpoint.
EndpointInject	Used to indicate an injection point of an Endpoint, Producer or ProducerTemplate into a POJO.
EndpointProducerResolver	Implemented by objects that can be resolved to a producer-facing Endpoint.
EndpointSending	Marker interface for Processor implementations that send an Exchange to an Endpoint as part of their processing.
ErrorHandlerFactory	Factory that creates and configures an error handler for a Route.
Exchange	An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer.
ExchangeConstantProvider	Generated by camel build tools - do NOT edit this file!
ExchangeException	Marks a parameter as being the exception set on an exchange
ExchangeExtension	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.
ExchangePattern	The message exchange pattern of an Exchange, indicating whether the caller expects a reply.
ExchangeProperties	Marks a method parameter as the entire exchange-property map of the current Exchange when Camel performs bean binding.
ExchangeProperty	Marks a method parameter as a named exchange property when Camel performs bean binding.
ExchangePropertyKey	Typed enum of the well-known Exchange property keys used by camel-core.
ExchangeTimedOutException	An exception thrown if an InOut exchange times out receiving the OUT message
ExpectedBodyTypeException	Thrown if the body could not be converted to the required type
Experimental	An experimental user-facing API.
Expression	An expression provides a plugin strategy for evaluating expressions on a message exchange.
ExpressionEvaluationException	An exception thrown if evaluation of the expression failed.
ExpressionFactory	Deferred factory for creating an Expression within a CamelContext.
ExpressionIllegalSyntaxException	An exception thrown if the expression contains illegal syntax.
ExtendedCamelContext	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.
ExtendedStartupListener	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.
FailedToCreateConsumerException	Thrown when an Endpoint cannot produce a Consumer, for example because the endpoint URI is not consumer-capable, required options are missing, or an underlying client connection cannot be opened.
FailedToCreateProducerException	Thrown when an Endpoint cannot produce a Producer, for example because the endpoint URI is not producer-capable, required options are missing, or an underlying client connection cannot be opened.
FailedToCreateRouteException	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.
FailedToCreateRouteFromTemplateException	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.
FailedToStartComponentException	Thrown when a Component fails to start as part of the CamelContext startup sequence.
FailedToStartRouteException	Thrown when a previously built Route fails to start as part of the CamelContext startup or a RouteController startRoute call.
FluentProducerTemplate	Template for working with Camel and sending Message instances in an Exchange to an Endpoint using a fluent build style.
GlobalEndpointConfiguration	Global endpoint configurations which can be set as defaults when Camel creates new Endpoints.
Handler	Marks a method on a bean as the preferred handler for bean binding.
Header	Marks a method parameter as a named header from the inbound Message when Camel performs bean binding.
Headers	Marks a method parameter as the entire header map of the inbound Message when Camel performs bean binding.
InOnly	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.
InOut	Marks a method as being ExchangePattern.InOut when a class or interface has been annotated with InOnly when using Bean Integration.
InvalidPayloadException	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.
InvalidPayloadRuntimeException	Unchecked variant of InvalidPayloadException, thrown when the body of a Message cannot be converted to the expected type.
InvalidPropertyException	An exception caused when an invalid property name is used on an object
IsSingleton	Used for defining if a given class is singleton or not.
LineNumberAware	An entity that can point to a given line number from a source Resource such as YAML and XML DSL parsers.
LoadPropertiesException	Represents a failure to open a Properties file at a given URL
LoggingLevel	Logging severity levels used throughout Camel to control the verbosity of diagnostic output.
ManagementMBeansLevel	Controls which Camel objects are registered as JMX MBeans for management and monitoring.
ManagementStatisticsLevel	Controls the granularity of JMX performance statistics collected for a running CamelContext.
Message	Implements the Message pattern and represents an inbound or outbound message as part of an Exchange.
MessageHistory	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.
MultipleConsumersSupport	Endpoint can optionally implement this interface to indicate whether or not it supports multiple consumers.
NamedNode	Represents an identifiable node in the Camel route model.
NamedRoute	Represents a route-level node in the Camel route model, identified by a route id.
Navigate<T>	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).
NoFactoryAvailableException	Thrown by the Camel FactoryFinder mechanism when no implementation class can be located for a given service URI.
NonManagedService	Marker interface that excludes a Service from JMX management registration.
NoSuchBeanException	Thrown when a bean cannot be found in the Camel Registry by name or by type.
NoSuchBeanTypeException	A runtime exception if a given bean type could not be found in the Registry
NoSuchEndpointException	Thrown 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.
NoSuchHeaderException	Thrown when a mandatory header is not available on the Message of an Exchange.
NoSuchHeaderOrPropertyException	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.
NoSuchLanguageException	A runtime exception thrown if an attempt is made to resolve an unknown language definition.
NoSuchPropertyException	Thrown when a mandatory exchange property is not available on an Exchange.
NoSuchServiceException	A runtime exception if a given service could not be found in the classpath
NoSuchVariableException	An exception caused when a mandatory variable is not available
NoTypeConversionAvailableException	Thrown when the Camel type-converter registry cannot find a converter capable of transforming a given value to the requested target type.
Ordered	Implemented by objects that carry an explicit ordering position within a sorted collection.
Pattern	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.
PollingConsumer	Represents a Polling Consumer where the caller polls for messages when it is ready.
PollingConsumerPollingStrategy	Strategy that allows Consumers to influence the PollingConsumer.
PooledExchange	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.
PooledExchange.OnDoneTask	Task to execute when the exchange is done.
Predicate	Evaluates a binary predicate on the message exchange.
PredicateFactory	Deferred factory for creating a Predicate within a CamelContext.
Processor	A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges.
Produce	Marks a field or property as being a producer to an Endpoint either via its URI or via the name of the endpoint reference which is then resolved in a registry such as the Spring Application Context.
Producer	A service that sends Exchanges to an Endpoint.
ProducerTemplate	Template for working with Camel and sending Message instances in an Exchange to an Endpoint.
PropertiesLookupListener	Listener to trigger when the properties component is looking up and found a property.
PropertyBindingException	Error binding property to a bean.
PropertyInject	Used to indicate an injection point of a property placeholder into a POJO.
ProxyInstantiationException	Exception indicating a failure while trying to create a proxy of a given type and on a given endpoint
RecipientList	Indicates that this method is to be used as a Dynamic Recipient List routing the incoming message to one or more endpoints.
ResolveEndpointFailedException	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.
RollbackExchangeException	Thrown (or explicitly constructed and set on an Exchange) to signal that the current exchange should be rolled back by the error handler.
Route	A Route defines the processing applied to an inbound Exchange arriving at a specific Endpoint within a CamelContext.
RouteAware	Implemented by objects that wish to receive a reference to the Route they belong to.
RouteConfigurationsBuilder	Low-level SPI interface for objects that can contribute route configurations to a CamelContext.
RoutesBuilder	Low-level SPI interface for objects that can contribute Routes to a CamelContext.
RouteTemplateContext	Contextual environment provided to a route template while it is being instantiated into a concrete Route.
RouteTemplateContext.BeanSupplier<T>	Used for template beans to supply the local bean the route template should use when creating route(s).
RoutingSlip	Indicates that this method is to be used as a Routing Slip routing the incoming message through a series of processing steps.
RuntimeCamelException	Base class for all unchecked exceptions thrown by Camel itself.
RuntimeConfiguration	Cross-cutting runtime configuration options shared by CamelContext and individual Routes.
RuntimeExchangeException	Unchecked base exception carrying the Exchange whose processing triggered the failure.
RuntimeExpressionException	Thrown if an expression evaluation fails
RuntimeTransformException	Thrown if a message transformation fails
SafeCopyProperty	An interface that allows safe copy (deep clone) of property value object when creating copy of Exchange objects.
Service	Core lifecycle contract for every managed object inside a CamelContext: build → init → start → stop → close.
ServiceStatus	The current lifecycle state of a Service (or StatefulService) as it transitions between Initializing, Started, Suspended and Stopped.
ShutdownableService	A Service which is capable of being shut down.
ShutdownRoute	Per-route policy controlling whether the route stops immediately or defers during graceful shutdown.
ShutdownRunningTask	Per-consumer policy controlling how many pending tasks are processed before the consumer stops during graceful shutdown.
SSLContextParametersAware	Marker interface for Camel components and endpoints that can consume the context-wide SSLContextParameters configured on the CamelContext.
StartupListener	Allows objects to be notified when CamelContext has almost done all work when starting.
StartupStep	Represents a single timed step in the CamelContext startup sequence, used for diagnostics and performance profiling.
StartupSummaryLevel	Controls how much information CamelContext logs in its startup (and shutdown) summary.
StatefulService	A Service that exposes its current ServiceStatus together with the full lifecycle, including suspend/resume from SuspendableService and shutdown from ShutdownableService.
StaticExpression	Marker for an Expression whose value is a compile-time or configuration-time constant.
StaticService	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.
StreamCache	Tagging interface to indicate that a type is capable of caching the underlying data stream.
StreamCacheException	Thrown when stream caching of a message body fails.
Suspendable	Marker interface to indicate a custom component has custom implementation for suspending the SuspendableService service.
SuspendableService	A Service which is also capable of suspending and resuming.
TimeoutMap<K,V>	A map whose entries expire automatically after a configurable period of inactivity.
TimeoutMap.Listener<K,V>
TimeoutMap.Listener.Type
TimerListener	Callback interface for objects that need to perform work on a recurring internal timer tick.
Traceable	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.
TypeConversionException	Unchecked exception thrown when a type converter is found but fails to convert a value to the required type.
TypeConverter	Pluggable strategy for converting objects to different types such as String, InputStream/OutputStream, Reader/Writer, Document, byte[], and ByteBuffer.
TypeConverterExists	Policy controlling what happens when a TypeConverterRegistry receives a request to register a type converter whose from-to type pair is already registered.
TypeConverterExistsException	Exception when failing to add type converters due there is already an existing type converter.
TypeConverterLoaderException	Exception when failing to load type converters.
TypeConverters	Marker interface indicating that a class contains type converter methods annotated with Converter.
ValidationException	Base class for all validation exceptions, such as invalid reference org.apache.camel.support.processor.validation.SchemaValidationException , so that callers can catch all validation failures in a single handler irrespective of the particular validation technology used.
ValueHolder<V>	Holder object for a given value.
Variable	Marks a method parameter as a named variable when Camel performs bean binding.
VariableAware	Implemented by objects that carry a variables store.
Variables	Marks a method parameter as the entire variables map of the current Exchange when Camel performs bean binding.
VetoCamelContextStartException	Thrown by a LifecycleStrategy to abort the startup of a CamelContext.
WaitForTaskToComplete	Represent the kinds of options for wait for tasks to complete.
WrappedFile<T>	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.