|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
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
AsyncProcessor so that it can
notify you when an Exchange has completed.Processor which supports asynchronous
processing of the Exchange.Processor to an AsyncProcessor.Exchange in a thread-safe wayBatchResequencerConfig.
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.
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 implementationsMessageEndpoint 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 GuicePredicate or Expression
to a ProcessorProcessorExchangeInvocationHandler which invokes a
message exchange on a camel EndpointProducer which just appends to a Collection the Exchange object.Endpoint objects.DefaultComponentResolverBeanHolderProcessor.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.EndpointRegistry to an endpoint using
some kind of transformation or wrapper
Integer
source exchange to target exchange
preserving the ExchangePattern of target.
CountDownLatch.Resequencer instance applying the given
config.
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
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.
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
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.ExchangeConverter.ExchangeFormatter which just uses the Exchange toString() methodMessageNamespaceContext which uses a simple Map where
the keys are the prefixes and the values are the URIsPackageScanClassResolverPollingConsumerMessage instances in an
Exchange to an Endpoint.Consumer which uses the
PollingConsumerTimeoutMap.TraceEventMessage.DefaultTraceEventMessage based on the given node it was traced while processing
the current Exchange
UnitOfWorkPolicyPolicyDirectEndpoint.Exchange with the current result
DomResultHandlerEndpoint instancesEndpoint, Producer or
ProducerTemplate into a POJO.Endpoint instances
Endpoint instances
resourceUri.
producer
and second by aggregating input data and additional data.Enricher.
Enricher.
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.OnExceptionDefinition should handle the thrown
exception.Message instances.Exchange into a String representation
usually to be used for logging or tracing purposes.Exchange objectsExpression 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(Exchange) or
ExpressionSupport.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.AsyncProcessor interface to the configured
processor on the consumer.
ProducerTemplate from the Spring ApplicationContext instances
or lazily creates a new one dynamically
Exchange#getException().
IllegalArgumentException if there are no interfaces specified
CamelContext if one is enabled
BatchResequencerConfig instance using default
values for batchSize (100) and batchTimeout
(1000L).
StreamResequencerConfig instance using default
values for capacity (1000) and timeout
(1000L).
DefaultCamelContext.setDelay(Long) method
or it has not been specified then default to the camel.delay system property
CamelContext if one is enabled
Endpoint.
Endpoint of the specified type.
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.
Pattern.
EndpointInject or Produce injection point
Exchange has taken.
DelegateProcessor implementation
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
CamelContext.
ManagedEndpoint.
Service.
ManagedRoute.
ProcessorDefinition.
Pattern.
ExchangePattern that should be used when invoking this method.
ExchangePattern (MEP) of this exchange.
CamelContext.getRoutes() to return the routes in the context.
Source
CamelContext
DefaultCamelContext.setTrace(Boolean) method
or it has not been specified then default to the camel.trace system property
CamelContext if one is enabled
GroupedExchange class holding all the aggregated exchanges.
DefaultConsumer.getExceptionHandler()
PollingConsumerSupport.getExceptionHandler()
MessageHeaderFilterStrategy.MessageDataFormat.IdempotentConsumer
to avoid duplicate messages
IdempotentConsumer
to avoid duplicate messages
IdempotentConsumer
to avoid duplicate messages
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.ProcessorDefinition.proceed() method
to continue processing the underlying route being intercepted.
DelegateProcessor.proceed(Exchange) method to be called at some pointInvalidTypeException.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
DataFormatCounterMonitor.Message for a JMX NotificationRegistry 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.
ExchangeMessage.Message body handling features but letting the derived class deal
with headers.Serializable version of a MethodMockEndpoint instancesXPathExpression or XQueryExpressionInjector on the given
CamelContext
Injector on the given
CamelContext
Policy which adds no interceptors.StreamCachingInterceptor type of interceptor 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
CamelContext.
Endpoint.
RouteContext(s).
Route(s).
Service.
Registry.MessagePackageScanClassResolver resolver.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.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.
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.
PollingConsumernull if no predecessor exists.
true if o1 is an immediate predecessor
of o2.
Predicate assertions.Predicate objects typically implemented by a builder such as
XPathBuilderProcessor which proceeds on an Interceptorexchange) by first obtaining
additional data from an endpoint represented by an endpoint
producer and second by aggregating input data and additional
data.
Processor implementationsProcessor.ProcessorPollingConsumer 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)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 metadataExchangePattern.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
ResultHandlerEndpoint within a CamelContextRoute instances in a CamelContext for smart routing.Route.RouteDefinition so that it can be stopped independently
of other routesDataFormat.ExchangeEndpoint which creates a ScheduledPollConsumerBlockingQueue 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
ExchangePatternexchange to the next processor.
Sequence instance.
ResequencerEngine.deliver() and
ResequencerEngine.deliverNext() methods to send out re-ordered
elements.DataFormatService objectsService instanceRedeliveryPolicy.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)
Tracer.setDestinationUri(String)
TraceEventExchange.
OnExceptionDefinition to use
for handling thrown exceptions.
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.
Log to use and which
LoggingLevel to use
MockEndpoint.assertIsSatisfied() will
wait on a latch until it is satisfied
FileLanguage
Pattern.
ExchangePattern (MEP) of this exchange to be customized.
ExchangePattern used to invoke this endpoint
FileLanguage
DefaultComponent.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.
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.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.
StreamResultHandlerStreamSource objectsDataFormatStringResultHandlerSource 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
TransactionSynchronizationSystem related methodsString 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, intercepted at the given node
that occured during routing.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.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.
ProcessorDefinition.wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route.
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 | |||||||||