All Classes

Class	Description
AbstractApiComponent<E extends Enum<E> & ApiName,T,S extends ApiCollection<E,T>>	Abstract base class for API Component Camel Component classes.
AbstractApiConfiguration
AbstractApiConsumer<E extends Enum<E> & ApiName,T>	Abstract base class for API Component Consumers.
AbstractApiEndpoint<E extends ApiName,T>	Abstract base class for API Component Endpoints.
AbstractApiProducer<E extends Enum<E> & ApiName,T>	Base class for API based Producers
AbstractCamelClusterService<T extends org.apache.camel.cluster.CamelClusterView>
AbstractCamelClusterView
AbstractMetaDataExtension
AbstractTaskBuilder<T extends Task>	Provides common logic for task builders
AdapterHelper
AnnotationExpressionFactory	A factory which creates an Expression object from an annotation on a field, property or method parameter of a specified type.
ApiCollection<E extends Enum<E> & ApiName,T>	Base class for a collection of ApiMethods.
ApiConsumerHelper	Utility class for API Consumers.
ApiMethod	Interface for proxy methods.
ApiMethodArg
ApiMethodHelper<T extends Enum<T> & ApiMethod>	Helper class for working with ApiMethod.
ApiMethodHelper.MatchType
ApiMethodImpl	Delegate class for ApiMethod.
ApiMethodParser<T>	Parser base class for generating ApiMethod enumerations.
ApiMethodParser.ApiMethodModel
ApiMethodPropertiesHelper<C>	Helper class to work with ApiMethod arguments to be extended by components.
ApiName	Marker interface for ApiName enumerations.
ArgumentSubstitutionParser<T>	Adds support for parameter name substitutions.
ArgumentSubstitutionParser.Substitution
AsyncCallbackToCompletableFutureAdapter<T>	AsyncCallback that provides a CompletableFuture completed when async action is done
AsyncProcessorConverterHelper	A simple converter that can convert any Processor to an AsyncProcessor.
AsyncProcessorHelper	Helper methods for AsyncProcessor objects.
AsyncProcessorSupport
BackgroundTask	A sleepless blocking task that runs in a Thread the background.
BackgroundTask.BackgroundTaskBuilder	A builder helper for building new background tasks
BackOffStrategy	A back-off strategy is used to configure different strategies for calculating the interval time between iterations
BasicResumeStrategyConfigurationBuilder<T extends BasicResumeStrategyConfigurationBuilder,Y extends org.apache.camel.resume.ResumeStrategyConfiguration>	This class implements the most basic configuration set used by all resume strategy builders
BinaryPredicateSupport	A useful base class for Predicate implementations
BlockingTask	Defines a task that blocks the code execution when ran.
BreakpointSupport	A support class for Breakpoint implementations to use as base class.
BridgeExceptionHandlerToErrorHandler	An ExceptionHandler that uses the DefaultConsumer to process the caused exception to send the message into the Camel routing engine which allows to let the routing engine handle the exception.
Budget	A budget defines how much a task can execute
BudgetBuilder<T extends Budget>	An interface for budget builders
Budgets	Helper builder of budgets
Budgets.TimeBoundedBudgetBuilder	A helper builder of time bounded builders.
ByteArrayInputStreamCache	A StreamCache for ByteArrayInputStream
CachedByteArrayOutputStream	A ByteArrayOutputStream that is capable of returning a InputStreamCache view of the buffer.
CachedOutputStream	This output stream will store the content into a File if the stream context size is exceed the THRESHOLD value.
CamelContextHelper	A number of helper methods
CamelInitialContextFactory	A factory of the Camel InitialContext which allows a Map to be used to create a JNDI context.
CamelLogProcessor	A Processor which just logs to a CamelLogger object which can be used as an exception handler instead of using a dead letter queue.
CamelObjectInputStream
CamelSagaCoordinator	A saga coordinator can be used to register compensator's and take the final decision on the saga: compensate or complete (successfully).
CamelSagaService	A Camel saga service is a factory of saga coordinators.
CamelSagaStep	Defines the configuration of a saga step.
CamelSingletonInitialContextFactory	A factory of the Camel InitialContext which allows a Map to be used to create a JNDI context.
CatalogVerifierCustomizer
ChildServiceSupport	Base class to control lifecycle for a set of child Services.
CipherPair	A class to hold a pair of encryption and decryption ciphers.
ClassicUuidGenerator	The classic (Camel 2.x) UuidGenerator optimized for Camel usage.
ClusterServiceHelper
ClusterServiceSelectors
ClusterServiceSelectors.SelectByAttribute
ClusterServiceSelectors.SelectByOrder
ClusterServiceSelectors.SelectByType
ClusterServiceSelectors.SelectFirst
ClusterServiceSelectors.SelectSingle
ComponentVerifierException
ConstantExpressionAdapter	A helper class for developers wishing to implement an Expression using Java code with a minimum amount of code to write so that the developer only needs to implement one of the ExpressionAdapter.evaluate(Exchange, Class) or ExpressionSupport.evaluate(Exchange) methods.
ConvertBodyProcessor	A processor which converts the payload of the input message to be of the given type
CustomizersSupport
CustomizersSupport.ComponentCustomizationEnabledPolicy	A ComponentCustomizer.Policy that uses a hierarchical lists of properties to determine if customization is enabled for the given Component.
CustomizersSupport.DataFormatCustomizationEnabledPolicy	A DataFormatCustomizer.Policy that uses a hierarchical lists of properties to determine if customization is enabled for the given DataFormat.
CustomizersSupport.LanguageCustomizationEnabledPolicy	A LanguageCustomizer.Policy that uses a hierarchical lists of properties to determine if customization is enabled for the given Language.
DefaultAnnotationExpressionFactory	Default implementation of the AnnotationExpressionFactory.
DefaultAsyncProducer	A default implementation of Producer for implementation inheritance, which can process Exchanges asynchronously.
DefaultComponent	Default component to use for base for components implementations.
DefaultComponentVerifierExtension
DefaultConsumer	A default consumer useful for implementation inheritance.
DefaultConsumerCache	Cache containing created Consumer.
DefaultContextReloadStrategy	Default ContextReloadStrategy.
DefaultDataFormat	A default dataformat useful for implementation inheritance.
DefaultEndpoint	Default Endpoint.
DefaultEndpointUtilizationStatistics
DefaultExchange	The default and only implementation of Exchange.
DefaultExchangeFormatter	Default ExchangeFormatter that have fine grained options to configure what to include in the output.
DefaultExchangeFormatter.OutputStyle
DefaultExchangeFormatterConfigurer	Generated by camel build tools - do NOT edit this file!
DefaultExchangeHolder	Holder object for sending an exchange over a remote wire as a serialized object.
DefaultHeaderFilterStrategy	The default header filtering strategy.
DefaultInterceptSendToEndpoint	This is an endpoint when sending to it, is intercepted and is routed in a detour (before and optionally after).
DefaultLRUCacheFactory	Default LRUCacheFactory which uses a LinkedHashMap based implementation.
DefaultManagementMBeanAssembler	An assembler to assemble a ModelMBean which can be used to register the object in JMX.
DefaultMaskingFormatter	The MaskingFormatter that searches the specified keywords in the source and replace its value with mask string.
DefaultMessage	The default implementation of Message
DefaultMessageHistory	Default MessageHistory.
DefaultMetaData
DefaultPollingConsumerPollStrategy	A default implementation that will not retry on rollback.
DefaultPollingEndpoint	A base class for an endpoint which the default consumer mode is to use a PollingConsumer
DefaultPooledExchange	The default and only implementation of PooledExchange.
DefaultProducer	A default implementation of Producer for implementation inheritance.
DefaultProducerCache	Default implementation of ProducerCache.
DefaultRegistry	The default Registry which supports using a given first-choice repository to lookup the beans, such as Spring, JNDI, OSGi etc.
DefaultResult
DefaultResultVerificationError
DefaultScheduledPollConsumer	A default implementation of an event driven Consumer which uses the PollingConsumer
DefaultScheduledPollConsumerScheduler	The default scheduler for ScheduledPollConsumer.
DefaultStartupStep
DefaultStartupStepRecorder	Default StartupStepRecorder that is always disabled.
DefaultThreadPoolFactory	Factory for thread pools that uses the JDK Executors for creating the thread pools.
DefaultTimeoutMap<K,V>	Default implementation of the TimeoutMap.
DefaultUuidGenerator	Default UuidGenerator (32 chars) optimized for Camel usage.
DeferProducer	A Producer that defers being started, until CamelContext has been started, this ensures that the producer is able to adapt to changes that may otherwise occur during starting CamelContext.
DelegateAsyncProcessor	A Delegate pattern which delegates processing to a nested AsyncProcessor which can be useful for implementation inheritance when writing an Policy
DelegateProcessor	A Delegate pattern which delegates processing to a nested Processor which can be useful for implementation inheritance when writing an Policy
DelegateSyncProcessor	A delegate pattern which delegates synchronous processing to a nested Processor.
EmptyAsyncCallback	An empty AsyncCallback which allows to share the same instance instead of creating a new instance for each message.
EmptyProducerCache
EndpointHelper	Some helper methods for working with Endpoint instances
EndpointUriFactorySupport	Base class used by Camel Package Maven Plugin when it generates source code for fast endpoint uri factory via EndpointUriFactory.
EventDrivenPollingConsumer	A default implementation of the PollingConsumer which uses the normal asynchronous consumer mechanism along with a BlockingQueue to allow the caller to pull messages on demand.
EventHelper	Helper for easily sending event notifications in a single line of code
EventNotifierSupport	Base class to extend for custom EventNotifier implementations.
ExchangeHelper	Some helper methods for working with Exchange objects
ExpressionAdapter	A helper class for developers wishing to implement an Expression using Java code with a minimum amount of code to write so that the developer only needs to implement one of the ExpressionAdapter.evaluate(org.apache.camel.Exchange, Class) or ExpressionSupport.evaluate(org.apache.camel.Exchange) methods.
ExpressionBuilder	A helper class for working with expressions.
ExpressionComparator	An implementation of Comparator that takes an Expression which is evaluated on each exchange to be compared
ExpressionListComparator	An implementation of Comparator which takes a list of Expression objects which is evaluated on each exchange to compare them
ExpressionSupport	A useful base class for Predicate and Expression implementations
ExpressionToPredicateAdapter	To adapt Expression as a Predicate
FileIdempotentRepository	A file based implementation of IdempotentRepository.
FileInputStreamCache	A StreamCache for Files
FileWatcherResourceReloadStrategy	A file based ResourceReloadStrategy which watches a file folder for modified files and reload on file changes.
FixedBackOffStrategy	A back-off strategy with constant rate
ForegroundTask	Runs a task in the foreground, executing for a given number of iteration and sleeping between each of them.
ForegroundTask.ForegroundTaskBuilder	A builder helper for building new foreground tasks
GroupIterator	Group based Iterator which groups the given Iterator a number of times and then return a combined response as a List.
GroupTokenIterator	Group based Iterator which groups the given Iterator a number of times and then return a combined response as a String.
GZIPHelper	Helper class to help wrapping content into GZIP input and output streams.
HeaderFilterStrategyComponent	Base class for components to support configuring a HeaderFilterStrategy.
HeaderSelectorProducer	A selector-based producer which uses a header value to determine which processor should be invoked.
IllegalOptionException
InMemorySagaCoordinator	A in-memory implementation of a saga coordinator.
InMemorySagaService	An in-memory implementation of a saga service.
InputStreamCache	A StreamCache for caching using an in-memory byte array.
InputStreamIterator	An InputStream that wraps an Iterator which reads iterations as byte array data.
IntrospectionSupport	Deprecated. use BeanIntrospection
IterationBoundedBudget	This task budget limits the execution by a given number of iterations or an unlimited number if configured to do so.
IterationBoundedBudgetBuilder	A helper builder of iteration bounded builders.
IterationBudget	A budget that limits the task execution to a given number of iterations
IterationTimeBoundedBudget	This task budget limits the execution by both a given number of iterations or a maximum amount of time for the execution.
IterationTimeBoundedBudgetBuilder	A helper builder of iteration and time bounded builders.
JndiBeanRepository	A BeanRepository implementation which looks up the objects in JNDI
JndiContext	A default JNDI context
LanguageAnnotation	Base annotation for languages.
LanguageSupport	Base language for Language implementations.
LazyStartProducer	A Producer which is created and started lazy, on the first message processed.
LifecycleStrategySupport	A useful base class for LifecycleStrategy implementations.
LocalBeanRegistry	A special registry which is used for local beans.
LoggerHelper	Helper for logging purposes.
LoggingExceptionHandler	A default implementation of ExceptionHandler which uses a CamelLogger to log the exception.
LoggingStartupStepRecorder	Logging StartupStepRecorder that outputs to log.
LRUCache<K,V>
LRUCacheFactory	Factory to create LRUCache instances.
MarshalProcessor	Marshals the body of the incoming message using the given data format
MBeanInfoAssembler	A Camel specific MBeanInfo assembler that reads the details from the ManagedResource, ManagedAttribute, ManagedOperation, ManagedNotification, and ManagedNotifications annotations.
MemoryIdempotentRepository	A memory based implementation of IdempotentRepository.
MessageHelper	Some helper methods when working with Message.
MessageSupport	A base class for implementation inheritance providing the core Message body handling features but letting the derived class deal with headers.
MetaDataBuilder
MixinRequiredModelMBean	A RequiredModelMBean which allows us to intercept invoking operations on the MBean.
NamespacePrefix	Creates a namespace prefix for an XPath
Namespaces	A helper class for working with namespaces.
NoLock	Empty lock implementation
NormalizedUri	Implementation of NormalizedEndpointUri.
NoSuchOptionException
NotificationSenderAdapter	Can be used to broadcast JMX notifications.
ObjectHelper	A number of useful helper methods for working with Objects
OffsetKeys	Utility class for handling offset keys
Offsets	Offset handling support
OffUuidGenerator	UuidGenerator which is turned off for exchange ids, but generated UUIDs for everything else.
OptionsGroup	A named group of options.
OrderedComparator	A comparator to sort Ordered
OutputStreamBuilder	Utility to hide the complexity of choosing which OutputStream implementation to choose.
PatternHelper
PlatformHelper	Deprecated.
PollingConsumerServicePool	PollingConsumer pool.
PollingConsumerSupport	A useful base class for implementations of PollingConsumer
PooledObjectFactorySupport<T>	Base class for building PooledObjectFactory based factories.
PredicateAssertHelper	A helper for doing Predicate assertions.
PredicateBuilder	A helper class for working with predicates
PredicateToExpressionAdapter	To adapt Predicate as an Expression
PredicateValidatingProcessor	A processor which validates the content of the inbound message body against a Predicate.
PredicateValidationException	A predicate validation exception occurred
ProcessorEndpoint	An endpoint which allows exchanges to be sent into it which just invokes a given Processor.
ProcessorPollingConsumer	A simple implementation of PollingConsumer which just uses a Processor.
ProducerServicePool	Producer pool.
PropertiesInterceptor	Intercepts Property values used to invoke API Method.
PropertyBindingListener	Listener when using Camel property binding (org.apache.camel.support.PropertyBinding).
PropertyBindingSupport	A convenient support class for binding String valued properties to an instance which uses a set of conventions: property placeholders - Keys and values using Camels property placeholder will be resolved nested - Properties can be nested using the dot syntax (OGNL and builder pattern using with as prefix), eg foo.bar=123 map - Properties can lookup in Map's using map syntax, eg foo[bar] where foo is the name of the property that is a Map instance, and bar is the name of the key. list - Properties can refer or add to in List's using list syntax, eg foo[0] where foo is the name of the property that is a List instance, and 0 is the index.
PropertyBindingSupport.Builder	To use a fluent builder style to configure this property binding support.
PropertyBindingSupport.OnAutowiring
PropertyConfigurerHelper	Helper class for dealing with configurers.
PropertyConfigurerSupport	Base class used by Camel Package Maven Plugin when it generates source code for fast property configurations via PropertyConfigurer.
PropertyNamesInterceptor	Intercepts Property names used to find methods.
PrototypeObjectFactorySupport<T>	PooledObjectFactory that creates a new instance (does not pool).
ReaderCache	A StreamCache for String Readers
RebalancingCamelClusterService	A RebalancingCamelClusterService adds rebalancing capabilities to an underlying CamelPreemptiveClusterService.
ResolverHelper	Some helper methods for new resolvers (like ComponentResolver, DataFormatResolver, etc.).
ResolverHelper.LookupExceptionHandler
ResourceEndpoint	A useful base class for endpoints which depend on a resource such as things like Velocity or XQuery based components.
ResourceHelper	Helper class for loading resources on the classpath or file system.
ResourceReloadStrategySupport	Base class for implementing custom ResourceReloadStrategy SPI plugins.
ResourceResolverSupport	Base class for ResourceResolver implementations.
ResourceSupport	Base class for Resource implementations.
RestComponentHelper	Helper class for rest-dsl components.
RestConsumerContextPathMatcher	A context path matcher when using rest-dsl that allows components to reuse the same matching logic.
RestConsumerContextPathMatcher.ConsumerPath<T>	Consumer path details which must be implemented and provided by the components.
RestProducerFactoryHelper	Helper for creating configured Components used by the RestProducerFactory contract.
ResultBuilder
ResultErrorBuilder
ResultErrorHelper	Helper that validates component parameters.
ResultInterceptor	Intercepts API method invocation result Exchange.
Resumables	A wrapper for resumable entities
ResumeActionAwareAdapter	A simple resume adapter that support caching, deserialization and actions.
ResumeStrategyHelper	Helper class for the resume strategy
RoutePolicySupport	A base class for developing custom RoutePolicy implementations.
RoutesBuilderLoaderSupport	Base class for RoutesBuilderLoader implementations.
RouteTemplateHelper	Helper for working with route templates.
RouteWatcherReloadStrategy	Watcher strategy for triggering reloading of Camel routes in a running Camel application.
ScheduledBatchPollingConsumer	A useful base class for any consumer which is polling batch based
ScheduledPollConsumer	A useful base class for any consumer which is polling based
ScheduledPollConsumerHealthCheck	HealthCheck that uses the last polling state from ScheduledPollConsumer when reporting the health.
ScheduledPollEndpoint	A base class for Endpoint which creates a ScheduledPollConsumer
ScriptHelper
SendDynamicAwareSupport	Support class for SendDynamicAware implementations.
ShortUuidGenerator	UuidGenerator that is 50% the size of the default (16 chars) optimized for Camel usage.
SimpleEventNotifierSupport	Base class to extend for custom EventNotifier implementations.
SimpleRegistry	A Map-based registry.
SimpleTypeConverter	Another base class for TypeConverter implementations.
SimpleTypeConverter.ConversionMethod
SimpleUuidGenerator	This implementation uses a counter which increments by one.
SingleInputLanguageSupport	Base class for Language implementations that support different sources of input data.
SingleInputTypedLanguageSupport	Base class for Language implementations that support a result type and different sources of input data.
StreamCacheBulkConverterLoader	Generated by camel build tools - do NOT edit this file!
StreamCacheConverter	A set of Converter methods for wrapping stream-based messages in a StreamCache implementation to ensure message re-readability (eg multicasting, retrying)
SupplierRegistry	Used for storing beans that are supplied via a Supplier.
SynchronizationAdapter	Simple Synchronization adapter with empty methods for easier overriding of single methods.
SynchronousDelegateProducer	To process the delegated producer in synchronous mode.
Task	A task defines a piece of code that may be executed - in the foreground or background - within a certain budget that is specific to the task type.
TaskBuilder<T extends Task>	Provides a common pattern for building tasks
Tasks	A helper class for building tasks
ThrottlingExceptionHalfOpenHandler	Used by the ThrottlingExceptionRoutePolicy to allow custom code to handle the half open circuit state and how to determine if a route should be closed
ThrottlingExceptionRoutePolicy	Modeled after the circuit breaker ThrottlingInflightRoutePolicy this RoutePolicy will stop consuming from an endpoint based on the type of exceptions that are thrown and the threshold setting.
ThrottlingInflightRoutePolicy	A throttle based RoutePolicy which is capable of dynamic throttling a route based on number of current inflight exchanges.
ThrottlingInflightRoutePolicy.ThrottlingScope
ThroughputLogger	A logger for logging message throughput.
TimeBoundedBudget	This task budget limits the execution by both a maximum amount of time for the execution.
TimeBudget	Defines a budget that limits the task execution to certain length of time
TimeoutMapEntry<K,V>	Represents an entry in a TimeoutMap
TimerListenerManager	A TimerListener manager which triggers the TimerListener listeners once every second.
TokenPairExpressionIterator	Expression to walk a Message body using an Iterator, which grabs the content between a start and end token.
TokenXMLExpressionIterator	Expression to walk a Message XML body using an Iterator, which grabs the content between a XML start and end token, where the end token corresponds implicitly to either the end tag or the self-closing start tag.
TypeConverterSupport	Base class for TypeConverter implementations.
TypedLanguageSupport	Base class for Language implementations that support a result type.
TypedProcessorFactory<T extends org.apache.camel.NamedNode>
UnitOfWorkHelper	Utility methods for UnitOfWork
UnmarshalProcessor	Unmarshals the body of the incoming message using the given data format
ValueBuilder	A builder of expressions or predicates based on values.
VanillaUuidGenerator	Deprecated. this is now the default uuid generator in Camel 3.6 onwards.