|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
GenericFileProcessStrategy.begin(GenericFileOperations, GenericFileEndpoint, org.apache.camel.Exchange, GenericFile)
operation.
Exchange events.List of values defined by the AbstractListAggregationStrategy.getValue(Exchange) call.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.
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.
ModelCamelContext.addRouteDefinition(org.apache.camel.model.RouteDefinition)
CamelContext must have an unique route id.
ModelCamelContext.addRouteDefinitions(java.util.Collection)
CamelContext must have an unique route id.
includeRoutes instead.
CamelContext have just been started.
Object to the given list
RouteBuilder which has extended capabilities when using
the advice with feature.AdviceWithTask tasks which are used by the AdviceWithRouteBuilder.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
KeyManagerFactory used to create
the KeyManagers represented by this object's configuration.
SecureRandom factory method used to create the
SecureRandom represented by this object's configuration.
TrustManagerFactory used to
create the TrustManagers represented by this object's
configuration.
Service has already been stopped.Expression object from an annotation on a field, property or method parameter
of a specified type.Converter objects and methods to pre-load
the TypeConverterRegistry of converters on startup.AntPathMatcher.Processor and
InterceptStrategy to do AOP in Camel.TimeClause predicate for message arriving.
ModelMBean.
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.Processor to an AsyncProcessor.AsyncProcessor objects.Processor to an AsyncProcessor.AsyncProcessor capable producer.Exception in a thread-safe wayExchange in a thread-safe wayMessageDataFormatBacklogTracer.BacklogTracer.DataFormatSimpleNode nodes.SSLContext appear as a normal SSLContext.SSLContext.BatchResequencerConfig.
EndpointResequencer.BatchResequencerConfig instance using default
values for batchSize (100) and batchTimeout
(1000L).
BatchResequencerConfig instance using the given
values for batchSize and batchTimeout.
BuilderSupport.method(Object) instead
BuilderSupport.method(Object, String) instead
BuilderSupport.method(Class) instead
BuilderSupport.method(Class, String) instead
Registry and use that to handle message dispatching.BeanInfo by the BeanComponentDataFormatbeanName.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.
MDCUnitOfWork leverages this
to ensure MDC is handled correctly during routing exchanges using the
asynchronous routing engine.
SubUnitOfWork, where sub (child) unit of works participate in a parent unit of work.
Predicate implementationsname to the bean object, so
that it can be looked up inside the CamelContext this command line tool
runs with.
Component which creates a BindingEndpoint from a
configured Binding instance and using the optional BindingComponent.setUriPrefix(String)
and BindingComponent.setUriPostfix(String) to create the underlying endpoint from the remaining URIBinding to a consumerBinding to an underlying Endpoint so that the binding processes messages
before its sent to the endpoint and processes messages received by the endpoint consumer before its passed
to the real consumer.binding:nameOfBinding:endpointURI
to extract the binding name which is then resolved from the registry and used to create a
BindingEndpoint from the underlying EndpointProducer which applies a Binding before invoking the underlying Producer on the EndpointDataFormatMessageXPathConstants.BOOLEAN
Breakpoint are used by the Debugger API.Breakpoint implementations to use as base class.ExceptionHandler that uses the DefaultConsumer to
process the caused exception to send the message into the Camel routing engine
which allows to let the routing engine handle the exception.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.ManagedBrowsableEndpointMBean.browseAllMessagesAsXml(Boolean) instead
BrowsableEndpoint within the given range, and returns the messages as a XML payload.
in into a BufferedInputStream
object and returns that.
out into a BufferedOutputStream
object and returns that.
reader into a BufferedReader object
and returns that.
writer into a BufferedWriter object
and returns that.
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 name
CamelContext.Predicate or Expression
to a ProcessorProcessorExchangeExchange.InitialContext which allows a Map to be used to create a
JNDI context.InvocationHandler which invokes a message
exchange on a camel EndpointLogger.Processor which just logs to a CamelLogger object which can be used
as an exception handler instead of using a dead letter queue.InitialContext which allows a Map to be used to create a
JNDI context.UnitOfWork failed with a number of caused exceptions.DataFormat.Processors in the route graph.UnitOfWorkProcessor that creates a child UnitOfWork that is
associated to a parent UnitOfWork.Registry and use that to handle message dispatching.MDCUnitOfWork
RouteBuilder has its private builder
to use, to avoid changes from one RouteBuilder to influence the
others.
BundleTracker.
IOHelper.close(java.io.Closeable, String, org.slf4j.Logger) instead
Exchange is complete.
AggregationStrategy which has callback when the aggregated Exchange is completed.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.DefaultComponentResolvernodes.CompositePackageScanFilter allows multiple
PackageScanFilters to be composed into a single filter.PerformanceCounter is used for tracking performance statistics on both a per
context and route level, by issuing callbacks on both when an event happens.Exchange matches when is being routed.Condition implementations to use as base class.EndpointConfiguration instancesSSLSessionContext, client or server, with the supplied session timeout.
SSLContext itself with direct setter calls.
SSLEngine based on the configurers in instance.
SSLServerSocketFactory based on the
configurers in this instance.
SSLSocketFactory based on the configurers in
this instance.
Exchange.
BeanHolderBeanTypeHolderEndpoint 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.Synchronization instance is
already contained on this exchange.
BundleTracker.
ContextScanDefinition represents a <contextScan/> element.Exchange.
AsyncProcessorConverterHelper.convert(org.apache.camel.Processor) instead
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.
ClassResolver which loads type converters
from a hardcoded list of classes.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
Processor which is used by a consumer on an endpoint to process the
message with the binding before its passed to the endpoint consumer producer.
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 is about to be sent to the endpoint (eg before).
EventObject when an Exchange has completely been sent to the endpoint (eg after).
Expression based on this model.
Expression based on this model.
FilterProcessor from the expression node.
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
Iterator iterates
over the corresponding Java primitive wrapper objects of the given elements
inside the value array.
KeyManagers based on this instance's configuration and the
KeyStore produced by the configuration returned from
KeyManagersParameters.getKeyStore().
KeyStoreParameters instance based off of the configuration state
of this instance.
LRUCache to be used.
LRUCache to be used.
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)
Predicate from the expression node.
ProcessorExchangePair which holds the processor and exchange to be send out.
Processor which is used by a producer on an endpoint to implement
the producer side binding before the message is sent to the underlying endpoint.
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.
SecureRandom instance initialized using the configured
algorithm and provider, if specified.
EventObject for a Service failed to start cleanly
EventObject for a Service failed to stop cleanly
SSLContext based on the related configuration options
of this instance.
StreamResequencer instance applying the given config.
XmlConverter.createTransformer(), will be removed in Camel 3.0
TrustManagers based on this instance's configuration and the
KeyStore produced by the configuration returned from
TrustManagersParameters.getKeyStore().
UnitOfWorkProcessor to be used for the sub route
DataFormatDataFormat to lookup using a referenceBinding which Marshals the message in the ProduceProcessor and
Unmarshals the message in the ConsumeProcessorDataFormat
options.DataFormat operations.RedeliveryPolicyDebugger with Exchanges being processed.Exchanges is being routed.AnnotationExpressionFactory.Producer for implementation inheritance,
which can process Exchanges asynchronously.BacklogTracer.CamelContext using JndiRegistry as registry,
but will silently fallback and use SimpleRegistry if JNDI cannot be used.
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.EndpointConfiguration.EventFactory.OnExceptionDefinition that should
handle the thrown exception.ExchangeExchange sequence by comparing
long values returned by this comparator's
expression.ExecutorServiceManager instead, will be removed in a future Camel releaseInjector which just uses reflection to
instantiate new objects using their zero argument constructor,
and then performing bean post processing using DefaultCamelBeanPostProcessor.LSResourceResolver which can included schema resources.ManagementStrategy.ModelMBean which can be used
to register the object in JMX.ManagementNameStrategy
This implementation will by default use a name pattern as #name# and in case
of a clash, then the pattern will fallback to be using the counter as #name#-#counter#.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.SubUnitOfWork combined
with a SubUnitOfWorkCallback to gather callbacks into this SubUnitOfWork stateExecutors for creating the thread pools.TimeoutMap.TraceEventMessage.DefaultTraceEventMessage based on the given node it was traced while processing
the current Exchange
ErrorHandler and ErrorListener which will log warnings,
and throws error and fatal as exception, which ensures those can be caught by Camel and dealt-with.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.Exchange is done.
Exchange.REDELIVERY_DELAY
and if not present, defaulting to RedeliveryPolicy.calculateRedeliveryDelay(long, int)
In order to prevent manipulation of the RedeliveryData state, the values of RedeliveryErrorHandler.RedeliveryData.redeliveryDelay
and RedeliveryErrorHandler.RedeliveryData.redeliveryCounter are copied in.
DirectEndpoint.DirectVmEndpoint.ManagementStrategy.
Exchange with the current result
CamelLogger.shouldLog() method first.
path against the given
pattern.
DomResultHandlerExchange is done.
Exchange type
then you need to invoke this method when you are done using the returned Exchange.
XPathBuilder.saxon() sets the default static XPathFactory which may have already been initialised
by previous XPath expressions
choice() DSL.
doTry() DSL.
ProcessorDefinitions to have special logic when using end() in the DSL
to return back to the intended parent.
Endpoint configuration as a pojo that can be manipulated and validated.DataFormat operations.Endpoint instancesEndpoint, Producer or
ProducerTemplate into a POJO.LRUSoftCache.Endpoint instances
Endpoint instances
Endpoint is about to be registered to the
endpoint registry in CamelContext.SubUnitOfWork.
resourceUri.
resourceUri.
producer
and second by aggregating input data and additional data.Enricher.
Enricher.
resourceUri.
ErrorHandlers.ErrorHandler implementations.Processor which evaluates an Expression
and stores the result as a property on the Exchange with the key
Exchange.EVALUATE_EXPRESSION_RESULT.DefaultRoute which starts with an
Event Driven Consumer
Use the API from CamelContext to control the lifecycle of a route,
such as starting and stopping using the CamelContext.startRoute(String)
and CamelContext.stopRoute(String) methods.PollingConsumer 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 has been created.Exchange into a String representation
usually to be used for logging or tracing purposes.Exchange objectsExchange to an Endpoint.Exchange has been sent to an Endpoint.ExecutorService.ExecutorService