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.
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
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
BaseSelectorProducer	A base class for selector-based producers.
BinaryPredicateSupport	A useful base class for Predicate implementations
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.
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.
ClusterServiceHelper
ClusterServiceSelectors
ClusterServiceSelectors.SelectByAttribute
ClusterServiceSelectors.SelectByOrder
ClusterServiceSelectors.SelectByType
ClusterServiceSelectors.SelectFirst
ClusterServiceSelectors.SelectSingle
ComponentVerifierException
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.
DefaultDataFormat	A default dataformat useful for implementation inheritance.
DefaultEndpoint	A default endpoint useful for implementation inheritance.
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
DefaultExchangeHolder	Holder object for sending an exchange over a remote wire as a serialized object.
DefaultHeaderFilterStrategy	The default header filtering strategy.
DefaultLRUCacheFactory	Default LRUCacheFactory which uses a LinkedHashMap.
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
DefaultProducer	A default implementation of Producer for implementation inheritance.
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	Default ScheduledBatchPollingConsumer.
DefaultThreadPoolFactory	Factory for thread pools that uses the JDK Executors for creating the thread pools.
DefaultTimeoutMap<K,V>	Default implementation of the TimeoutMap.
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 which can be useful for implementation inheritance when writing an Policy
EmptyAsyncCallback	An empty AsyncCallback which allows to share the same instance instead of creating a new instance for each message.
EndpointHelper	Some helper methods for working with Endpoint instances
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
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
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
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.
LoggingExceptionHandler	A default implementation of ExceptionHandler which uses a CamelLogger to log the exception.
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
NoSuchOptionException
NotificationSenderAdapter	Can be used to broadcast JMX notifications.
ObjectHelper	A number of useful helper methods for working with Objects
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	Utility dedicated for resolving runtime information related to the platform on which Camel is currently running.
PollingConsumerSupport	A useful base class for implementations of PollingConsumer
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.
PropertiesInterceptor	Intercepts Property values used to invoke API Method.
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
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.
ReactiveHelper	Deprecated.
ReaderCache	A StreamCache for String Readers
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.
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.
RoutePolicySupport	A base class for developing custom RoutePolicy implementations.
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
ScheduledPollEndpoint	A base class for Endpoint which creates a ScheduledPollConsumer
ScriptHelper
SimpleRegistry	A Map-based registry.
SimpleTypeConverter	Another base class for TypeConverter implementations.
SimpleTypeConverter.ConversionMethod
SimpleUuidGenerator	This implementation uses a counter which increments by one.
StreamCacheConverter	A set of Converter methods for wrapping stream-based messages in a StreamCache implementation to ensure message re-readability (eg multicasting, retrying)
StreamCacheConverterLoader	Generated by camel build tools - do NOT edit this file!
SynchronizationAdapter	Simple Synchronization adapter with empty methods for easier overriding of single methods.
SynchronousDelegateProducer	To process the delegated producer in synchronous mode.
ThroughputLogger	A logger for logging message throughput.
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.
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.