|
||||||||||
PREV NEXT | FRAMES NO FRAMES |
Collection
which aggregates exchanges together using a correlation
expression so that there is only a single message exchange sent for a single
correlation key.AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.Expression
object from an annotation on a field, property or method parameter
of a specified type.DataFormat
MockEndpoint
instances registered
in the given context are valid
AsyncProcessor
so that it can
notify you when an Exchange
has completed.Processor
which supports asynchronous
processing of the Exchange
.BatchResequencerConfig
.
Processor
which implements some kind of
batch processing.Resequencer
.BatchResequencerConfig
instance using default
values for batchSize
(100) and batchTimeout
(1000L).
BatchResequencerConfig
instance using the given
values for batchSize
and batchTimeout
.
Exchange
to the method arguments.Processor
which converts the inbound exchange to a method
invocation on a POJOPredicate
implementationsMessage
Endpoint
may choose to implement which allows it to expose a way of browsing
the exchanges available.Source
from a byte[]
which can be read as many times as required.CamelContext
such as when working with Spring or GuicePredicate
or Expression
to a Processor
Processor
Exchange
InvocationHandler
which invokes a
message exchange on a camel Endpoint
Message
instances in an
Exchange
to an Endpoint
.Producer
which just appends to a Collection
the Exchange
object.Endpoint
objects.DefaultComponentResolver
FileComponent.HEADER_FILE_NAME
header.
BeanHolder
Endpoint
Registry
to an endpoint using
some kind of transformation or wrapper
ProcessorType.convertBodyTo(Class)
instead
Integer
Pipeline
but derived classes could change the
behaviour
Registry
DataSet
ExchangePattern
such as whether its going
to be an ExchangePattern.InOnly
or ExchangePattern.InOut
exchange
IOException
from the given
exception and message
IOException
from the given
exception and message
PollingConsumer.receive()
,
PollingConsumer.receiveNoWait()
or
PollingConsumer.receive(long)
whenever it is ready to do so
rather than using the Event
Based Consumer returned by Endpoint.createConsumer(Processor)
DataFormat
DataFormat
options.RedeliveryPolicy
CamelContext
using the given JNDI context as the
registry
CamelContext
using the given registry
ComponentResolver
which tries to find
components by using the URI scheme prefix and searching for a file of the URI
scheme name in the META-INF/services/org/apache/camel/component/
directory on the classpath.ExceptionType
that should
handle the thrown exception.Exchange
Exchange
sequence by comparing
long
values returned by this comaprator's
expression
.Message
NamespaceContext
which uses a simple Map where
the keys are the prefixes and the values are the URIsPollingConsumer
Consumer
which uses the PollingConsumer
UnitOfWork
Policy
Policy
DirectEndpoint
.Endpoint
instancesEndpoint
, Producer
,
ProducerTemplate
or CamelTemplate
into a POJO.Endpoint
instances
Endpoint
instances
ErrorHandler
implementations.Route
which starts with an
Event Driven ConsumerPollingConsumer
which uses the normal
asynchronous consumer mechanism along with a BlockingQueue
to allow
the caller to pull messages on demand.ExceptionType
should handle the thrown
exception.Message
instances.Exchange
objectsExpression
instance
Comparator
which takes an Expression
which is evaluated
on each exchange to compareComparator
which takes a list of
Expression
objects which is evaluated
on each exchange to compare themSequenceElementComparator
that compares Exchange
s based on
the result of an expression evaluation.Predicate
and Expression
implementationsExchange
for FileExchange
for FileFileProcessStrategy
to use.FileProcessStrategy
implementation to extend.Producer
implementation for FileAnnotationTypeConverterLoader.META_INF_SERVICES
location.
ExchangePattern
instance
XPathFunctionResolver
instance to use on these XPath
expressions
AsyncProcessor
interface to the configured
processor on the consumer.
BatchResequencerConfig
instance using default
values for batchSize
(100) and batchTimeout
(1000L).
StreamResequencerConfig
instance using default
values for capacity
(100) and timeout
(1000L).
Endpoint
.
Endpoint
of the specified type.
ExceptionType
to be used for handling the given thrown exception.
ExceptionType
that should handle the thrown exception.
ExceptionType
to use for a given thrown exception
DelegateProcessor
implementation
NoSuchEndpointException
is thrown
CamelContext
.
ManagedEndpoint
.
Service
.
ManagedRoute
.
PerformanceCounter
.
ExchangePattern
(MEP) of this exchange.
Source
TryType.finallyBlock()
instead, as the name
is better. Current name sugests that it handles exception,
while it mimics java finally keyword.
DefaultConsumer.getExceptionHandler()
PollingConsumerSupport.getExceptionHandler()
Message
Message
IdempotentConsumer
to avoid duplicate messages
IdempotentConsumer
to avoid duplicate messages
TypeConverter
implementation which instantiates an object
so that an instance method can be used as a type converterProcessorType.proceed()
method
to continue processing the underlying route being intercepted.
DelegateProcessor.proceed(Exchange)
method to be called at some pointRuntimeCamelException
instances
Class.isAssignableFrom(Class)
method but which also includes
coercion between primitive types to deal with Java 5 primitive type
wrapping
DataFormat
Exchange
for a jmx notificationMessage
for a JMX NotificationRegistry
implementation which looks up the objects in JNDIExpression
or Predicate
instancesList
of Exchange
instances
which can be useful for tooling, debugging and visualising routes.Processor
instancesLoadBalancer
and on closing unregisters
itself with a load balancerLoadBalancer
implementationProcessor
which just logs to a Log
object which can be used
as an exception handler instead of using a dead letter queue.ErrorHandler
which uses commons-logging to dump the errorLogger
as an error handlerExceptionHandler
which uses a Logger
to
log to an arbitrary Log
with some LoggingLevel
Registry
on the
CamelContext
Registry
on the
CamelContext
Registry
on the
CamelContext
Registry
on the
CamelContext
IllegalArgumentException
if the value could not be converted to a non null value
IllegalArgumentException
if the value could not be converted to a non null value
Registry
on the
CamelContext
or throws
Registry
on the
CamelContext
Registry
on the
CamelContext
or throws
Registry
on the
CamelContext
DataFormat
expression to define
the format of the output which will be added to the out body.
DataFormat
and sets the output on the out message body.
DataFormat
and sets the output on the out message body.
DataFormat
reference in the Registry
and sets the output on the out message body.
DataFormatType
List
result set where
if the first element is a boolean its value is used otherwise this method
returns true if the collection is not empty
MessageIdRepository
.Map
to
use to store the processed Message ID objects.
Exchange
Consumer
of
Exchange
instances to process Message
instances.Message
body handling features but letting the derived class deal
with headers.Serializable
version of a Method
MockEndpoint
instancesXPathExpression
or XQueryExpression
Injector
on the given
CamelContext
Injector
on the given
CamelContext
Policy
which adds no interceptors.StreamCachingInterceptor
type of interceptor from the given list of interceptors
Registry
RecipientList
is unable to resolve an
Endpoint
from a URI.Exchange
Exchange
PredicateAggregationCollection
to check to see if the aggregation has completed
CamelContext
.
Endpoint
.
RouteContext
(s).
Route
(s).
Service
.
Message
Pipeline
of the list of endpoints so that the message
will get processed by each endpoint in turn and for request/response the
output of one endpoint will be the input of the next endpoint
Pipeline
of the list of endpoints so that the message
will get processed by each endpoint in turn and for request/response the
output of one endpoint will be the input of the next endpoint
Pipeline
of the list of endpoints so that the message
will get processed by each endpoint in turn and for request/response the
output of one endpoint will be the input of the next endpoint
PollingConsumer
and polls all pending messages on the endpoint
and invokes the given Processor
to process each Exchange
and then closes
down the consumer and throws any exceptions thrown.
PollingConsumer
and polls all pending messages on the
endpoint and invokes the given Processor
to process each
Exchange
and then closes down the consumer and throws any
exceptions thrown.
PollingConsumer
null
if no predecessor exists.
true
if o1
is an immediate predecessor
of o2
.
Predicate
objects typically implemented by a builder such as @{XPathBuilder}Predicate
implementationsProcessor
which proceeds on an Interceptor
Processor
implementationsProcessor
.Processor
PollingConsumer
which just uses
a Processor
.Endpoint
Exchange
Exchange
BlockingQueue
within a CamelContextLoadBalancer
implementations which choose a single
destination for each exchange (rather like JMS Queues)Registry
.Injector
which just uses reflection to
instantiate new objects using their zero argument constructor.BeanHolder
which willSequenceElementComparator
.Endpoint
can not be resolved via URIExpression
instance
throwing an exception if it could not be created
Language
or throws an exception if it could not be converted
Endpoint
within a CamelContext
Route
instances in a CamelContext
for smart routing.RoutingSlipType.ROUTING_SLIP_HEADER
.
Exchange
Endpoint
which creates a ScheduledPollConsumer
BlockingQueue
within a CamelContextBlockingQueue
within a CamelContextProcessor
to populate the exchange
Processor
to populate the exchange.
Processor
to populate the exchange
ExchangePattern
returning any result output body
ExchangePattern
returning any result output body
Sequence
instance.
Exchange
s from a blocking queue and
send them to the linked processor.SequenceSender
thread.
DataFormat
Service
objectsRedeliveryPolicy.setUseExponentialBackOff(boolean)
is enabled
CamelContext
CamelContext
is injected into the component when it is added
to it
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory)
DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory)
and no expression is
provided via DeadLetterChannelBuilder.setDefaultDeadLetterEndpointExpression(Expression)
ExceptionType
to use
for handling thrown exceptions.
FileProcessStrategySupport.DEFAULT_LOCK_FILE_POSTFIX
to ignore lock files by default.
Exchange
s.
ExpressionClause
AlreadyStoppedException
to terminate processing.
FileComponent.HEADER_FILE_NAME
header and generate a new dynamic file
Log
to use and which
LoggingLevel
to use
FileProcessStrategy
will be to use the
NoOpFileProcessStrategy
to not move or copy processed files
ProcessorType.transform(Expression)
instead
ProcessorType.transform()
instead
BlockingQueue
to take messages from.
MockEndpoint.assertIsSatisfied()
will
wait on a latch until it is satisfied
MockEndpoint.expectedMessageCount(int)
is called with zero
RedeliveryPolicy.getBackOffMultiplier()
to increase the time between retries
TypeConverter
implementation which invokes a static method to convert from a type to another typeExpression
to calculate
a correlation key to perform the sticky load balancing; rather like jsessionid in the web
or JMSXGroupID in JMS.StreamResequencerConfig
.
Converter
methods for wrapping stream-based messages in a StreamCache
implementation to ensure message re-readability (e.g.Interceptor
that converts a message into a re-readable formatExchange
s.StreamResequencer
instance.
StreamResequencer
.StreamResequencerConfig
instance using default
values for capacity
(100) and timeout
(1000L).
BatchResequencerConfig
instance using the given
values for capacity
and timeout
.
BatchResequencerConfig
instance using the given
values for capacity
and timeout
.
DataFormat
Source
from a String which can
be read as many times as required.null
if no successor exists.
true
if o1
is an immediate successor
of o2
.
Processor
or Component
instances to respond to
completed or failed processing of an Exchange
rather like Spring's
TransactionSynchronizationTimer
instance a timeout value.
TimeoutMap
TimerEndpoint
.MulticastProcessor
pattern
MulticastProcessor
pattern
MulticastProcessor
pattern
InputStream
to a DOM document
InputStream
to a DOM document
InputSource
to a DOM document
String
to a DOM document
File
to a DOM document
DOMSource
or returns null if the conversion is not
supported (making it easy to derive from this class to add new kinds of conversion).
DOMSource
or returns null if the conversion is not
supported (making it easy to derive from this class to add new kinds of conversion).
LoadBalancer
implementations which sends to all destinations
(rather like JMS Topics)Predicate
SAXSource
or returns null if the conversion is not
supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource
or returns null if the conversion is not
supported (making it easy to derive from this class to add new kinds of conversion).
SAXSource
or returns null if the conversion is not
supported (making it easy to derive from this class to add new kinds of conversion).
ProcessorType.DEFAULT_TRACE_CATEGORY
logging category.
TypeConverter
such as for implementing a fallback type converterExchange
which allows the use of Synchronization
hooks.DataFormat
expression to define
the format of the input message and the output will be set on the out message body.
DataFormat
and sets the output on the out message body.
DataFormat
and sets the output on the out message body.
DataFormat
reference in the Registry
and sets the output on the out message body.
DataFormatType
RedeliveryPolicy.getBackOffMultiplier()
to
increase the time between retries
AggregationStrategy
which just uses the latest exchange which is useful
for status messages where old status messages have no real value; another example is things
like market data prices, where old stock prices are not that relevant, only the current price is.SchemaValidationException
so
that it is easy to treat all validation errors in a similar way irrespective
of the particular validation technology used.BlockingQueue
within the classloader tree containing
the camel-core.jar.DataFormat
Source
and Document
DataFormat
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |