|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Packages that use org.apache.camel | |
---|---|
org.apache.camel | The core Camel API |
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.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.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.file | The File Component for working with file systems. |
org.apache.camel.component.file.strategy | Strategies for the File Component. |
org.apache.camel.component.jmx | The JMX Component for monitoring JMX Attributes uisng a CounterMonitor. |
org.apache.camel.component.list | The List 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.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.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.timer | The Timer Component extends the POJO component to provide a simple timer |
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.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.language | Camel language support such as Bean and Simple language. |
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.simple | Camel Simple language. |
org.apache.camel.management | Camel JMX export services. |
org.apache.camel.model | The JAXB POJOs for the XML Configuration of the routing rules. |
org.apache.camel.model.config | The Resequencer Configuration classes |
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 LoadBalancer and the LoadBalancerStrategy JAXB Objects |
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.util | Utility classes used by the core of Camel and useful for Camel component developers |
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 has completed. |
|
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 |
|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
ExchangeProperty
Represents an instance and a type safe registry of well known Camel Exchange properties. |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange |
|
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. |
|
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 (named like Spring's TransactionTemplate & JmsTemplate et al) 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 |
|
Routes
|
|
RuntimeCamelException
Base class for all Camel unchecked exceptions. |
|
RuntimeExchangeException
A runtime exception caused by a specific message Exchange |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
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.builder | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
|
Routes
|
Classes in org.apache.camel used by org.apache.camel.builder.xml | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.bean | |
---|---|
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. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
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 has completed. |
|
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.file | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.file.strategy | |
---|---|
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.jmx | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
ExchangePattern
Represents the kind of message exchange pattern |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.list | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.log | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
Classes in org.apache.camel used by org.apache.camel.component.mock | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.ref | |
---|---|
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 |
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 has completed. |
|
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 |
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 |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.component.vm | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 | |
---|---|
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 |
Classes in org.apache.camel used by org.apache.camel.converter.stream | |
---|---|
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 |
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 has completed. |
|
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
Intercept
An interface which provides the processing logic as a pluggable processor |
|
Message
Implements the Message pattern and represents an inbound or outbound message as part of an Exchange |
|
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 (named like Spring's TransactionTemplate & JmsTemplate et al) for working with Camel and sending Message instances in an
Exchange to an Endpoint . |
|
ResolveEndpointFailedException
A runtime exception thrown if an Endpoint can not be resolved via URI |
|
Route
A Route defines the processing used on an inbound message exchange from a specific Endpoint within a CamelContext |
|
Routes
|
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
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
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
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.language | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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.language.bean | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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.language.header | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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.language.simple | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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.management | |
---|---|
AsyncCallback
The callback interface for an AsyncProcessor so that it can
notify you when an Exchange has completed. |
|
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
Classes in org.apache.camel used by org.apache.camel.model | |
---|---|
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 |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.model.config | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
Classes in org.apache.camel used by org.apache.camel.model.dataformat | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
Classes in org.apache.camel used by org.apache.camel.model.language | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 has completed. |
|
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
Intercept
An interface which provides the processing logic as a pluggable processor |
|
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 |
Classes in org.apache.camel used by org.apache.camel.processor.aggregate | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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.processor.exceptionpolicy | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
Classes in org.apache.camel used by org.apache.camel.processor.idempotent | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.processor.interceptor | |
---|---|
CamelContext
Interface used to represent the context used to configure routes and the policies to use during message exchanges between endpoints. |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
Intercept
An interface which provides the processing logic as a pluggable processor |
|
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. |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
Classes in org.apache.camel used by org.apache.camel.processor.loadbalancer | |
---|---|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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 |
Classes in org.apache.camel used by org.apache.camel.processor.resequencer | |
---|---|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
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.validation | |
---|---|
CamelException
Base class for all Camel checked exceptions typically thrown by a Processor |
|
CamelExchangeException
An exception caused by a specific message Exchange |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
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 | |
---|---|
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. |
|
Endpoint
An endpoint implements the Message Endpoint pattern and represents an endpoint that can send and receive message exchanges |
|
Exchange
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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. |
|
Intercept
An interface which provides the processing logic as a pluggable processor |
|
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 |
|
Service
Represents the core lifecycle API for POJOs which can be started and stopped |
|
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 | |
---|---|
AsyncProcessor
A more complex version of Processor which supports asynchronous
processing of the Exchange . |
|
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
The base message exchange interface providing access to the request, response and fault Message instances. |
|
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 retrieve because of being null, wrong class type etc. |
|
InvalidTypeException
Is thrown if type conversion failed. |
|
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 |
|
Processor
A processor is used to implement the Event Driven Consumer and Message Translator patterns and to process message exchanges. |
|
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.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 |