|
||||||||||
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.Processor
which implements some kind of
batch processing.Processor
which converts the inbound exchange to a method
invocation on a POJOPredicate
implementationsMessage
Source
from a byte[]
which can be read as many times as required.CamelContext
such as when working with Spring or GuiceProcessor
InvocationHandler
which invokes a
message exchange on a camel Endpoint
Message
instances in an
Exchange
to an Endpoint
.Endpoint
objects.DefaultComponentResolver
Endpoint
Registry
to an endpoint using
some kind of transformation or wrapper
Integer
Pipeline
but derived classes could change the
behaviour
Registry
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)
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.Exchange
Message
NamespaceContext
which uses a simple Map where
the keys are the prefixes and the values are the URIsPollingConsumer
which uses the normal
asynchronous consumer mechanism along with a BlockingQueue
to allow
the caller to pull messages on demand.Policy
DirectEndpoint
.Endpoint
or Producer
in a POJO.Endpoint
instances
Endpoint
instances
Route
which starts with an
Event Driven ConsumerMessage
instances.Exchange
objectsComparator
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 themPredicate
and Expression
implementationsExchange
for FileExchange
for FileProducer
implementation for FileXPathFunctionResolver
instance to use on these XPath
expressions
Endpoint
.
Endpoint
of the specified type.
NoSuchEndpointException
is thrown
CamelContext
.
ManagedEndpoint
.
Service
.
ManagedRoute
.
Source
DefaultConsumer.getExceptionHandler()
PollingConsumerSupport.getExceptionHandler()
Message
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 underying 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
Exchange
for a jmx notificationMessage
for a JMX NotificationRegistry
implementation which looks up the objects in JNDIExpression
or Predicate
instancesProcessor
instancesLoadBalancer
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
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.MockEndpoint
instancesPolicy
which adds no interceptors.RecipientList
is unable to resolve an Endpoint
from a URI.Exchange
CamelContext
.
Endpoint
.
Route
(s).
Route
.
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
Predicate
objects typically implemented by a builder such as @{XPathBuilder}Predicate
implementationsProcessor
which proceeds on an Interceptor
Processor
implementationsProcessor
.Processor
Endpoint
Exchange
BlockingQueue
within a CamelContextLoadBalancer
implementations which choose a single
destination for each exchange (rather like JMS Queues)Injector
which just uses reflection to
instantiate new objects using their zero argument constructor.Endpoint
can not be resolved via URIEndpoint
within a CamelContext
Route
instances in aEndpoint
which creates a ScheduledPollConsumer
BlockingQueue
within a CamelContextBlockingQueue
within a CamelContextService
objectsRedeliveryPolicy.setUseExponentialBackOff(boolean)
is enabled
CamelContext
CamelContext
is injected into the component when it is added
to it
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
MockEndpoint.assertIsSatisfied()
will
wait on a latch until it is satisfied
DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory)
DeadLetterChannelBuilder.setDeadLetterFactory(ProcessorFactory)
and no expression is
provided via DeadLetterChannelBuilder.setDefaultDeadLetterEndpointExpression(Expression)
FileProcessStrategySupport.DEFAULT_LOCK_FILE_POSTFIX
to ignore lock files by default.
AlreadyStoppedException
to terminate processing.
Log
to use and which
LoggingLevel
to use
FileProcessStrategy
will be to use the
NoOpFileProcessStrategy
to not move or copy processed files
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.Source
from a String which can
be read as many times as required.TimerEndpoint
.MulticastProcessor
pattern
MulticastProcessor
pattern
MulticastProcessor
pattern
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 converterRedeliveryPolicy.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.Source
and Document
|
||||||||||
PREV NEXT | FRAMES NO FRAMES |