|
||||||||||
| 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.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.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.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.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.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. |
|
| 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 ErrorHandlers. |
|
| 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
Deprecated. will be removed in Camel 3.0 |
|
| 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. |
|
| 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 ErrorHandlers. |
|
| 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 |
|
| 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 |
|
| 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.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. |
|
| 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 |
|
| 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 |
|
| 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. |
|
| 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. |
|
| 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.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. |
|
| 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. |
|
| 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 Consumers 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 |
|
| 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. |
|
| 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 |
|
| Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange. |
|
| 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 |
|
| 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. |
|
| 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 |
|
| 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. |
|
| 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. |
|
| 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 ErrorHandlers. |
|
| 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
Deprecated. will be removed in Camel 3.0 |
|
| 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. |
|
| 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 Consumers 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. |
|
| 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. |
|
| 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. |
|
| 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 | |
|---|---|
| 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 | |
|---|---|
| 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 ErrorHandlers. |
|
| 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 |
|
| 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 ErrorHandlers. |
|
| 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 Processors 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 ErrorHandlers. |
|
| 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.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 |
|
| 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. |
|
| 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 | |
|---|---|
| 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 |
|
| 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.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 Processors 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. |
|
| 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. |
|
| 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. |
|
| Classes in org.apache.camel used by org.apache.camel.processor.validation | |
|---|---|
| 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. |
|
| 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 ErrorHandlers. |
|
| 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. |
|
| 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 ErrorHandlers. |
|
| 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. |
|
| 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. |
|
| 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. |
|
| 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
Deprecated. will be removed in Camel 3.0 |
|
| 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.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 | |||||||||