|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use org.apache.camel | |
---|---|
org.apache.camel | The core Camel API. |
org.apache.camel.api.management | Service provider interfaces for management. |
org.apache.camel.builder | The Camel Domain Specific Language for creating Routes, Predicates, Expressions and Error Handlers. |
org.apache.camel.builder.xml | Support for XPath based Expressions and Predicates as well as an XSLT processor |
org.apache.camel.component | Base classes for Components |
org.apache.camel.component.bean | The Bean Component which will look up the bean name in the Spring ApplicationContext and use that to dispatch messages to a POJO |
org.apache.camel.component.binding | The Binding Component which is a way of wrapping an Endpoint in a contract; such as a Data Format, a Content Enricher or validation step. |
org.apache.camel.component.browse | The Browse Component which is a simple in memory component which maintains a list of all message exchanges which can be useful for debugging, tooling or visualistion. |
org.apache.camel.component.controlbus | The Control Bus Component which allows to manage Camel at runtime. |
org.apache.camel.component.dataformat | The DataFormat Component allows to use Data Format as a Camel Component. |
org.apache.camel.component.dataset | A DataSet Endpoint for testing of endpoints using defined DataSets |
org.apache.camel.component.direct | The Direct Component which synchronously invokes all the consumers when a producer sends an exchange to the endpoint. |
org.apache.camel.component.directvm | The Direct VM Component which synchronously invokes the consumer when a producer sends an exchange to the endpoint. |
org.apache.camel.component.file | The File Component for working with file systems. |
org.apache.camel.component.file.strategy | Strategies for the File Component. |
org.apache.camel.component.language | The Language Component to send messages to language endpoints executing the script. |
org.apache.camel.component.log | The Log Component uses Jakarta Commons Logging to log message exchanges. |
org.apache.camel.component.mock | The Mock Component which is used for testing of routing and mediation rules. |
org.apache.camel.component.properties | The Properties Component for lookup of property placeholders for endpoint URI. |
org.apache.camel.component.ref | The Ref Component for lookup of existing
endpoints bound in the Registry . |
org.apache.camel.component.seda | The SEDA Component for asynchronous SEDA exchanges on a BlockingQueue within a single CamelContext |
org.apache.camel.component.stub | The Stub Component which is used for stubbing endpoints. |
org.apache.camel.component.test | A Test Endpoint for Pattern Based Testing |
org.apache.camel.component.timer | The Timer Component extends the POJO component to provide a simple timer |
org.apache.camel.component.validator | The Validator Component for validating XML against some schema |
org.apache.camel.component.vm | The VM Component for asynchronous SEDA exchanges on a BlockingQueue within the current JVM; so across CamelContext instances. |
org.apache.camel.component.xslt | The XSLT Component for transforming messages with XSLT |
org.apache.camel.converter | A set of helper classes for converting from different types of Java object to be used by the Type Conversion Support |
org.apache.camel.converter.jaxp | A number of JAXP related helper classes for converting to and from various JAXP related classes like Document and Source to be used by a TypeConverter |
org.apache.camel.converter.stream | Package with converters for dealing with stream-based messages |
org.apache.camel.impl | Default implementation classes for Camel Core |
org.apache.camel.impl.converter | Default implementation classes the Type Conversion Strategies |
org.apache.camel.impl.osgi | Camel OSGi Activator. |
org.apache.camel.language.bean | Camel Bean language. |
org.apache.camel.language.constant | Camel Constant language. |
org.apache.camel.language.header | Camel Header language. |
org.apache.camel.language.property | Camel Property language. |
org.apache.camel.language.ref | Camel Ref language. |
org.apache.camel.language.simple | Camel Simple language. |
org.apache.camel.language.simple.ast | AST for the Camel Simple language. |
org.apache.camel.language.simple.types | Types for the Camel Simple language. |
org.apache.camel.language.tokenizer | Camel Tokenizer language. |
org.apache.camel.language.xpath | Camel XPath language support. |
org.apache.camel.main | Application level classes that can be used to instantiate camel. |
org.apache.camel.management | Camel management |
org.apache.camel.management.event | Camel management events |
org.apache.camel.management.mbean | Camel management JMX MBeans |
org.apache.camel.model | The JAXB POJOs for the XML Configuration of the routing rules. |
org.apache.camel.model.dataformat | The JAXB POJOs for the Data Formats used to marshal and unmarshal objects to and from streams inside components |
org.apache.camel.model.language | The JAXB POJOs for the Expression and Predicate plugins for the XML Configuration. |
org.apache.camel.model.loadbalancer | The JAXB POJOs for the Load Balancer EIP pattern for the XML Configuration. |
org.apache.camel.processor | A collection of Processor implementations which are used to implement the Enterprise Integration Patterns |
org.apache.camel.processor.aggregate | Helper classes for the Aggregator pattern. |
org.apache.camel.processor.binding | Helper classes for the Binding concept on Endpoints. |
org.apache.camel.processor.exceptionpolicy | Exception policy startegies for Dead Letter Channel pattern. |
org.apache.camel.processor.idempotent | An implementation of the Idempotent Consumer pattern. |
org.apache.camel.processor.interceptor | Helper classes for interceptors. |
org.apache.camel.processor.loadbalancer | Various load balancer processors |
org.apache.camel.processor.resequencer | Helper classes for the Resequencer pattern. |
org.apache.camel.processor.validation | Performs XML validation using JAXP for validating against XSD or RelaxNG |
org.apache.camel.spi | Service Provider Interfaces used internally by the Camel runtime which are plugin strategies. |
org.apache.camel.support | Base classes that help to implement the camel API and are expected to be extended by the user |
org.apache.camel.util | Utility classes used by the core of Camel. |
org.apache.camel.util.concurrent | Concurrent utility classes |
org.apache.camel.util.jsse | A collection of utility classes for configuring a JSSE SSLContext and other JSSE classes. |
org.apache.camel.util.toolbox | |
org.apache.camel.view | Helper class to help with the Visualisation of Routes |
Classes in org.apache.camel used by org.apache.camel | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
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 . |
|
Component
A component is a factory of Endpoint objects. |
|
ComponentConfiguration
Represents a set of configuration values for an endpoint URI which can be created from a URI string or a base URI string and a set of parameter names and values. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
ConsumerTemplate
Template for working with Camel and consuming Message instances in an
Exchange from an Endpoint . |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
EndpointConfiguration
Holds an Endpoint configuration as a pojo that can be manipulated and validated. |
|
EndpointConfiguration.UriFormat
DataFormat operations. |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
InvalidPayloadException
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
LoggingLevel
Used to configure the logging levels |
|
ManagementStatisticsLevel
Level of granularity for performance statistics enabled |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange . |
|
NamedNode
|
|
Navigate
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. |
|
NoFactoryAvailableException
Thrown if no factory resource is available for the given URI |
|
NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type |
|
Pattern
Marks a method as having a specific kind of ExchangePattern for use with
Bean Integration or
Spring Remoting
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. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
ProducerTemplate
Template for working with Camel and sending Message instances in an
Exchange to an Endpoint . |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
RoutesBuilder
A routes builder is capable of building routes using the builder and model classes. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
RuntimeConfiguration
Various runtime configuration options used by CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the like. |
|
RuntimeExchangeException
A runtime exception caused by a specific message Exchange |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ServiceStatus
Represents the status of a Service instance |
|
ShutdownableService
A Service which is capable of being shut down. |
|
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. |
|
StartupListener
Allows objects to be notified when CamelContext has done all work when starting. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools. |
|
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 |
|
WaitForTaskToComplete
Represent the kinds of options for wait for tasks to complete. |
Classes in org.apache.camel used by org.apache.camel.api.management | |
---|---|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
Classes in org.apache.camel used by org.apache.camel.builder | |
---|---|
BinaryPredicate
A predicate which evaluates a binary expression. |
|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
LoggingLevel
Used to configure the logging levels |
|
NoSuchEndpointException
A runtime exception thrown if a routing processor such as a RecipientList is unable to resolve an
Endpoint from a URI. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
RoutesBuilder
A routes builder is capable of building routes using the builder and model classes. |
|
ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools. |
Classes in org.apache.camel used by org.apache.camel.builder.xml | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange . |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
RuntimeExpressionException
Thrown if an expression evaluation fails |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.bean | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Component
A component is a factory of Endpoint objects. |
|
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 |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
FallbackConverter
An annotation used to mark methods to indicate code capable of being a fallback converter which are then auto-discovered using the Type Conversion Support. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
NoSuchBeanException
A runtime exception if a given bean could not be found in the Registry |
|
Pattern
Marks a method as having a specific kind of ExchangePattern for use with
Bean Integration or
Spring Remoting
to overload the default value which is ExchangePattern.InOut for request/reply if no annotations are used. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.binding | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.browse | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.controlbus | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
LoggingLevel
Used to configure the logging levels |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.dataformat | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.dataset | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.direct | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.directvm | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
DelegateProcessor
Interface to be used for processors that delegate to the real processor |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Navigate
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. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.file | |
---|---|
BatchConsumer
A consumer of a batch of message exchanges from an Endpoint |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
ComponentConfiguration
Represents a set of configuration values for an endpoint URI which can be created from a URI string or a base URI string and a set of parameter names and values. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
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 |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
FallbackConverter
An annotation used to mark methods to indicate code capable of being a fallback converter which are then auto-discovered using the Type Conversion Support. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
LoggingLevel
Used to configure the logging levels |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange . |
|
NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type |
|
PollingConsumerPollingStrategy
Strategy that allows Consumer s to influence the PollingConsumer . |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
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. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
WrappedFile
Wraps a file. |
Classes in org.apache.camel used by org.apache.camel.component.file.strategy | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
LoggingLevel
Used to configure the logging levels |
Classes in org.apache.camel used by org.apache.camel.component.language | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.log | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
LoggingLevel
Used to configure the logging levels |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.mock | |
---|---|
BinaryPredicate
A predicate which evaluates a binary expression. |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Handler
Marks a method on a POJO as being the preferred method to invoke when Camel looks for methods to invoke using the BeanEndpoint . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.properties | |
---|---|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.ref | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.seda | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
MultipleConsumersSupport
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
|
PollingConsumer
Represents a Polling Consumer where the caller polls for messages when it is ready. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
WaitForTaskToComplete
Represent the kinds of options for wait for tasks to complete. |
Classes in org.apache.camel used by org.apache.camel.component.stub | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.test | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.timer | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
MultipleConsumersSupport
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.validator | |
---|---|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.vm | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.component.xslt | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.converter | |
---|---|
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 |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
Classes in org.apache.camel used by org.apache.camel.converter.jaxp | |
---|---|
BytesSource
A helper class which provides a JAXP Source from a byte[] which can be read as many times as required. |
|
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 |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
StringSource
A helper class which provides a JAXP Source from a String which can be read as many times as required. |
Classes in org.apache.camel used by org.apache.camel.converter.stream | |
---|---|
BytesSource
A helper class which provides a JAXP Source from a byte[] which can be read as many times as required. |
|
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 |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
StreamCache
Tagging interface to indicate that a type is capable of caching the underlying data stream. |
|
StringSource
A helper class which provides a JAXP Source from a String which can be read as many times as required. |
Classes in org.apache.camel used by org.apache.camel.impl | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
AsyncProducerCallback
Callback for sending a exchange message to a endpoint using an AsyncProcessor capable producer. |
|
BatchConsumer
A consumer of a batch of message exchanges from an Endpoint |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
CamelExecutionException
Exception occurred during execution/processing of an Exchange . |
|
Component
A component is a factory of Endpoint objects. |
|
ComponentConfiguration
Represents a set of configuration values for an endpoint URI which can be created from a URI string or a base URI string and a set of parameter names and values. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
ConsumerTemplate
Template for working with Camel and consuming Message instances in an
Exchange from an Endpoint . |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
EndpointConfiguration
Holds an Endpoint configuration as a pojo that can be manipulated and validated. |
|
EndpointConfiguration.UriFormat
DataFormat operations. |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
InvalidPayloadException
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
LoggingLevel
Used to configure the logging levels |
|
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. |
|
NamedNode
|
|
Navigate
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. |
|
NoFactoryAvailableException
Thrown if no factory resource is available for the given URI |
|
PollingConsumer
Represents a Polling Consumer where the caller polls for messages when it is ready. |
|
PollingConsumerPollingStrategy
Strategy that allows Consumer s to influence the PollingConsumer . |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
ProducerCallback
Callback for sending a exchange message to a endpoint using a producer. |
|
ProducerTemplate
Template for working with Camel and sending Message instances in an
Exchange to an Endpoint . |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
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. |
|
RouteNode
Represents a model of a node in the runtime route path. |
|
RoutesBuilder
A routes builder is capable of building routes using the builder and model classes. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
RuntimeConfiguration
Various runtime configuration options used by CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the like. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ServiceStatus
Represents the status of a Service instance |
|
ShutdownableService
A Service which is capable of being shut down. |
|
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. |
|
StartupListener
Allows objects to be notified when CamelContext has done all work when starting. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
StaticService
Marker for indicating the Service is a static service (only one instance per CamelContext ). |
|
StreamCache
Tagging interface to indicate that a type is capable of caching the underlying data stream. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.impl.converter | |
---|---|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
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 |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
StaticService
Marker for indicating the Service is a static service (only one instance per CamelContext ). |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
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 |
|
TypeConverterLoaderException
Exception when failing to load type converters. |
Classes in org.apache.camel used by org.apache.camel.impl.osgi | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Component
A component is a factory of Endpoint objects. |
|
TypeConverterLoaderException
Exception when failing to load type converters. |
Classes in org.apache.camel used by org.apache.camel.language.bean | |
---|---|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
RuntimeExpressionException
Thrown if an expression evaluation fails |
Classes in org.apache.camel used by org.apache.camel.language.constant | |
---|---|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.header | |
---|---|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.property | |
---|---|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.ref | |
---|---|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.simple | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.simple.ast | |
---|---|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.simple.types | |
---|---|
ExpressionIllegalSyntaxException
An exception thrown if the expression contains illegal syntax. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
Classes in org.apache.camel used by org.apache.camel.language.tokenizer | |
---|---|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.language.xpath | |
---|---|
CamelContextAware
An interface to represent an object which wishes to be injected with a CamelContext such as when working with Spring or Guice |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.main | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
ProducerTemplate
Template for working with Camel and sending Message instances in an
Exchange to an Endpoint . |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.management | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
DelegateProcessor
Interface to be used for processors that delegate to the real processor |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ManagementStatisticsLevel
Level of granularity for performance statistics enabled |
|
NamedNode
|
|
Navigate
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. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
VetoCamelContextStartException
An exception to veto starting CamelContext . |
Classes in org.apache.camel used by org.apache.camel.management.event | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
Classes in org.apache.camel used by org.apache.camel.management.mbean | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Component
A component is a factory of Endpoint objects. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
TimerListener
Listener for receiving timer events. |
Classes in org.apache.camel used by org.apache.camel.model | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Channel
Channel acts as a channel between Processor s in the route graph. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
ExecutorServiceAware
Is used for easy configuration of ExecutorService . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
LoggingLevel
Used to configure the logging levels |
|
NamedNode
|
|
Navigate
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. |
|
NoSuchEndpointException
A runtime exception thrown if a routing processor such as a RecipientList is unable to resolve an
Endpoint from a URI. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
RoutesBuilder
A routes builder is capable of building routes using the builder and model classes. |
|
RuntimeConfiguration
Various runtime configuration options used by CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the like. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ServiceStatus
Represents the status of a Service instance |
|
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. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools. |
Classes in org.apache.camel used by org.apache.camel.model.dataformat | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
Classes in org.apache.camel used by org.apache.camel.model.language | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.model.loadbalancer | |
---|---|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
Classes in org.apache.camel used by org.apache.camel.processor | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
DelegateProcessor
Interface to be used for processors that delegate to the real processor |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
LoggingLevel
Used to configure the logging levels |
|
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. |
|
Navigate
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. |
|
PollingConsumer
Represents a Polling Consumer where the caller polls for messages when it is ready. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
StreamCache
Tagging interface to indicate that a type is capable of caching the underlying data stream. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools. |
|
Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's defined in the route model. |
Classes in org.apache.camel used by org.apache.camel.processor.aggregate | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Navigate
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. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's defined in the route model. |
Classes in org.apache.camel used by org.apache.camel.processor.binding | |
---|---|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.processor.exceptionpolicy | |
---|---|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
Classes in org.apache.camel used by org.apache.camel.processor.idempotent | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Navigate
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. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.processor.interceptor | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Channel
Channel acts as a channel between Processor s in the route graph. |
|
DelegateProcessor
Interface to be used for processors that delegate to the real processor |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
LoggingLevel
Used to configure the logging levels |
|
Navigate
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. |
|
NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
RouteNode
Represents a model of a node in the runtime route path. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
Classes in org.apache.camel used by org.apache.camel.processor.loadbalancer | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Navigate
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. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's defined in the route model. |
Classes in org.apache.camel used by org.apache.camel.processor.resequencer | |
---|---|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
Classes in org.apache.camel used by org.apache.camel.processor.validation | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
Traceable
Traceable processors allowing easier tracing using constructed labels to help identify the processor and where it's defined in the route model. |
|
ValidationException
The base class for any validation exception, such as SchemaValidationException so
that it is easy to treat all validation errors in a similar way irrespective
of the particular validation technology used. |
Classes in org.apache.camel used by org.apache.camel.spi | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
ComponentConfiguration
Represents a set of configuration values for an endpoint URI which can be created from a URI string or a base URI string and a set of parameter names and values. |
|
Consumer
A consumer of message exchanges from an Endpoint |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
ManagementStatisticsLevel
Level of granularity for performance statistics enabled |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange . |
|
NamedNode
|
|
NoFactoryAvailableException
Thrown if no factory resource is available for the given URI |
|
NoSuchLanguageException
A runtime exception thrown if an attempt is made to resolve an unknown language definition. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Producer
Provides a channel on which clients can create and invoke message exchanges on an Endpoint |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
RouteNode
Represents a model of a node in the runtime route path. |
|
RuntimeConfiguration
Various runtime configuration options used by CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the like. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ShutdownableService
A Service which is capable of being shut down. |
|
ShutdownRunningTask
Represents the kind of options for what to do with the current task when shutting down. |
|
StaticService
Marker for indicating the Service is a static service (only one instance per CamelContext ). |
|
StreamCache
Tagging interface to indicate that a type is capable of caching the underlying data stream. |
|
ThreadPoolRejectedPolicy
Represent the kinds of options for rejection handlers for thread pools. |
|
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 |
|
TypeConverterLoaderException
Exception when failing to load type converters. |
|
VetoCamelContextStartException
An exception to veto starting CamelContext . |
Classes in org.apache.camel used by org.apache.camel.support | |
---|---|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
Component
A component is a factory of Endpoint objects. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
ErrorHandlerFactory
Factory for creating ErrorHandler s. |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
ExpressionIllegalSyntaxException
An exception thrown if the expression contains illegal syntax. |
|
IsSingleton
Used for defining if a given class is singleton or not. |
|
NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type |
|
Ordered
Interface to be implemented by objects that should be orderable, such as with a Collection . |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
ServiceStatus
Represents the status of a Service instance |
|
ShutdownableService
A Service which is capable of being shut down. |
|
StatefulService
A Service which has all the lifecycle events and offers details about its current state. |
|
StaticService
Marker for indicating the Service is a static service (only one instance per CamelContext ). |
|
SuspendableService
A Service which is also capable of suspending and resuming. |
|
TimeoutMap
Represents a map of values which timeout after a period of inactivity. |
|
TimerListener
Listener for receiving timer events. |
|
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 |
|
VetoCamelContextStartException
An exception to veto starting CamelContext . |
Classes in org.apache.camel used by org.apache.camel.util | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange is done. |
|
AsyncProcessor
An asynchronous processor which can process an Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback . |
|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExecutionException
Exception occurred during execution/processing of an Exchange . |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
InvalidPayloadException
Is thrown if the payload from the exchange could not be retrieved because of being null, wrong class type etc. |
|
LoggingLevel
Used to configure the logging levels |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange . |
|
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 RecipientList is unable to resolve an
Endpoint from a URI. |
|
NoSuchHeaderException
An exception caused when a mandatory header is not available on a message Exchange |
|
NoSuchPropertyException
An exception caused when a mandatory property is not available on a message Exchange |
|
NoTypeConversionAvailableException
An exception thrown if a value could not be converted to the required type |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods. |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
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 |
Classes in org.apache.camel used by org.apache.camel.util.concurrent | |
---|---|
Rejectable
Reject executing or processing some task. |
Classes in org.apache.camel used by org.apache.camel.util.jsse | |
---|---|
CamelContext
Interface used to represent the context 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 a CamelContext such as when working with Spring or Guice |
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
Classes in org.apache.camel used by org.apache.camel.util.toolbox | |
---|---|
Exchange
An Exchange is the message container holding the information during the entire routing of a Message received by a Consumer . |
|
Expression
An expression provides a plugin strategy for evaluating expressions on a message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
|
Predicate
Evaluates a binary predicate on the message exchange to support things like scripting languages, XQuery or SQL as well as any arbitrary Java expression. |
Classes in org.apache.camel used by org.apache.camel.view | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |