|
||||||||||
| 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 implementationsMessageSource from a byte[]
which can be read as many times as required.CamelContext such as when working with Spring or GuiceProcessorInvocationHandler which invokes a
message exchange on a camel EndpointMessage instances in an
Exchange to an Endpoint.Endpoint objects.DefaultComponentResolverEndpointRegistry 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)
RedeliveryPolicyCamelContext 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.ExchangeMessageNamespaceContext 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.PolicyDirectEndpoint.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()
MessageIdempotentConsumer 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 LoggingLevelList 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.
ExchangeConsumer 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.ExchangeCamelContext.
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
PollingConsumerPredicate objects typically implemented by a builder such as @{XPathBuilder}Predicate implementationsProcessor which proceeds on an InterceptorProcessor implementationsProcessor.ProcessorEndpointExchangeBlockingQueue 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 CamelContextRoute instances in aEndpoint which creates a ScheduledPollConsumerBlockingQueue 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 | |||||||||