|
||||||||||
| 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.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
AggregationStrategy
(by default the latest message is used) to compress many message exchanges
into a smaller number of exchanges.
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 POJOLanguageExpression will be removed in Camel 2.0Predicate implementationsMessageEndpoint may choose to implement which allows it to
expose a way of browsing the exchanges available.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 EndpointProducerTemplate instead, can be created using CamelContext.createProducerTemplate(). Will be removed in Camel 2.0Producer which just appends to a Collection the Exchange object.Endpoint objects.DefaultComponentResolverFileComponent.HEADER_FILE_NAME header.
BeanHolderProcessor.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
ProcessorType.convertBodyTo(Class) instead. Will be removed in Camel 2.0.
ProcessorType.convertBodyTo(Class) instead. Will be removed in Camel 2.0.
Integer
Exchange.copy()
to get a new instance of an exchange or simply create a new
exchange object
CountDownLatch -- this implementation also supports incrementing
the latch count while counting down.Resequencer instance applying the given
config.
Pipeline but derived classes could change the
behaviour
Registry
ExceptionType 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)
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.ExceptionType 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 URIsPollingConsumerMessage instances in an
Exchange to an Endpoint.Consumer which uses the PollingConsumerTimeoutMap.UnitOfWorkPolicyPolicyDirectEndpoint.Exchange with the current result
DomResultHandlerEndpoint instancesEndpoint, Producer or
ProducerTemplate into a POJO.Endpoint instances
Endpoint instances
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.RouteBuilder.onException(Class) instead. Will be removed in Camel 2.0.
ProcessorType.onException(Class) instead. Will be removed in Camel 2.0.
ExceptionType should handle the thrown
exception.Message instances.Exchange into a String
so it can be logged to a fileExchange objectsExpression instance
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 implementationsExchange for FileExpression to dynamically compute the file name.Message for FileFileProcessStrategy to use.FileProcessStrategy implementation to extend.AnnotationTypeConverterLoader.META_INF_SERVICES location.
DataFormat.ExchangePattern instance
XPathFunctionResolver instance to use on these XPath
expressions
AsyncProcessor interface to the configured
processor on the consumer.
ProducerTemplate from the Spring ApplicationContext instances
or lazily creates a new one dynamically
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.
ExceptionType to be used for handling the given thrown exception.
ExceptionType that should handle the thrown exception.
ExceptionType
to use for a given thrown exception
Exchange.getOut()
and check the #org.apache.camel.Message.isFault() flag
Exchange.getOut()
and check the #org.apache.camel.Message.isFault() flag
Pattern.
EndpointInject or Produce injection point
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.
ProcessorType.
Exchange.getOut()
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
DefaultCamelContext.setTrace(Boolean) method
or it has not been specified then default to the camel.trace system property
CamelContext if one is enabled
TryType.finallyBlock() instead, as the name
is better. Current name sugests that it handles exception,
while it mimics java finally keyword. Will be removed in Camel 2.0.
DefaultConsumer.getExceptionHandler()
PollingConsumerSupport.getExceptionHandler()
MessageHeaderFilterStrategy.MessageDataFormat.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 type converterInstrumentationProcessor.Counter for instrumenting
processing of exchanges.ProcessorType.proceed() method
to continue processing the underlying route being intercepted.
DelegateProcessor.proceed(Exchange) method to be called at some pointInvalidTypeException. Will be removed in Camel 2.0.InvalidTypeException.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
ObjectHelper.createIterator(Object). Will be removed in Camel 2.0.
DataFormatCounterMonitor.Exchange for JMX notificationMessage for a JMX NotificationRegistry implementation which looks up the objects in JNDIExpression or Predicate instancesList of Exchange instances
which can be useful for tooling, debugging and visualising routes.Processor 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
Registry on the
CamelContext
Registry on the
CamelContext or throws
Registry on the
CamelContext
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.
DataFormatTypeList 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
ValueBuilder.regex(String). Will be removed in Camel 2.0
MessageIdRepository.Map to
use to store the processed Message ID objects.
ExchangeConsumer of
Exchange instances to process Message instances.Message.Message body handling features but letting the derived class deal
with headers.Serializable version of a MethodMockEndpoint instancesXPathExpression or XQueryExpressionExchange.copy()
to get a new instance of an exchange or simply create a new
exchange object
Injector 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.MessageExchangePattern 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
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 objects typically implemented by a builder such as
XPathBuilderPredicate implementationsPredicate implementationsProcessor which proceeds on an InterceptorProcessor 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.
SequenceElementComparator.StreamCache instance, reset the cache to
enable reading from it again.
Endpoint can not 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
ResultHandlerEndpoint within a CamelContextRoute instances in a CamelContext for smart routing.Route.RoutingSlipType.ROUTING_SLIP_HEADER.
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
exchange to the next processor.
ExchangePatternSequence instance.
ResequencerEngine.deliver() and
ResequencerEngine.deliverNext() methods to send out re-ordered
elements.DataFormatService objectsRedeliveryPolicy.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)
ExceptionType to use
for handling thrown exceptions.
ExchangePattern into the exchange
FileLanguage
Exchanges.
ExpressionClause
AlreadyStoppedException to terminate processing.
ProcessorType.setHeader(String, Expression) instead. Will be removed in Camel 2.0.
FileComponent.HEADER_FILE_NAME
header and generate a new dynamic file
Pattern.
ProcessorType.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
BeanProcessor.setMethod(String). Will be removed in Camel 2.0.
MockEndpoint.assertIsSatisfied() will
wait on a latch until it is satisfied
FileProcessStrategy will be to use the
NoOpFileProcessStrategy
to not move or copy processed files
ProcessorType.transform(Expression) instead. Will be removed in Camel 2.0.
ProcessorType.transform() instead. Will be removed in Camel 2.0.
Pattern.
ExchangePattern (MEP) of this exchange to be customized.
ExchangePattern used to invoke this endpoint
FileLanguage
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
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.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).
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.
DataFormatTypeRedeliveryPolicy.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.ProcessorType.wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route.
ProcessorType.wrapProcessor(RouteContext, Processor)
to give the implementor an opportunity to wrap the target processor
in a route.
ProcessorType.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 DocumentURIResolver which is capable of loading files
from the classpath and file system.DataFormat
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||