|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
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.
Object to the given list
Collection which aggregates exchanges together,
using a correlation Expression and a AggregationStrategy.AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.Service has already been stopped.Expression object from an annotation on a field, property or method parameter
of a specified type.DataFormatMockEndpoint instances registered
in the given context are valid
Exchange in a thread-safe wayBatchResequencerConfig.
EndpointProcessor 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.
BatchConsumer
and aggregate the total number of exchanges the BatchConsumer has reported
as total by setting the exchange property Exchange.BATCH_SIZE.
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 POJOPredicate implementationsDataFormatMessageEndpoint 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.Source from a byte[]
which can be read as many times as required.CamelContext such as when working with Spring or GuiceCamelContext
Predicate or Expression
to a ProcessorProcessorExchangeExchange.InvocationHandler which invokes a
message exchange on a camel EndpointProcessors in the route graph.Producer which just appends to a Collection the Exchange object.Endpoint objects.DefaultComponentResolverCompositePackageScanFilter allows multiple
PackageScanFilters to be composed into a single filter.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.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.
Channel.
Pipeline but derived classes could change the behaviour
Registry
OnExceptionDefinition should be used.
DataSet
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange
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)
DefaultExchange instance from the given
exchange.
DefaultExchange instance from the given
exchange.
StreamResequencer instance applying the given
config.
DataFormatDataFormat
options.DataFormat operations.RedeliveryPolicyCollection which aggregates exchanges together using a correlation
expression so that there is only a single message exchange sent for a single
correlation key.AnnotationExpressionFactory.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.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() methodMessage
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.Message instances in an
Exchange to an Endpoint.Endpoint within a CamelContextRouteNodeConsumer which uses the
PollingConsumerTimeoutMap.TraceEventMessage.DefaultTraceEventMessage based on the given node it was traced while processing
the current Exchange
UnitOfWorkPolicyDirectEndpoint.Exchange with the current result
DomResultHandlerEndpoint instancesEndpoint, Producer or
ProducerTemplate into a POJO.Endpoint instances
Endpoint instances
Endpoint is about to be registered to the
endopoint registry in CamelContext.resourceUri.
resourceUri.
producer
and second by aggregating input data and additional data.Enricher.
Enricher.
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.OnExceptionDefinition should handle the thrown
exception.Message instances.Exchange into a String representation
usually to be used for logging or tracing purposes.Exchange objectsExecutorService to construct executors using a thread factory that
create thread names with Camel prefix.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
ExpressionAdapter.evaluate(org.apache.camel.Exchange, Class) 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 implementationsFile 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.AnnotationTypeConverterLoader.META_INF_SERVICES location.
DataFormat.ExchangePattern instance
XPathFunctionResolver instance to use on these XPath
expressions
GenericFile.Exchange has been processed.CamelContext
ProducerTemplate from the Spring ApplicationContext instances
or lazily creates a new one dynamically
Exchange#getException().
IllegalArgumentException if there are no interfaces specified
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.
Endpoint of the specified type.
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
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
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.
CamelContext.
ManagedEndpoint.
Service.
ManagedRoute.
ProcessorDefinition.
Message this Unit of Work was started with.
Pattern.
ExchangePattern that should be used when invoking this method.
ExchangePattern (MEP) of this exchange.
Producer pooling.
Scanner for scanning the given value.
Source
CamelContext
CamelContext if one is enabled
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()
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.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.Counter for instrumenting
processing of exchanges.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
DataFormatRegistry implementation which looks up the objects in JNDIExpression or Predicate instancesProcessor 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 handler, will log at ERROR level by default.ExceptionHandler which uses a Logger to
log to an arbitrary Log with some LoggingLevelRegistry 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 exception if not found.
Registry on the
CamelContext or throws exception if not found.
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
IdempotentRepository.LRUCache
with a default of 1000 entries in the cache.
LRUCache.
Map to
use to store the processed message ids.
Exchange
See DefaultMessage for how headers is represented in Camel using a
CaseInsensitiveMap.Message.Message body handling features but letting the derived class deal
with headers.Serializable version of a MethodMockEndpoint instancesXPathExpression or XQueryExpressionList of outputs of type T that can contain 0..n nodes.Processors.
Injector on the given
CamelContext
Injector on the given
CamelContext
Policy which adds no interceptors.StreamCachingInterceptor from the given list of interceptors
RegistryRecipientList is unable to resolve an
Endpoint from a URI.ExchangeExchangePredicateAggregationCollection
to check to see if the aggregation has completed
Exchange completed succesfully (no errors).
Exchange is complete.
Synchronization hook that invoke this route as
a callback when the Exchange has finished being processed.
CamelContext.
ManagedEndpoint and
register that with the mbean server.
Endpoint.
Exchange ended with failure (exception or FAULT message).
RouteContext(s).
Route(s).
Service.
Registry.MessagePackageScanDefinition represents a <package-scan/> element.PackageScanClassResolver resolver.ExecutorService to do the multicasting work
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.PatternBasedPackageScanFilter uses an underlying
AntPathMatcher to filter scanned files according to include and
exclude patterns.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.
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.
PollingConsumer when polling an Endpoint.PollingConsumerExecutorService.
GenericFileMessage relevant headers
null if no predecessor exists.
true if o1 is an immediate predecessor
of o2.
Predicate assertions.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.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.ProducerTemplateExchangeExchangePropertyEditor conversion system to convert Objects to
and from String values.LoadBalancer implementations which choose a single
destination for each exchange (rather like JMS Queues)StreamCache implementation for Cache the Reader ReadersRegistry.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
OnCompletionDefinition from the defintion.
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 URIExpression instance
throwing an exception if it could not be created
Language or throws an exception if it could not be converted
IdempotentRepository to use
ResultHandlerExchange to rollback.DefaultRoute instances in a CamelContext for smart routing.Route.RouteDefinition so that it can be stopped independently
of other routesDataFormat.CamelContext and RouteContext
for cross cutting functions such as tracing, delayer, stream cache and the likes.ExchangeEndpoint which creates a ScheduledPollConsumerBlockingQueue within a CamelContextBlockingQueue within a CamelContextProcessor to populate the exchange
Processor to populate the exchange
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
CamelExecutionException with
the caused exception wrapped.
ExchangePattern
returning any result output body
Notice: that if the processing of the exchange failed with an Exception
it is thrown from this method as a 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.
Sequence instance.
ResequencerEngine.deliver() and
ResequencerEngine.deliverNext() methods to send out re-ordered
elements.DataFormatService objectsServicePool.Service instanceRedeliveryPolicy.setUseExponentialBackOff(boolean) is enabled
CamelContext
CamelContext is injected into the component when it is added
to it
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
RedeliveryPolicy.setUseCollisionAvoidance(boolean)
Tracer.setDestinationUri(String)
ErrorHandler this Channel uses.
OnExceptionDefinition to use
for handling thrown exceptions.
OnExceptionDefinition
to use for a given thrown exception
ExchangePattern into the exchange
Exchanges.
ExpressionClause
AlreadyStoppedException to terminate processing.
FileLanguage
Pattern.
ProcessorDefinition.addRoutes(RouteContext, java.util.Collection)
will not add processor to addEventDrivenProcessor to the RouteContext and it
will prevent from adding an EventDrivenRoute.
MockEndpoint.assertIsSatisfied() will
wait on a latch until it is satisfied
FileLanguage
FileLanguage
Exchange to.
Pattern.
ExchangePattern (MEP) of this exchange to be customized.
ExchangePattern used to invoke this endpoint
FileLanguage
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
RedeliveryPolicy.getBackOffMultiplier() to increase the time between retries
DefaultTraceEventMessage
Use this to allow persistence of trace events into a database using JPA.
Exchange to the original intended endpoint
StreamCache implementation for StringSourcesTypeConverter 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.
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 RouteContextDelegateProcessor that converts a message into a re-readable formatExchanges.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.
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.System related methodsExchange
String or Node
Node
DataFormatTimer instance and
timeout value.
TimeoutMapTimerEndpoint.Iterator 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 excact
route path a given Exchange has been processed.Exchange at the point of interception.Exchange during routing.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.
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.Exchange is moved to the dead letter queue.
Message when an 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.BlockingQueue within the classloader tree containing
the camel-core.jar.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 DocumentDataFormatDataFormatDataFormat
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||