All Classes Interface Summary Class Summary Enum Summary Exception Summary Annotation Types Summary
Class |
Description |
AfterPropertiesConfigured |
To perform optional initialization on an element after its properties has been configured.
|
AggregationRepository |
Access to a repository to store aggregated exchanges to support pluggable implementations.
|
AggregationStrategy |
A strategy for aggregating two exchanges together into a single exchange.
|
AliasedX509ExtendedKeyManager |
KeyManager to select a key with desired alias while delegating processing to specified KeyManager Can be used both
with server and client sockets
|
AlreadyStoppedException |
Exception thrown in situations when a Service has already been stopped.
|
AnnotationBasedProcessorFactory |
Factory to create Processor for annotation based EIPs.
|
AnnotationScanTypeConverters |
A TypeConverter which is capable of annotation scanning for
Converter classes and add these as type converters.
|
ApiEndpoint |
Marks the Endpoint as an endpoint from an API based component.
|
ApiMethod |
Represents an API method as part of a parent API.
|
ApiParam |
Used for annotating a UriParam parameter that its for use by API based endpoints.
|
ApiParams |
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.
|
AsEndpointUri |
Indicates that the Camel string/expression should be used as an endpoint uri.
|
AsPredicate |
Indicates that the Camel language/expression should be used as predicate.
|
AsyncCallback |
|
AsyncEndpoint |
Marks the Endpoint as support asynchronous non-blocking routing in its consumer and producer.
|
AsyncProcessor |
An asynchronous processor which can process an Exchange in an asynchronous fashion and signal
completion by invoking the AsyncCallback .
|
AsyncProcessorAwaitManager |
A manager to handle async routing engine, when Exchange s 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.
|
AsyncProcessorAwaitManager.AwaitThread |
Information about the thread and exchange that are inflight.
|
AsyncProcessorAwaitManager.Statistics |
Utilization statistics of the this manager.
|
AsyncProducer |
Asynchronous producer
|
AuthorizationPolicy |
A marker for defining the policy to be used for applying authorization to routes.
|
AutowiredLifecycleStrategy |
Marker interface for LifecycleStrategy that are used for auto-wiring components, data formats and languages.
|
AwsVaultConfiguration |
Configuration for access to AWS Secret.
|
AzureVaultConfiguration |
Configuration for access to Azure Key Vault.
|
BaseService |
A useful base class which ensures that a service is only initialized once and provides some helper methods for
enquiring of its status.
|
BaseSSLContextParameters |
Represents configuration options that can be applied in the client-side or server-side context depending on what they
are applied to.
|
BaseSSLContextParameters.SSLContextDecorator |
Makes a decorated SSLContext appear as a normal SSLContext .
|
BaseSSLContextParameters.SSLContextSpiDecorator |
Class needed to provide decoration of an existing SSLContext .
|
BaseSSLContextParameters.SSLServerSocketFactoryDecorator |
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.
|
BaseSSLContextParameters.SSLSocketFactoryDecorator |
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.
|
BatchConsumer |
A consumer of a batch of message exchanges from an Endpoint
|
BeanConfigInject |
Used to indicate an injection point of a configuration bean (obtained from the Registry ,
or a new instance is created) into a POJO.
|
BeanInject |
Used to indicate an injection point of a bean obtained from the Registry , into a POJO.
|
BeanIntrospection |
Used for introspecting beans properties via Java reflection; such as extracting current property values, or updating
one or more properties etc.
|
BeanIntrospection.ClassInfo |
Structure of an introspected class.
|
BeanIntrospection.MethodInfo |
Structure of an introspected method.
|
BeanProcessorFactory |
Factory for creating a Processor that can invoke a method on a bean and supporting using Camel bean parameter
bindings.
|
BeanProxyFactory |
A factory for creating a Proxy for a bean.
|
BeanRepository |
Represents a bean repository used to lookup components by name and type.
|
BeanScope |
|
BinaryPredicate |
A predicate which evaluates a binary expression.
|
BindToRegistry |
Used for binding a bean to the registry.
|
Body |
Marks a parameter as being the body of an inbound Message
|
BootstrapCloseable |
A marker interface for a service, or other kind of process that is only used during bootstrapping Camel.
|
Breakpoint |
|
Breakpoint.State |
State of the breakpoint as either active or suspended.
|
BrowsableEndpoint |
An optional interface an Endpoint may choose to implement which allows it to expose a way of browsing the
exchanges available.
|
Builder<T> |
|
BulkTypeConverters |
Bulk type converters that often comes out of the box with Apache Camel.
|
Cacheable |
Used to identify objects that can cache their resume state or data
|
Cacheable.FillPolicy |
The cache fill policy can be used to determine how this cache should be filled with data.
|
CamelAuthorizationException |
An exception thrown for either authentication or authorization errors occurring in a Camel exchange.
|
CamelBeanPostProcessor |
Bean post processor.
|
CamelBeanPostProcessorInjector |
|
CamelClusterEventListener |
Marker interface for cluster events
|
CamelClusterEventListener.Leadership |
|
CamelClusterEventListener.Membership |
|
CamelClusterMember |
|
CamelClusterService |
|
CamelClusterService.Selector |
|
CamelClusterView |
Represents the View of the cluster at some given period of time.
|
CamelConfiguration |
Configuration class for Camel applications.
|
CamelContext |
Interface used to represent the CamelContext used to configure routes and the policies to use during message
exchanges between endpoints.
|
CamelContextAware |
An interface to represent an object which wishes to be injected with the CamelContext
|
CamelContextCustomizer |
|
CamelContextLifecycle |
|
CamelContextNameStrategy |
|
CamelContextTracker |
|
CamelContextTracker.Filter |
|
CamelDependencyInjectionAnnotationFactory |
A factory which performs the task from Camel dependency injection annotations on a field, property or method
parameter of a specified type.
|
CamelEvent |
This interface is implemented by all events.
|
CamelEvent.CamelContextEvent |
|
CamelEvent.CamelContextInitializedEvent |
|
CamelEvent.CamelContextInitializingEvent |
|
CamelEvent.CamelContextResumedEvent |
|
CamelEvent.CamelContextResumeFailureEvent |
|
CamelEvent.CamelContextResumingEvent |
|
CamelEvent.CamelContextRoutesStartedEvent |
|
CamelEvent.CamelContextRoutesStartingEvent |
|
CamelEvent.CamelContextRoutesStoppedEvent |
|
CamelEvent.CamelContextRoutesStoppingEvent |
|
CamelEvent.CamelContextStartedEvent |
|
CamelEvent.CamelContextStartingEvent |
|
CamelEvent.CamelContextStartupFailureEvent |
|
CamelEvent.CamelContextStopFailureEvent |
|
CamelEvent.CamelContextStoppedEvent |
|
CamelEvent.CamelContextStoppingEvent |
|
CamelEvent.CamelContextSuspendedEvent |
|
CamelEvent.CamelContextSuspendingEvent |
|
CamelEvent.ExchangeCompletedEvent |
|
CamelEvent.ExchangeCreatedEvent |
|
CamelEvent.ExchangeEvent |
|
CamelEvent.ExchangeFailedEvent |
|
CamelEvent.ExchangeFailureEvent |
|
CamelEvent.ExchangeFailureHandledEvent |
|
CamelEvent.ExchangeFailureHandlingEvent |
|
CamelEvent.ExchangeRedeliveryEvent |
|
CamelEvent.ExchangeSendingEvent |
|
CamelEvent.ExchangeSentEvent |
|
CamelEvent.FailureEvent |
This interface is implemented by all events that contain an exception and is used to retrieve the exception in a
universal way.
|
CamelEvent.RouteAddedEvent |
|
CamelEvent.RouteEvent |
|
CamelEvent.RouteReloadedEvent |
|
CamelEvent.RouteRemovedEvent |
|
CamelEvent.RouteStartedEvent |
|
CamelEvent.RouteStartingEvent |
|
CamelEvent.RouteStoppedEvent |
|
CamelEvent.RouteStoppingEvent |
|
CamelEvent.ServiceEvent |
|
CamelEvent.ServiceStartupFailureEvent |
|
CamelEvent.ServiceStopFailureEvent |
|
CamelEvent.StepCompletedEvent |
|
CamelEvent.StepEvent |
|
CamelEvent.StepFailedEvent |
|
CamelEvent.StepStartedEvent |
|
CamelEvent.Type |
|
CamelException |
Base class for all Camel checked exceptions typically thrown by a Processor
|
CamelExchangeException |
An exception caused by a specific message Exchange
|
CamelExecutionException |
Exception occurred during execution/processing of an Exchange .
|
CamelInternalProcessorAdvice<T> |
An advice (before and after) to execute cross cutting functionality in the Camel routing engine.
|
CamelLogger |
A logger which logs to a slf4j Logger .
|
CamelPreemptiveClusterService |
|
CamelPreemptiveClusterView |
|
CamelUnitOfWorkException |
A UnitOfWork failed with a number of caused exceptions.
|
CatalogCamelContext |
|
Category |
This enum set various categories options into the UriEndpoint.
|
Channel |
Channel acts as a channel between Processor s in the route graph.
|
CipherSuitesParameters |
Represents a list of TLS/SSL cipher suite names.
|
CircuitBreakerConstants |
|
ClaimCheckRepository |
Access to a repository of keys to implement the Claim Check
pattern.
|
ClassResolver |
A class resolver for loading classes in a loosly coupled manner to cater for different platforms such as standalone,
web container, j2ee container and OSGi platforms.
|
ClientAuthentication |
Represents the options for the client authentication settings of a server socket.
|
CloudServiceFactory |
|
CompilePostProcessor |
Allows to plugin custom post processors that are processed after the DSL has loaded the source and compiled into a
Java object.
|
Component |
|
Component |
|
ComponentAware |
An interface to represent an object which wishes to be injected with a Component .
|
ComponentCustomizer |
To apply custom configurations to Component instances.
|
ComponentCustomizer.Builder<T extends Component> |
|
ComponentCustomizer.Policy |
Used as additional filer mechanism to control if customizers need to be applied or not.
|
ComponentExtension |
Marker interface for component extensions.
|
ComponentNameResolver |
Discovers which components are available on the classpath.
|
ComponentResolver |
Represents a resolver of components from a URI to be able to auto-load them using some discovery mechanism like
org.apache.camel.impl.DefaultComponentResolver
|
ComponentVerifierExtension |
Defines the interface used for validating component/endpoint parameters.
|
ComponentVerifierExtension.Result |
The result of a verification
|
ComponentVerifierExtension.Result.Status |
Status of the verification
|
ComponentVerifierExtension.Scope |
The scope defines how the parameters should be verified.
|
ComponentVerifierExtension.VerificationError |
This interface represents a detailed error in case when the verification fails.
|
ComponentVerifierExtension.VerificationError.Attribute |
Interface defining an attribute which is a key for the detailed error messages.
|
ComponentVerifierExtension.VerificationError.Code |
Interface defining an error code.
|
ComponentVerifierExtension.VerificationError.ExceptionAttribute |
Attributes for details about an exception that was raised
|
ComponentVerifierExtension.VerificationError.GroupAttribute |
Group related details
|
ComponentVerifierExtension.VerificationError.HttpAttribute |
HTTP related error details
|
ComponentVerifierExtension.VerificationError.StandardCode |
Standard set of error codes
|
Condition |
A condition to define when a given Exchange matches when is being routed.
|
Configuration |
|
ConfigurationPropertiesValidationResult |
Details result of validating configuration properties (eg application.properties for camel-main).
|
Configurer |
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 .
|
ConfigurerResolver |
A pluggable strategy for resolving different configurers in a loosely coupled manner
|
ConfigurerStrategy |
Strategy for configurers.
|
ConstantProvider |
Internal annotation to mark a class as having constant fields for the source code generator.
|
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 consumer of message exchanges from an Endpoint .
|
ConsumerCache |
|
ConsumerListener<C,P> |
An interface for listening to consumer events and allow proxying between a consumer predicate and the Camel
component.
|
ConsumerListenerAware<T extends ConsumerListener<?,?>> |
An interface to represent an object which wishes to support listening for consumer events using the
ConsumerListener .
|
ConsumerTemplate |
|
ContentTypeAware |
Represents an object that can have an associated content type.
|
Contract |
A Contract which represents the input type and/or output type of the Endpoint or Processor .
|
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
|
Dataformat |
|
DataFormat |
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.
|
DataFormatContentTypeHeader |
Special accessor for a DataFormat
|
DataFormatCustomizer |
To apply custom configurations to DataFormat instances.
|
DataFormatCustomizer.Builder<T extends DataFormat> |
|
DataFormatCustomizer.Policy |
Used as additional filer mechanism to control if customizers need to be applied or not.
|
DataFormatFactory |
|
DataFormatName |
The name of the DataFormat which allows to know which kind of data format the
implementation is.
|
DataFormatResolver |
Represents a resolver of data formats.
|
DataType |
Represents the data type URN which is used for message data type contract.
|
DataTypeAware |
Allows Message to store a DataType which represents the data type of the Message.
|
Debugger |
A debugger which allows tooling to attach breakpoints which is being invoked when Exchange s is being routed.
|
DebuggerFactory |
|
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.
|
DeferServiceFactory |
Factory to create services such as Producer s and defer starting the created service, until
CamelContext has been started.
|
DelegateEndpoint |
An interface to represent an Endpoint which are delegated.
|
DelegateProcessor |
Interface to be used for processors that delegate to the real processor
|
DependencyStrategy |
Strategy when 3rd party dependencies are detected during loading routes.
|
Deserializable |
|
DevConsole |
Developer Console
|
DevConsole |
Marks a class as a custom developer console.
|
DevConsole.MediaType |
|
DevConsoleRegistry |
A registry for dev console.
|
DevConsoleResolver |
A pluggable strategy for resolving dev consoles in a loosely coupled manner
|
DiscoverableService |
|
DslProperty |
Internal annotation used to include fields otherwise excluded because annotate with XmlTransient.
|
DynamicRouter |
Indicates that this method is to be used as a Dynamic
Router routing the incoming message through a series of processing steps.
|
EagerClassloaded |
Marks this class to be eager loaded by the JDK classloader so the class is already loaded when Camel is started.
|
Endpoint |
An endpoint implements the
Message Endpoint pattern and represents an endpoint that
can send and receive message exchanges
|
EndpointAware |
|
EndpointConsumerResolver |
An interface to represent an object that can be resolved as a consumer Endpoint
|
EndpointInject |
|
EndpointProducerResolver |
An interface to represent an object that can be resolved as a producer Endpoint
|
EndpointRegistry<K> |
Registry to cache endpoints in memory.
|
EndpointStrategy |
Endpoint strategy with callback invoked when an Endpoint is about to be registered to the
endpoint registry in CamelContext .
|
EndpointUriFactory |
Factory to create Endpoint URI string from a Map of parameters.
|
EndpointUtilizationStatistics |
Various statistics about endpoint utilization, such as from EIP patterns that uses dynamic endpoints.
|
EndpointValidationResult |
Details result of validating endpoint uri.
|
ErrorHandler |
An interface used to represent an error handler
|
ErrorHandlerAware |
|
ErrorHandlerFactory |
|
ErrorHandlerRedeliveryCustomizer |
|
EventFactory |
Factory to create events that are emitted when such an event occur.
|
EventNotifier |
|
ExceptionHandler |
A Strategy pattern for handling exceptions; particularly in asynchronous processes such as consumers.
|
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
|
ExchangeFactory |
Factory used by Consumer to create Camel Exchange holding the incoming message received by the
consumer.
|
ExchangeFactoryManager |
|
ExchangeFormatter |
A plugin used to turn an Exchange into a String representation usually to be used for logging or tracing
purposes.
|
ExchangePattern |
Represents the kind of message exchange pattern
|
ExchangeProperties |
Marks a parameter as being an injection point of the exchange properties of an Exchange
|
ExchangeProperty |
Marks a parameter as being an injection point of a property of an Exchange
|
ExchangePropertyKey |
An enum of common and known keys for exchange properties used by camel-core.
|
ExchangeTimedOutException |
An exception thrown if an InOut exchange times out receiving the OUT message
|
ExecutorServiceManager |
Strategy to create thread pools.
|
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 |
|
ExpressionFactoryAware |
|
ExpressionIllegalSyntaxException |
An exception thrown if the expression contains illegal syntax.
|
ExpressionResultTypeAware |
|
ExtendedCamelContext |
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.
|
ExtendedExchange |
Extended Exchange which contains the methods and APIs that are not intended for Camel end users but used
internally by Camel for optimization purposes, SPI, custom components, or more advanced used-cases with Camel.
|
ExtendedPropertyConfigurerGetter |
A marker interface to identify the object as being a configurer which can provide details about the options the
configurer supports.
|
ExtendedRoutesBuilderLoader |
An extended RoutesBuilderLoader that is capable of loading from multiple resources in one unit (such as
compiling them together).
|
ExtendedStartupListener |
|
FactoryFinder |
Finder to find factories from the resource classpath, usually META-INF/services/org/apache/camel/.
|
FactoryFinderResolver |
|
FailedToCreateConsumerException |
Thrown if Camel failed to create a consumer for a given endpoint.
|
FailedToCreateProducerException |
Thrown if Camel failed to create a producer for a given endpoint.
|
FailedToCreateRouteException |
Exception when failing to create a Route .
|
FailedToCreateRouteFromTemplateException |
Exception when failing to create a Route from a RouteTemplateDefinition.
|
FailedToStartComponentException |
|
FailedToStartRouteException |
Exception when failing to start a Route .
|
FallbackConverter |
Deprecated.
|
FilterParameters |
Represents a set of regular expression based filter patterns for including and excluding content of some type.
|
FilterParameters.Patterns |
An immutable collection of compiled includes and excludes filter Pattern s.
|
FluentProducerTemplate |
Template for working with Camel and sending Message instances in an Exchange to an Endpoint
using a fluent build style.
|
GcpVaultConfiguration |
Configuration for access to AWS Secret.
|
GeneratedPropertyConfigurer |
A auto generated PropertyConfigurer for fast configuration of Camel components & endpoints.
|
GlobalEndpointConfiguration |
Global endpoint configurations which can be set as defaults when Camel creates new Endpoint s.
|
GlobalSSLContextParametersSupplier |
A global Supplier of SSLContextParameters to be used in Camel registry.
|
GroupAware |
To allow objects to be injected with an group.
|
Handler |
Marks a method on a POJO as being the preferred method to invoke when Camel looks for methods to invoke using the
BeanEndpoint .
|
HasCamelContext |
A simple marker interface for an object which holds a CamelContext .
|
HasGroup |
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
|
HasId |
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
|
Header |
Marks a parameter as being a header on an inbound Message
|
HeaderFilterStrategy |
Interface to allow plug-able implementation to filter header to and from Camel message.
|
HeaderFilterStrategy.Direction |
The direction is either IN or OUT.
|
HeaderFilterStrategyAware |
|
Headers |
Marks a parameter as being an injection point of the headers of an inbound Message
|
HeadersMapFactory |
Factory to create the Map implementation to use for storing headers on Message .
|
HealthCheck |
Health check
|
HealthCheck |
Marks a class as a custom health-check or health-check repository.
|
HealthCheck.Kind |
|
HealthCheck.Result |
Response to a health check invocation.
|
HealthCheck.State |
|
HealthCheckAware |
An interface to represent an object which wishes to be injected with the HealthCheck
|
HealthCheckHelper |
|
HealthCheckRegistry |
A registry for health checks.
|
HealthCheckRepository |
A repository for health checks.
|
HealthCheckResolver |
A pluggable strategy for resolving health checks in a loosely coupled manner
|
HealthCheckResultBuilder |
|
HealthCheckResultStrategy |
A strategy that allows SPI to process HealthCheck results and enrich and manipulate the result.
|
HttpResponseAware |
Represents an object which is aware of HTTP responses.
|
IdAware |
To allow objects to be injected with an id, such as EIP Processor s which has been defined
from Camel routes.
|
IdempotentRepository |
|
InflightRepository |
A repository which tracks in flight Exchange s.
|
InflightRepository.InflightExchange |
Information about the inflight exchange.
|
Injector |
A pluggable strategy for creating and possibly dependency injecting objects which could be implemented using straight
forward reflection or using Spring or CDI to perform dependency injection.
|
InOnly |
|
InOut |
|
InterceptEndpointFactory |
A factory to create Endpoint which are intercepted.
|
InterceptSendToEndpoint |
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).
|
InterceptStrategy |
The purpose of this interface is to allow an implementation to wrap processors in a route with interceptors.
|
InternalProcessor |
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
...
|
InternalProcessorFactory |
A factory used internally by Camel to create Processor and other internal building blocks.
|
InvalidPayloadException |
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc.
|
InvalidPayloadRuntimeException |
|
InvalidPropertyException |
An exception caused when an invalid property name is used on an object
|
InvokeOnHeader |
Marks a method as being invoked for a specific header value.
|
InvokeOnHeaderStrategy |
|
IsSingleton |
Used for defining if a given class is singleton or not.
|
JdkService |
|
JSonSchemaResolver |
Pluggable resolver to load JSON schema files for components, data formats, languages etc.
|
JsseParameters |
Base class that provides optional integration with core Camel capabilities.
|
KeyManagersParameters |
A representation of configuration options for creating and loading KeyManager instance(s).
|
KeyStoreParameters |
A representation of configuration options for creating and loading a KeyStore instance.
|
Language |
|
Language |
|
LanguageCustomizer |
To apply custom configurations to Language instances.
|
LanguageCustomizer.Builder<T extends Language> |
|
LanguageCustomizer.Policy |
Used as additional filer mechanism to control if customizers need to be applied or not.
|
LanguageResolver |
A pluggable strategy for resolving different languages in a loosely coupled manner
|
LanguageValidationResult |
Validation result of parsing a language expression or predicate
|
LifecycleStrategy |
Strategy for lifecycle notifications.
|
LineNumberAware |
An entity that can point to a given line number from a source Resource such as YAML and
XML DSL parsers.
|
LoadablePropertiesSource |
A source for properties that can be loaded all at once during initialization, such as loading .properties files.
|
LoadPropertiesException |
Represents a failure to open a Properties file at a given URL
|
LocalBeanRepositoryAware |
Allows a BeanRepository to temporary have a local repository take precedence, such as when creating route
templates to give more flexibility.
|
LoggingLevel |
Used to configure the logging levels
|
LogListener |
An event listener SPI for logging.
|
ManagementAgent |
Camel JMX service agent
|
ManagementInterceptStrategy |
|
ManagementInterceptStrategy.InstrumentationProcessor<T> |
|
ManagementMBeanAssembler |
An assembler to assemble a RequiredModelMBean which can be used to register the
object in JMX.
|
ManagementMBeansLevel |
Level of mbeans for registration
|
ManagementNameStrategy |
|
ManagementObjectNameStrategy |
Strategy for computing ObjectName names for the various beans that Camel register for management.
|
ManagementObjectStrategy |
Strategy for creating the managed object for the various beans Camel register for management.
|
ManagementStatisticsLevel |
Level of granularity for performance statistics enabled
|
ManagementStrategy |
Strategy for management.
|
ManagementStrategyFactory |
Service Factory for ManagementStrategy
|
MaskingFormatter |
A plugin used to mask a log String, for example security information like password or passphrase.
|
Message |
Implements the Message pattern and represents an inbound or
outbound message as part of an Exchange .
|
MessageHistory |
Represents the history of a Camel Message how it was routed by the Camel routing engine.
|
MessageHistoryFactory |
|
Metadata |
Meta data for EIPs, components, data formats and other Camel concepts
|
MetaDataExtension |
|
MetaDataExtension.MetaData |
|
MockSendToEndpointStrategyFactory |
Factory for intercepting sending to endpoint pattern and sending to mock component.
|
ModelineFactory |
Factory for parsing camel-k modeline when running Camel standalone with DSLs.
|
ModelJAXBContextFactory |
Factory to abstract the creation of the Model's javax.xml.bind.JAXBContext.
|
ModelReifierFactory |
Factory that uses reifiers to build an entity from a given model.
|
ModelToXMLDumper |
SPI for dumping model definitions into XML representation.
|
MultipleConsumersSupport |
Endpoint can optionally implement this interface to indicate whether or not it supports
multiple consumers.
|
NamedNode |
Represents a node in the routes which is identified by an id.
|
NamedRoute |
Represents a node in the routes which is identified as a route.
|
NamespaceAware |
Represents an object which is aware of the namespaces in which its used such as XPath and XQuery type expressions so
that the current namespace context can be injected
|
Navigate<T> |
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.
|
NodeIdFactory |
Factory to generate unique ids for model nodes.
|
NoFactoryAvailableException |
Thrown if no factory resource is available for the given URI
|
NonManagedService |
A marker to indicate the Service should not be registered in JMX for management.
|
NormalizedEndpointUri |
An Uri which has been normalized.
|
NoSuchBeanException |
A runtime exception if a given bean could not be found in the Registry
|
NoSuchEndpointException |
A runtime exception thrown if a routing processor such as a recipient list is unable to resolve an Endpoint
from a URI.
|
NoSuchHeaderException |
An exception caused when a mandatory header is not available on a message Exchange
|
NoSuchHeaderOrPropertyException |
|
NoSuchLanguageException |
A runtime exception thrown if an attempt is made to resolve an unknown language definition.
|
NoSuchPropertyException |
An exception caused when a mandatory property is not available on a message Exchange
|
NotifyBuilderMatcher |
Allows to be used in combination with NotifyBuilder as external predicate implementations to compute if the
exchange matches.
|
NoTypeConversionAvailableException |
An exception thrown if a value could not be converted to the required type
|
Offset<T> |
Generic offset without a concrete type
|
OffsetKey<K> |
An interface to represent offset keys (addressable for an offset)
|
OnCamelContextEvent |
Marker interface used to make it easy to discover CamelContext related event handlers from the registry.
|
OnCamelContextInitialized |
|
OnCamelContextInitializing |
|
OnCamelContextStart |
|
OnCamelContextStarted |
|
OnCamelContextStarting |
|
OnCamelContextStop |
|
OnCamelContextStopped |
|
OnCamelContextStopping |
|
OptimisticLockingAggregationRepository |
|
OptimisticLockingAggregationRepository.OptimisticLockingException |
Exception used by an AggregationRepository to indicate that an optimistic update error has
occurred and that the operation should be retried by the caller.
|
Ordered |
Interface to be implemented by objects that should be orderable, such as with a Collection .
|
PackageScanClassResolver |
A resolver that can find classes based on package scanning.
|
PackageScanFilter |
|
PackageScanResourceResolver |
A resolver that can find resources based on package scanning.
|
Pattern |
|
Policy |
A strategy capable of applying interceptors to a processor.
|
PollingConsumer |
Represents a Polling Consumer where the caller polls for
messages when it is ready.
|
PollingConsumerPollingStrategy |
|
PollingConsumerPollStrategy |
|
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 Consumer s via
ExchangeFactory .
|
PooledExchange.OnDoneTask |
Task to execute when the exchange is done.
|
PooledObjectFactory<T> |
Factory for pooled objects or tasks.
|
PooledObjectFactory.Statistics |
Utilization statistics of the this factory.
|
Predicate |
Evaluates a binary predicate on the message exchange.
|
PredicateExceptionFactory |
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.
|
PredicateFactory |
|
PredicateFactoryAware |
|
Processor |
|
ProcessorExchangeFactory |
|
ProcessorFactory |
A factory to create Processor based on the definition .
|
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 |
Provides a channel on which clients can create and invoke message exchanges on an Endpoint .
|
ProducerCache |
|
ProducerCache.AsyncProducerCallback |
Callback for sending a exchange message to a endpoint using an AsyncProcessor capable producer.
|
ProducerTemplate |
|
PropertiesComponent |
Component for property placeholders and loading properties from sources (such as .properties file from classpath or
file system)
|
PropertiesFunction |
|
PropertiesFunction |
A function that is applied instead of looking up a property placeholder.
|
PropertiesLookupListener |
Listener to trigger when the properties component is looking up and found a property.
|
PropertiesSource |
A source for properties.
|
PropertyBindingException |
Error binding property to a bean.
|
PropertyConfigurer |
A marker interface to identify the object as being configurable via a configurer class.
|
PropertyConfigurerAware |
An interface to represent an object which is capable of configuring via PropertyConfigurer .
|
PropertyConfigurerGetter |
A marker interface to identify the object as being a configurer which can provide details about the options the
configurer supports.
|
PropertyInject |
|
ProxyInstantiationException |
Exception indicating a failure while trying to create a proxy of a given type and on a given endpoint
|
ReactiveExecutor |
SPI to plugin different reactive engines in the Camel routing engine.
|
RecipientList |
Indicates that this method is to be used as a Dynamic Recipient
List routing the incoming message to one or more endpoints.
|
RecoverableAggregationRepository |
|
Registry |
Represents a BeanRepository which may also be capable of binding beans to its repository.
|
ReifierStrategy |
Strategy for reifiers.
|
ResolveEndpointFailedException |
A runtime exception thrown if an Endpoint cannot be resolved via URI
|
Resource |
Describe a resource, such as a file or class path resource.
|
ResourceAware |
An interface to represent an object which wishes to be injected with the Resource
|
ResourceLoader |
SPI for loading resources.
|
ResourceReload |
Listener for re-loading a Resource such as a Camel route.
|
ResourceReloadStrategy |
|
ResourceResolver |
|
ResourceResolver |
SPI for loading resources.
|
RestApiConsumerFactory |
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.
|
RestApiProcessorFactory |
|
RestBindingJaxbDataFormatFactory |
SPI for setting up XML data format (JAXB) for rest-dsl.
|
RestConfiguration |
|
RestConfiguration.RestBindingMode |
|
RestConfiguration.RestHostNameResolver |
|
RestConsumerFactory |
Allows SPI to plugin a RestConsumerFactory that creates the Camel Consumer responsible for handling
incoming HTTP requests from clients that request to access REST services which has been created using the
rest-dsl.
|
RestProducerFactory |
Allows SPI to plugin a RestProducerFactory that creates the Camel Producer responsible for performing
HTTP requests to call a remote REST service.
|
RestRegistry |
A registry of all REST services running within the CamelContext which have been defined and
created using the Rest DSL.
|
RestRegistry.RestService |
Details about the REST service
|
RestRegistryFactory |
|
Resumable |
This provides an interface for resumable objects.
|
ResumeAction |
Provides and interface for integrations to run actions during resume
|
ResumeActionAware |
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.
|
ResumeAdapter |
A resume adapter provides the component-specific logic that plugs the more generic strategic with the lower level
requirements of the component being used.
|
ResumeAware<T extends ResumeStrategy> |
An interface to represent an object which wishes to support resume operations using a ResumeStrategy .
|
ResumeCache<K> |
|
ResumeStrategy |
Defines a strategy for handling resume operations.
|
ResumeStrategyConfiguration |
Basic configuration holder for resume strategies
|
ResumeStrategyConfigurationBuilder<T extends ResumeStrategyConfigurationBuilder,Y extends ResumeStrategyConfiguration> |
Provides a basic interface for implementing component-specific configuration builder
|
RollbackExchangeException |
Exception used for forcing an Exchange to be rolled back.
|
Route |
|
RouteAware |
An interface to represent an object which wishes to be injected with a Route such as Consumer which
is the consumer for a route.
|
RouteConfigurationsBuilder |
A route configurations builder is capable of building route configurations using the builder and model classes.
|
RouteController |
Controller for managing the lifecycle of all the Route 's.
|
RouteError |
The last error that happened during changing the route lifecycle, i.e.
|
RouteError.Phase |
|
RouteFactory |
A factory to create Route
|
RouteIdAware |
To allow objects to be injected with the route id
|
RoutePolicy |
Policy for a Route which allows controlling the route at runtime.
|
RoutePolicyFactory |
A factory to create RoutePolicy and assign to routes automatic.
|
RoutesBuilder |
A routes builder is capable of building routes using the builder and model classes.
|
RoutesBuilderLoader |
|
RoutesLoader |
|
RoutesLoader |
|
RouteStartupOrder |
Information about a route to be started where we want to control the order in which they are started by
CamelContext .
|
RouteTemplateContext |
The context used during creating a Route from a route template.
|
RouteTemplateContext.BeanSupplier<T> |
Used for template beans to supply the local bean the route template should use when creating route(s).
|
RouteTemplateLoaderListener |
Listener when route templates is loaded from a Resource .
|
RouteTemplateParameterSource |
Source for parameters used when creating routes from route templates.
|
RoutingSlip |
Indicates that this method is to be used as a Routing Slip
routing the incoming message through a series of processing steps.
|
RuntimeCamelCatalog |
|
RuntimeCamelException |
Base class for all Camel unchecked exceptions.
|
RuntimeConfiguration |
Various runtime configuration options used by CamelContext and Route for cross
cutting functions such as tracing, delayer, stream cache and the like.
|
RuntimeEndpointRegistry |
A registry which listen for runtime usage of Endpoint during routing in Camel.
|
RuntimeEndpointRegistry.Statistic |
Statistics gathered about the endpoint.
|
RuntimeExchangeException |
A runtime exception caused by a specific message Exchange
|
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.
|
ScheduledPollConsumerScheduler |
A pluggable scheduler for org.apache.camel.support.ScheduledPollConsumer consumers.
|
ScriptingLanguage |
Represents a Language which is a general purpose scripting languages such as groovy, joor and others.
|
SecureRandomParameters |
|
SecureSocketProtocolsParameters |
Represents a list of TLS/SSL cipher suite names.
|
SendDynamic |
|
SendDynamicAware |
Used for components that can optimise the usage of org.apache.camel.processor.SendDynamicProcessor (toD) to
reuse a static Endpoint and Producer that supports using headers to provide the
dynamic parts.
|
SendDynamicAware.DynamicAwareEntry |
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.
|
Serializable |
An interface that represents resumable objects that can be serialized to a medium
|
Service |
Represents the core lifecycle API for services which can be initialized, started and stopped
|
ServiceCallConstants |
|
ServiceChooser |
Allows SPIs to implement custom Service Chooser.
|
ServiceChooserAware |
An interface to represent an object which wishes to be injected with a ServiceChooser
|
ServiceChooserFactory |
A factory to create ServiceChooser
|
ServiceDefinition |
Represents a Service.
|
ServiceDiscovery |
Allows SPIs to implement custom Service Discovery.
|
ServiceDiscoveryAware |
An interface to represent an object which wishes to be injected with a ServiceDiscovery
|
ServiceDiscoveryFactory |
A factory to create ServiceDiscovery
|
ServiceExpressionFactory |
A factory to create Expression
|
ServiceFactory<T> |
|
ServiceFactory |
|
ServiceFilter |
Allows SPIs to implement custom Service Filter.
|
ServiceFilterAware |
An interface to represent an object which wishes to be injected with a ServiceFilter
|
ServiceFilterFactory |
A factory to create ServiceFilter
|
ServiceHealth |
|
ServiceHelper |
A collection of helper methods for working with Service objects.
|
ServiceLoadBalancer |
Represents a Load Balancer.
|
ServiceLoadBalancerFactory |
A factory to create LoadBalancer
|
ServiceLoadBalancerFunction<T> |
Represents a load balancer function to be executed by the LoadBalancer.
|
ServiceRegistry |
|
ServiceRegistry.Selector |
A selector used to pick up a service among a list.
|
ServiceStatus |
Represents the status of a Service instance
|
ServiceSupport |
A useful base class which ensures that a service is only initialized once and provides some helper methods for
enquiring of its status.
|
SharedInternalProcessor |
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
...
|
ShutdownableService |
A Service which is capable of being shut down.
|
ShutdownAware |
Allows Consumer to fine grained control on shutdown which mostly have to cater for in-memory
based components.
|
ShutdownPrepared |
Allows a Service to prepare for shutdown.
|
ShutdownRoute |
Represents the options available when shutting down routes.
|
ShutdownRunningTask |
Represents the kind of options for what to do with the current task when shutting down.
|
ShutdownStrategy |
Pluggable shutdown strategy executed during shutdown of Camel and the active routes.
|
SimpleExecutorService |
|
SSLContextClientParameters |
Configuration model for client side JSSE options.
|
SSLContextParameters |
Represents SSLContext configuration options used in instantiating an SSLContext instance.
|
SSLContextParametersAware |
|
SSLContextServerParameters |
|
StartupListener |
Allows objects to be notified when CamelContext has almost done all work when starting.
|
StartupStep |
Recording state of steps during startup to capture execution time, and being able to emit events to diagnostic tools
such as Java Flight Recorder.
|
StartupStepRecorder |
To record StartupStep during startup to allow to capture diagnostic information to help troubleshoot Camel
applications via various tooling such as Java Flight Recorder.
|
StartupSummaryLevel |
Controls the level of information logged during startup (and shutdown) of CamelContext .
|
StatefulService |
A Service which has all the lifecycle events and offers details about its current state.
|
StateRepository<K,V> |
This StateRepository holds a set of key/value pairs for defining a particular state of a component.
|
StaticExpression |
|
StaticService |
|
StreamCache |
Tagging interface to indicate that a type is capable of caching the underlying data stream.
|
StreamCacheException |
|
StreamCachingStrategy |
|
StreamCachingStrategy.SpoolRule |
Rule for determine if stream caching should be spooled to disk or kept in-memory.
|
StreamCachingStrategy.SpoolUsedHeapMemoryLimit |
Used for selecting if the memory limit is committed or maximum heap memory setting.
|
StreamCachingStrategy.Statistics |
Utilization statistics of stream caching.
|
SuggestionStrategy |
Strategy to provide suggestions for unknown endpoint options
|
SupervisingRouteController |
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.
|
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.
|
Synchronization |
|
SynchronizationRouteAware |
|
SynchronizationVetoable |
|
ThreadPoolFactory |
Creates ExecutorService and ScheduledExecutorService objects that work with a thread pool for a given
ThreadPoolProfile and ThreadFactory.
|
ThreadPoolProfile |
A profile which defines thread pool settings.
|
TimeoutMap<K,V> |
Represents a map of values which timeout after a period of inactivity.
|
TimeoutMap.Listener<K,V> |
|
TimeoutMap.Listener.Type |
|
TimerListener |
Listener for receiving timer events.
|
Traceable |
Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's
defined in the route model.
|
Tracer |
SPI for tracing messages.
|
TransactedPolicy |
A marker for defining the policy to be used for applying transaction to routes.
|
Transformer |
Transformer performs message transformation according to the
declared data type.
|
TransformerRegistry<K> |
Registry to cache transformers in memory.
|
TrustManagersParameters |
|
TypeConversionException |
Exception when failing during type conversion.
|
TypeConverter |
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
|
TypeConverterExists |
What to do if attempting to add a duplicate type converter
|
TypeConverterExistsException |
Exception when failing to add type converters due there is already an existing type converter.
|
TypeConverterLoader |
|
TypeConverterLoaderException |
Exception when failing to load type converters.
|
TypeConverterRegistry |
Registry for type converters.
|
TypeConverterRegistry.Statistics |
Utilization statistics of the registry.
|
TypeConverters |
A tagging interface to mark this class implements type converters using the Converter annotations.
|
UnitOfWork |
|
UnitOfWorkFactory |
|
UpdatableConsumerResumeStrategy<T extends Resumable> |
An updatable resume strategy
|
UriEndpoint |
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
|
UriFactoryResolver |
A pluggable strategy for resolving different URI factories in a loosely coupled manner.
|
UriParam |
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
|
UriParams |
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.
|
UriPath |
Represents an injection point of a Camel Uri path value (the remaining part of a Camel URI without any query
arguments)
|
UuidGenerator |
Generator to generate UUID strings.
|
ValidationException |
The base class for any validation exception, such as
org.apache.camel.processor.validation.SchemaValidationException so that it is easy to treat all validation
errors in a similar way irrespective of the particular validation technology used.
|
Validator |
Validator performs message content validation according to the
declared data type.
|
ValidatorRegistry<K> |
Registry to cache validators in memory.
|
ValueHolder<V> |
Holder object for a given value.
|
VaultConfiguration |
Base configuration for access to Vaults.
|
VetoCamelContextStartException |
|
WaitForTaskToComplete |
Represent the kinds of options for wait for tasks to complete.
|
WrapAwareProcessor |
An interface to represent an object which wraps a Processor .
|
WrappedFile<T> |
Wraps a file.
|
XMLRoutesDefinitionLoader |
Deprecated.
|
YamlIn |
|
YamlOut |
|
YamlProperty |
|
YamlType |
|