|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
Exchange events.ProducerCache.releaseProducer(org.apache.camel.Endpoint, org.apache.camel.Producer) method.
UuidGenerator which is a fast implementation based on
how ActiveMQUuidGenerator(String) -
Constructor for class org.apache.camel.impl.ActiveMQUuidGenerator
Exchange under the correlation key.
BundleTrackerCustomizer.addingBundle method.
BundleTracker.
InterceptStrategy to apply each Exchange before
its routed to the next Processor.
InterceptStrategy to apply each Exchange before
its routed to the next Processor.
Synchronization to be invoked as callback when
this exchange is completed.
callback to allow you to do custom
logic when an Endpoint is about to be registered to the CamelContext endpoint registry.
includeRoutes instead.
CamelContext have just been started.
Object to the given list
Exchange has been processed (after).
Exchange has been processed which allows implementators
to notify breakpoints.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.MemoryAggregationRepository
Service has already been stopped.Expression object from an annotation on a field, property or method parameter
of a specified type.MockEndpoint instances registered
in the given context are valid
MockEndpoint instances registered
in the given context are valid
AsyncProcessor so that it can
notify you when an Exchange is done.Exchange in an asynchronous fashion
and signal completion by invoking the AsyncCallback.AsyncProcessor objects.Processor to an AsyncProcessor.AsyncProcessor capable producer.Exchange in a thread-safe wayMessageBatchResequencerConfig.
EndpointResequencer.BatchResequencerConfig instance using default
values for batchSize (100) and batchTimeout
(1000L).
BatchResequencerConfig instance using the given
values for batchSize and batchTimeout.
Registry and use that to handle message dispatching.beanName.methodName which is then invoked using the
beanName to lookup in the bean integration to bind the
Exchange to the method arguments.Processor which converts the inbound exchange to a method
invocation on a POJOExchange is about to be processed (before).
Exchange is about to be processed which allows implementators
to notify breakpoints.
Predicate implementationsDataFormatMessageBreakpoint are used by the Debugger API.Breakpoint implementations to use as base class.Endpoint may choose to implement which allows it to
expose a way of browsing the exchanges available.List of Exchange instances
which can be useful for tooling, debugging and visualising routes.BundleTracker class simplifies tracking bundles much like
the ServiceTracker simplifies tracking services.BundleTracker for bundles whose state is present in
the specified state mask.
BundleTrackerCustomizer interface allows a
BundleTracker to customize the Bundles that are
tracked.Source from a byte[]
which can be read as many times as required.CamelContext such as when working with Spring or GuiceCamelContext
CamelContext.Predicate or Expression
to a ProcessorProcessorExchangeExchange.InvocationHandler which invokes a
message exchange on a camel EndpointDataFormat.Processors in the route graph.Registry and use that to handle message dispatching.BundleTracker.
IOHelper.close(java.io.Closeable, String, org.apache.commons.logging.Log)
Producer which just appends to a Collection the Exchange object.Exchange is complete.
BatchConsumer
and aggregate the total number of exchanges the BatchConsumer has reported
as total by checking the exchange property Exchange.BATCH_COMPLETE when its complete.
Endpoint objects.DefaultComponentResolverCompositePackageScanFilter allows multiple
PackageScanFilters to be composed into a single filter.Exchange matches when is being routed.Condition implementations to use as base class.Exchange.
BeanHolderEndpoint either via its
URI or via the name of the endpoint reference
which is then resolved in a registry such as the Spring Application Context.EndpointConsumer.Message instances in an
Exchange from an Endpoint.BundleTracker.
ContextScanDefinition represents a <contextScan/> element.Exchange.
Registry to an endpoint using
some kind of transformation or wrapper
InvalidPayloadException is thrown.Integer
source exchange to target exchange
preserving the ExchangePattern of target.
Resequencer instance applying the given
config.
EventObject for Camel has been resumed successfully.
EventObject for Camel failing to resume
EventObject for Camel is resuming.
EventObject for Camel has been started successfully.
EventObject for Camel is starting.
EventObject for Camel failing to start
EventObject for Camel failing to stop cleanly
EventObject for Camel has been stopped successfully.
EventObject for Camel is stopping.
EventObject for Camel has been suspended successfully.
EventObject for Camel is suspending.
Channel.
Pipeline but derived classes could change the behaviour
ConsumerTemplate which is started and therefore ready to use right away.
ConsumerTemplate which is started and therefore ready to use right away.
Registry
HasId
OnExceptionDefinition should be used.
DataSet
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
EventObject when an Exchange has been completed successfully
EventObject when an Exchange has been created
EventObject when an Exchange has failed
EventObject when an Exchange has failed
but was handled by the Camel error handlers such as an dead letter channel.
EventObject when an Exchange is about to be redelivered
EventObject when an Exchange has completely been sent to the endpoint.
ConsumerTemplate to be injected into a POJO
PollingConsumer to be injected into a POJO
Producer to be injected into a POJO
ProducerTemplate to be injected into a POJO
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)
ProcessorExchangePair which holds the processor and exchange to be send out.
ProducerTemplate which is started and therefore ready to use right away.
ProducerTemplate which is started and therefore ready to use right away.
DefaultExchange instance from the given
exchange.
ResultHandler to use
EventObject for Route has been started successfully.
EventObject for Route has been stopped successfully.
EventObject for a Service failed to start cleanly
EventObject for a Service failed to stop cleanly
StreamResequencer instance applying the given
config.
DataFormatRouteBuilder or from camel-core-xml component.
DataFormat
options.DataFormat operations.RedeliveryPolicyDebugger with Exchanges being processed.Exchanges is being routed.AnnotationExpressionFactory.Producer for implementation inheritance,
which can process Exchanges asynchronously.CamelContext using the given JNDI context as the registry
CamelContext using the given registry
Channel.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.Message instances in an
Exchange from an Endpoint.Debugger.EventFactory.OnExceptionDefinition that should
handle the thrown exception.ExchangeExchange sequence by comparing
long values returned by this comaprator's
expression.ExchangeFormatter which just uses the Exchange toString() methodManagementStrategy.Message
This implementation uses a CaseInsensitiveMap storing the headers.NamespaceContext which uses a simple Map where
the keys are the prefixes and the values are the URIsPackageScanClassResolverPollingConsumerProducer for implementation inheritance.Producer.Message instances in an
Exchange to an Endpoint.PropertiesResolver which can resolve properties
from file and classpath.Route.RouteNodeRouteStartupOrder.Consumer which uses the
PollingConsumerShutdownStrategy which uses graceful shutdown.TimeoutMap.TraceEventMessage.DefaultTraceEventMessage based on the given node it was traced while processing
the current Exchange
UnitOfWorkAsyncProcessor which can
be useful for implementation inheritance when writing an Policy
Important: This implementation does support the asynchronous routing engine.PerformanceCounter.Processor which can
be useful for implementation inheritance when writing an Policy
Important: This implementation does not support the asynchronous routing engine.DirectEndpoint.ManagementStrategy.
Exchange with the current result
DomResultHandleris done.
Endpoint instancesEndpoint, Producer or
ProducerTemplate into a POJO.LRUCache
to keep the last 1000 in an internal cache.Endpoint instances
Endpoint instances
Endpoint is about to be registered to the
endpoint registry in CamelContext.resourceUri.
resourceUri.
producer
and second by aggregating input data and additional data.Enricher.
Enricher.
resourceUri.
ErrorHandler implementations.DefaultRoute 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.events that are emitted when such an event occur.events.EventNotifier implementations.OnExceptionDefinition should handle the thrown
exception.Message received by a Consumer.Exchange into a String representation
usually to be used for logging or tracing purposes.Exchange objectsExecutorService.ExecutorServiceExecutorService to construct executors using a thread factory that
create thread names with Camel prefix.CamelContext.Expression instance
Expression instance
Expression
using Java code with a minimum amount of code to write so that the developer only needs
to implement one of the ExpressionAdapter.evaluate(org.apache.camel.Exchange, Class) or
ExpressionSupport.evaluate(org.apache.camel.Exchange) methods.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 Exchanges based on
the result of an expression evaluation.Predicate and Expression implementationsFactoryFinderExchange failed.
Route.Route.Pipeline in the async variation
as the failover load balancer is a specialized pipeline.File type.IdempotentRepository.LRUCache
as 1st level cache with a default of 1000 entries in the cache.
LRUCache
as 1st level cache.
LRUCache
as 1st level cache.
Map
as 1st level cache.
File.StreamResult which is streamed to file.Exchange to be used for matching.
Exchange to be used for matching.
AnnotationTypeConverterLoader.META_INF_SERVICES location.
DataFormat.Exchange which is originated from the particular endpoint(s).
Exchange which is originated from the particular route(s).
ExchangePattern instance
XPathFunctionResolver instance to use on these XPath
expressions
GenericFile.Exchange has been processed.MulticastProcessor.getAggregationStrategy(org.apache.camel.Exchange) instead.
ProcessorDefinition to the Channel
AsyncProcessor interface to the configured
processor on the consumer.
Bundles for all bundles being tracked by
this BundleTracker.
CamelContext
ProducerTemplate from the Spring ApplicationContext instances
or lazily creates a new one dynamically
Exchange#getException().
Exchange.CHARSET_NAME.
IllegalArgumentException if there are no interfaces specified
ExecutorService from the given definition.
ScheduledExecutorService from the given definition.
Consumer
Debugger
BatchResequencerConfig instance using default
values for batchSize (100) and batchTimeout
(1000L).
StreamResequencerConfig instance using default
values for capacity (1000) and timeout
(1000L).
CamelContext if one is enabled
Endpoint of the specified type.
Endpoint of the specified type.
Consumer consumes from.
ErrorHandler this Channel uses.
OnExceptionDefinition to be used for handling the given thrown exception.
OnExceptionDefinition that should handle the thrown exception.
OnExceptionDefinition
to use for a given thrown exception
Registry for the executor service to be used.
ExecutorServiceStrategy
Exchange currently being traced.
CamelContext if one is enabled
Pattern.
EndpointInject or Produce injection point
InterceptStrategy registered to this Channel.
NoSuchEndpointException is thrown
NoSuchEndpointException is thrown
Exchange is doomed
as exhausted and moved to the dead letter channel.
MethodInfo for the given method if it exists or null
if there is no metadata available for the given method
Processor to route to (not wrapped)
Exchange has currently taken.
Bundle if
the specified bundle is being tracked by this BundleTracker.
Message this Unit of Work was started with.
Exchange.getIn() instead as it will
ensure headers etc.
Pattern.
ExchangePattern that should be used when invoking this method.
ExchangePattern (MEP) of this exchange.
ProcessorFactory
Producer pooling.
RouteContext
RouteContext that this UnitOfWork currently is being routed through.
Scanner for scanning the given value.
Source
CamelContext
CamelContext if one is enabled
Exchange.
BundleTracker.
UuidGenerator
List as a exchange property with the key
Exchange.GROUPED_EXCHANGE.List as a exchange
property with the key Exchange.GROUPED_EXCHANGE.
DataFormatDefaultConsumer.getExceptionHandler()
PollingConsumerSupport.getExceptionHandler()
RoutePolicySupport.getExceptionHandler()
InterceptStrategy implementation to handle faults as exceptions on a RouteContextBeanEndpoint.Exchange.
MessageHeaderFilterStrategy.MessageDataFormat.IdempotentConsumer
to avoid duplicate messages
IdempotentConsumer
to avoid duplicate messages
IdempotentConsumer
to avoid duplicate messages
IdempotentConsumer.Exchanges.ExchangePattern.InOnly
for one way asynchronous invocation when using
Bean Integration or
Spring Remoting
to overload the default value which is ExchangePattern.InOut for request/reply if no annotations are used.ExchangePattern to be InOnly
ExchangePattern.InOut when a class or interface has been annotated with
InOnly when using
Bean Integration or
Spring Remoting.ExchangePattern to be InOut
TypeConverter implementation which instantiates an object
so that an instance method can be used as a fallback type converterTypeConverter implementation which instantiates an object
so that an instance method can be used as a type converterInstrumentationProcessor.ManagedCounter for instrumenting
processing of exchanges.Processor
work with the asynchronous routing engine without causing side effects.InvalidPayloadException.RuntimeCamelException instances
Class.isAssignableFrom(Class) method but which also includes
coercion between primitive types to deal with Java 5 primitive type
wrapping
Iterable to ensure we can send messages as soon as the data becomes available
for parallel processing, we start aggregating responses as they get send back to the processor;
this means the AggregationStrategy has to take care of handling out-of-order arrival of exchanges
UUID from Java.DataFormatEventNotifier which broadcasts JMX Notifications.Registry implementation which looks up the objects in JNDIDataFormatExpression or Predicate instancesExchanges to a given language and have the script being executed.PollingConsumerPollStrategy which supports suspending consumers if they
failed for X number of times in a row.Processor instancesLoadBalancer and on closing unregisters
itself with a load balancerLoadBalancer implementation.Processor 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 handler, will log at ERROR level by default.ExceptionHandler which uses a Logger to
log to an arbitrary Log with some LoggingLevelExecutorService from the Registry
and from known list of ThreadPoolProfile(s).
Registry on the
CamelContext
Registry on the
CamelContext
Registry.
ScheduledExecutorService from the Registry
and from known list of ThreadPoolProfile(s).
ManagementStrategy that Camel by default uses if possible.ObjectName names for the various beans that Camel register for management.IllegalArgumentException
if the value could not be converted to a non null value
Registry on the
CamelContext or throws IllegalArgumentException if not found.
Registry on the
CamelContext or throws IllegalArgumentException if not found.
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.
DataFormatDefinitionList 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
ExecutorService.
AggregationRepository which stores in memory only.IdempotentRepository.LRUCache
with a default of 1000 entries in the cache.
LRUCache.
Map to
use to store the processed message ids.
Exchange.Message.Message body handling features but letting the derived class deal
with headers.Serializable version of a MethodMockEndpoint instancesBundleTrackerCustomizer.modifiedBundle method.
BundleTracker has been modified.
Endpoint can optionally implement this interface to
indicate whether or not it supports multiple consumers or not.XPathExpression or XQueryExpressionList of outputs of type T that can contain 0..n nodes.Processors.
Injector on the given
CamelContext
ExpressionNode which does not support any outputs.StreamCachingInterceptor from the given list of interceptors
RegistryRecipientList is unable to resolve an
Endpoint from a URI.ExchangeExchangeEventNotifier notifications
about Exchange being routed.CamelContext has just been started.
Exchange completed successfully (no errors).
Exchange is complete.
Synchronization hook that invoke this route as
a callback when the Exchange has finished being processed.
Component.
Component.
CamelContext.
CamelContext.
ManagedEndpoint and
register that with the mbean server.
Endpoint.
Endpoint.
Exchange events occurred.
Exchange is being processed which allows implementators
to notify breakpoints.
Exchange is started being routed on the given Route
Exchange is done being routed, where it started from the given Route
Notice this callback is invoked when the Exchange is done and the Route is the route where
the Exchange was started.
Exchange ended with failure (exception or FAULT message).
Route is being initialized
ExecutorService have been created.
RouteContext(s).
Route(s).
Route(s).
Service.
Service.
BundleTracker and begin tracking bundles.
Collection.OrderedRegistry.MessageExchange.XSLT_FILE_NAME header.
PackageScanDefinition represents a <packageScan/> element.PackageScanClassResolver resolver.ExecutorService to do the multicasting work
ExchangePattern used to invoke this endpoint
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.Exchange are routed in Camel.Pipeline 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
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
Policy.
Policy.
AsyncProcessor as the returned wrapped
Processor which ensures the policy works well with the asynchronous routing engine.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.
resourceUri
using a PollingConsumer to poll the endpoint.
resourceUri
using a PollingConsumer to poll the endpoint.
resourceUri
using a PollingConsumer to poll the endpoint.
resourceUri
using a PollingConsumer to poll the endpoint.
producer
and second by aggregating input data and additional data.PollEnricher.
PollEnricher.
resourceUri
using a PollingConsumer to poll the endpoint.
PollingConsumer when polling an Endpoint.PollingConsumerExecutorService.
RouteContext
it should be removed.
GenericFileMessage relevant headers
null if no predecessor exists.
true if o1 is an immediate predecessor
of o2.
Predicate assertions.CamelContext
Exchange to send as onCompletion.
exchange) by first obtaining
additional data from an endpoint represented by an endpoint
producer and second by aggregating input data and additional
data.
exchange) by first obtaining
additional data from an endpoint represented by an endpoint
producer and second by aggregating input data and additional
data.
Exchange in a batch.
Processor implementationsProcessor.MulticastProcessor.Processor based on the definition.PollingConsumer which just uses
a Processor.Endpoint either via its
URI or via the name of the endpoint reference
which is then resolved in a registry such as the Spring Application Context.EndpointProducer.Message instances in an
Exchange to an Endpoint.ExchangeExchangePropertyEditor conversion system to convert Objects to
and from String values.Registry which delegates to the real registry.DataFormatEventNotifier which publishes the EventObject to some
Endpoint.RouteContext that this UnitOfWork currently is being routed through.
LoadBalancer implementations which choose a single
destination for each exchange (rather like JMS Queues)StreamCache implementation for Cache the Reader ReadersAggregationRepository which also supports
recovery.RedeliveryPolicy to lookup in the Registry to be used.
Registry.Injector which just uses reflection to
instantiate new objects using their zero argument constructor.BeanHolder which will look up a bean from the registry and act as a cache of its metadataRegistry
BundleTracker.
Exchange is completed
OnCompletionDefinition from the definition.
BundleTrackerCustomizer.removedBundle method.
BundleTracker has been removed.
ExchangePattern.InOut message exchange pattern.
ExchangePattern.InOut message exchange pattern.
ExchangePattern.InOut message exchange pattern.
ExchangePattern.InOut message exchange pattern.
ExchangePattern.InOut message exchange pattern.
ExchangePattern.InOut message exchange pattern.
SequenceElementComparator.StreamCache instance, reset the cache to
enable reading from it again.
Endpoint cannot be resolved via URIIdempotentRepository to use
ResultHandlerExchange to rollback.Endpoint within a CamelContextDefaultRoute instances in a CamelContext for smart routing.Route.RouteDefinition
Utility methods to help preparing RouteDefinition before they are added to
CamelContext.Route which allows controlling the route at runtime.RoutePolicy implementations.RouteDefinition so that it can be stopped independently
of other routesCamelContext.DataFormat.CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the likes.ExchangeExchange will pass through.
SamplingThrottler is a special kind of throttler.s is friendly for a URL or file system.
Exchanges to be recovered
Endpoint which creates a ScheduledPollConsumerBlockingQueue within a CamelContextBlockingQueue within a CamelContextProcessor to populate the exchange
Processor to populate the exchange
Exchange.getException().
Exchange.getException().
Exchange.getException().
Exchange.getException().
Exchange.getException().
Exchange.getException().
Exchange.getException().
Exchange.getException().
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
ExchangePattern
returning any result output body
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
ExchangePatternexchange to the next processor.
Exchange to the consumer(s).
Sequence instance.
ResequencerEngine.deliver() and
ResequencerEngine.deliverNext() methods to send out re-ordered
elements.DataFormatService objectsServicePool.Service instanceRedeliveryPolicy.setUseExponentialBackOff(boolean) is enabled
CamelContext
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
Exchange
should be send to.
Debugger
Tracer.setDestinationUri(String)
ErrorHandler this Channel uses.
Throwable into Exception type to
accommodate for the Exchange.getException() method returning a plain Exception type.
OnExceptionDefinition to use
for handling thrown exceptions.
OnExceptionDefinition
to use for a given thrown exception
ExchangePattern into the exchange
Registry for the executor service to be used.
ExecutorServiceStrategy
Exchanges.
ExpressionClause
SimpleLanguage
Pattern.
ProcessorDefinition.addRoutes(RouteContext, java.util.Collection)
will not add processor to addEventDrivenProcessor to the RouteContext and it
will prevent from adding an EventDrivenRoute.
Exchange
should be attempted, before its exhausted.
MockEndpoint.assertIsSatisfied() will
wait on a latch until it is satisfied
SimpleLanguage
SimpleLanguage
Exchange to.
Pattern.
ExchangePattern (MEP) of this exchange to be customized.
ExchangePattern used to invoke this endpoint
SimpleLanguage
ProcessorFactory
Producer pooling.
EndpointHelper.isReferenceParameter(String)
by looking it up in registry and setting it on the bean if possible.
MockEndpoint.assertIsSatisfied() will
wait on a latch until it is satisfied
MockEndpoint.expectedMessageCount(int) is called with zero
ManagementStatisticsLevel.All
RedeliveryPolicy.getBackOffMultiplier() to increase the time between retries
DefaultTraceEventMessage
Use this to allow persistence of trace events into a database using JPA.
UuidGenerator (should only be set once)
DefaultProducerServicePool which is used by
CamelContext by default.Service which is also capable of shutting down.Consumer to fine grained control on shutdown which mostly
have to cater for in-memory based components.CamelContext.stopRoute(String) and CamelContext.removeRoute(String)
CamelContext.stopRoute(String, long, java.util.concurrent.TimeUnit) and CamelContext.removeRoute(String)
Simple language builder.LoadBalancer implementation.Map-based registry.BundleTracker.
Exchange to the original intended endpoint
StreamCache implementation for StringSourcesProducer to be used for sending to the given endpoint
This can be used to early start the Producer to ensure it can be created,
such as when Camel is started.
CamelContext have just been started.TypeConverter implementation which invokes a static method
as a fallback type converter from a type to another typeTypeConverter 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.Exchange and marks it as completed.
Exchange and the caused exception will be thrown.
Exchange and the caused exception will be thrown.
Exchange and the caused exception will be thrown.
ShutdownStrategy.
ShutdownStrategy with a specified timeout.
StreamResequencerConfig.
Converter methods for wrapping stream-based messages in a StreamCache
implementation to ensure message re-readability (eg multicasting, retrying)InterceptStrategy implementation to configure stream caching on a RouteContextStreamCache.Exchanges.StreamResequencer instance.
StreamResequencer.StreamResequencerConfig instance using default
values for capacity (1000) and timeout
(1000L).
BatchResequencerConfig instance using the given
values for capacity and timeout.
BatchResequencerConfig instance using the given
values for capacity and timeout.
StreamResultHandlerStreamCache implementation for Cache the StreamSource StreamSourcesStreamSource objectsDataFormatStringResultHandlerSource from a String which can
be read as many times as required.CompletionService that orders the completed tasks
in the same order as they where submitted.null if no successor exists.
true if o1 is an immediate successor
of o2.
Service which is also capable of suspending and resuming.ShutdownStrategy.
ShutdownStrategy with a specified timeout.
Processor or Component
instances to respond to completed or failed processing of an Exchange rather like Spring's
TransactionSynchronizationSynchronization adapter with empty methods for easier overriding
of single methods.Synchronization.Exchange using asynchronous routing engine.
Exchange using asynchronous routing engine.
Exchange using asynchronous routing engine.
Exchanges
using the asynchronous routing engine.RoutePolicy which is capable of dynamic
throttling a route based on number of current inflight exchanges.Exchange
String or Node
Node
DataFormatTimer instance and
timeout value.
AggregationStrategy which can handle timeouts as well.TimeoutMapTimerEndpoint.TimeUnitAdapter is a simple adapter to convert between Strings
and instances of the TimeUnit enumerationIterator to a ArrayList
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).
Iterable into a List
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).
TraceInterceptor
so we can trace the exact route path a given Exchange has been processed.Exchange at the point of interception.Exchange is about to be processed
This event is only called if trace out has been disabled (which it is by default).
Exchange is about to be processed (in)
This event is only called if trace out has been enabled.
Exchange has been processed (out)
This event is only called if trace out has been enabled.
Exchange during routing.TypeConverter
such as for implementing a fallback type converterExchange
which allows the use of Synchronization hooks.Exchange is routed under the boundaries of an UnitOfWork.Producer is executed within an UnitOfWork.UnitOfWork.
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.
DataFormatDefinitionRedeliveryPolicy.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.AggregationStrategy which just uses the original exchange
which can be needed when you want to preserve the original Exchange.Exchange for this on completion.
OnExceptionDefinition.useOriginalMessage()
Message when an Exchange
is moved to the dead letter queue.
Exchange is moved to the dead letter queue.
SchemaValidationException so
that it is easy to treat all validation errors in a similar way irrespective
of the particular validation technology used.CamelContext.BlockingQueue within the classloader tree containing
the camel-core.jar.Exchange should match the Predicate
Exchange should match the Predicate
Exchange should match the Predicate
Exchange should match the Predicate
Exchange has been completed.
Exchange is done being processed.
Exchange
being sent to it when they are done.
Exchange
being sent to it when they are done.
Exchange has been completed.
Exchange is done being processed.
Exchange has failed.
Exchange has failed.
Exchange has been received.
Exchange
being sent to it when they are received.
Exchange
being sent to it when they are received.
ExchangePattern.InOnly.
ExchangePattern.InOnly.
ExchangePattern.InOnly.
Exchange to the destination
using ExchangePattern.InOnly.
Exchange to the destination
using ExchangePattern.InOnly.
Exchange to the destination
using ExchangePattern.InOnly.
Exchange to the destination
using ExchangePattern.InOnly.
CamelExecutionException if its not
already such an exception.
ProcessorDefinition.wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route.
RuntimeCamelException if its not
already such an exception.
DataFormatSource and DocumentDataFormatURIResolver which is capable of loading files
from the classpath and file system.DataFormatDataFormat
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||