Package | Description |
---|---|
org.apache.camel |
The core Camel API.
|
org.apache.camel.spi |
Service Provider Interfaces used by the Camel runtime which are plugin strategies.
|
Modifier and Type | Method and Description |
---|---|
Exchange |
AggregationStrategy.aggregate(Exchange oldExchange,
Exchange newExchange)
Aggregates an old and new exchange together to create a single combined exchange
|
Exchange |
Exchange.copy()
Creates a copy of the current message exchange so that it can be
forwarded to another destination
|
Exchange |
Endpoint.createExchange()
Create a new exchange for communicating with this endpoint
|
Exchange |
Endpoint.createExchange(ExchangePattern pattern)
Create a new exchange for communicating with this endpoint
with the specified
ExchangePattern such as whether its going
to be an ExchangePattern.InOnly or ExchangePattern.InOut exchange |
Exchange |
RuntimeExchangeException.getExchange()
Returns the exchange which caused the exception
Can be null
|
Exchange |
CamelExchangeException.getExchange()
Returns the exchange which caused the exception
|
Exchange |
ExpressionEvaluationException.getExchange() |
Exchange |
ExpectedBodyTypeException.getExchange() |
Exchange |
Message.getExchange()
Returns the exchange this message is related to
|
Exchange |
PollingConsumer.receive()
Waits until a message is available and then returns it.
|
Exchange |
ConsumerTemplate.receive(Endpoint endpoint)
Receives from the endpoint, waiting until there is a response.
|
Exchange |
ConsumerTemplate.receive(Endpoint endpoint,
long timeout)
Receives from the endpoint, waiting until there is a response
or the timeout occurs
Important: See
ConsumerTemplate.doneUoW(Exchange) |
Exchange |
PollingConsumer.receive(long timeout)
Attempts to receive a message exchange, waiting up to the given timeout
to expire if a message is not yet available.
|
Exchange |
ConsumerTemplate.receive(String endpointUri)
Receives from the endpoint, waiting until there is a response
Important: See
ConsumerTemplate.doneUoW(Exchange) |
Exchange |
ConsumerTemplate.receive(String endpointUri,
long timeout)
Receives from the endpoint, waiting until there is a response
or the timeout occurs
Important: See
ConsumerTemplate.doneUoW(Exchange) |
Exchange |
PollingConsumer.receiveNoWait()
Attempts to receive a message exchange immediately without waiting and
returning null if a message exchange is not available yet.
|
Exchange |
ConsumerTemplate.receiveNoWait(Endpoint endpoint)
Receives from the endpoint, not waiting for a response if non exists.
|
Exchange |
ConsumerTemplate.receiveNoWait(String endpointUri)
Receives from the endpoint, not waiting for a response if non exists.
|
Exchange |
ProducerTemplate.request(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Uses an
ExchangePattern.InOut message exchange pattern. |
Exchange |
ProducerTemplate.request(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Uses an
ExchangePattern.InOut message exchange pattern. |
Exchange |
FluentProducerTemplate.send()
Send to an endpoint (InOnly)
|
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(Exchange exchange)
Sends the exchange to the default endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(Processor processor)
Sends an exchange to the default endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(String endpointUri,
Exchange exchange)
Sends the exchange to the given endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(String endpointUri,
ExchangePattern pattern,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(String endpointUri,
Processor processor)
Sends an exchange to an endpoint using a supplied processor
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Modifier and Type | Method and Description |
---|---|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(Endpoint endpoint,
Exchange exchange,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(Endpoint endpoint,
Processor processor,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint using a supplied processor.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(String endpointUri,
Exchange exchange,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(String endpointUri,
Processor processor,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint using a supplied processor.
|
Future<Exchange> |
FluentProducerTemplate.asyncSend()
Sends asynchronously to the given endpoint (InOnly).
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(Endpoint endpoint,
Exchange exchange)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(Endpoint endpoint,
Processor processor)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(String endpointUri,
Exchange exchange)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(String endpointUri,
Processor processor)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
AsyncProcessor.processAsync(Exchange exchange) |
Modifier and Type | Method and Description |
---|---|
Exchange |
AggregationStrategy.aggregate(Exchange oldExchange,
Exchange newExchange)
Aggregates an old and new exchange together to create a single combined exchange
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(Endpoint endpoint,
Exchange exchange,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncCallback(String endpointUri,
Exchange exchange,
Synchronization onCompletion)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(Endpoint endpoint,
Exchange exchange)
Sends an asynchronous exchange to the given endpoint.
|
CompletableFuture<Exchange> |
ProducerTemplate.asyncSend(String endpointUri,
Exchange exchange)
Sends an asynchronous exchange to the given endpoint.
|
<T> T |
TypeConverter.convertTo(Class<T> type,
Exchange exchange,
Object value)
Converts the value to the specified type in the context of an exchange
Used when conversion requires extra information from the current
exchange (such as encoding).
|
StreamCache |
StreamCache.copy(Exchange exchange)
Create a copy of the stream.
|
static String |
CamelExchangeException.createExceptionMessage(String message,
Exchange exchange,
Throwable cause)
Creates an exception message with the provided details.
|
protected static String |
RuntimeExchangeException.createMessage(String message,
Exchange exchange) |
void |
ConsumerTemplate.doneUoW(Exchange exchange)
|
<T> T |
Expression.evaluate(Exchange exchange,
Class<T> type)
Returns the value of the expression on the given exchange
|
void |
Exchange.handoverCompletions(Exchange target)
Handover all the on completions from this exchange to the target exchange.
|
<T> T |
TypeConverter.mandatoryConvertTo(Class<T> type,
Exchange exchange,
Object value)
Converts the value to the specified type in the context of an exchange
Used when conversion requires extra information from the current
exchange (such as encoding).
|
boolean |
Predicate.matches(Exchange exchange)
Evaluates the predicate on the message exchange and returns true if this
exchange matches the predicate
|
String |
BinaryPredicate.matchesReturningFailureMessage(Exchange exchange)
Evaluates the predicate on the message exchange and returns null if this
exchange matches the predicate.
|
default void |
AggregationStrategy.onCompletion(Exchange exchange)
The aggregated
Exchange has completed
Important: This method must not throw any exceptions. |
default void |
AggregationStrategy.onOptimisticLockFailure(Exchange oldExchange,
Exchange newExchange)
Callback when the aggregated
Exchange fails to add
in the OptimisticLockingAggregationRepository because of
an OptimisticLockingAggregationRepository.OptimisticLockingException . |
default boolean |
AggregationStrategy.preComplete(Exchange oldExchange,
Exchange newExchange)
Determines if the aggregation should complete the current group, and start a new group, or the aggregation
should continue using the current group.
|
void |
Processor.process(Exchange exchange)
Processes the message exchange
|
boolean |
AsyncProcessor.process(Exchange exchange,
AsyncCallback callback)
Processes the message exchange.
|
CompletableFuture<Exchange> |
AsyncProcessor.processAsync(Exchange exchange) |
protected static String |
NoSuchPropertyException.reason(Exchange exchange,
String propertyName) |
protected static String |
NoSuchHeaderException.reason(Exchange exchange,
String propertyName) |
Exchange |
ProducerTemplate.send(Endpoint endpoint,
Exchange exchange)
Sends the exchange to the given endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(Exchange exchange)
Sends the exchange to the default endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
Exchange |
ProducerTemplate.send(String endpointUri,
Exchange exchange)
Sends the exchange to the given endpoint
Notice: that if the processing of the exchange failed with an Exception it is not thrown from this method, but you can access it from the returned exchange using getException() . |
default void |
AggregationStrategy.timeout(Exchange exchange,
int index,
int total,
long timeout)
A timeout occurred.
|
<T> T |
TypeConverter.tryConvertTo(Class<T> type,
Exchange exchange,
Object value)
Tries to convert the value to the specified type in the context of an exchange,
returning null if not possible to convert.
|
FluentProducerTemplate |
FluentProducerTemplate.withExchange(Exchange exchange)
Set the exchange to use for send.
|
static CamelExecutionException |
CamelExecutionException.wrapCamelExecutionException(Exchange exchange,
Throwable e)
Wraps the caused exception in a
CamelExecutionException if its not
already such an exception. |
Modifier and Type | Method and Description |
---|---|
FluentProducerTemplate |
FluentProducerTemplate.withExchange(Supplier<Exchange> exchangeSupplier)
Set the exchangeSupplier which will be invoke to get the exchange to be
used for send.
|
Modifier and Type | Method and Description |
---|---|
Exchange |
AggregationRepository.add(CamelContext camelContext,
String key,
Exchange exchange)
Add the given
Exchange under the correlation key. |
Exchange |
OptimisticLockingAggregationRepository.add(CamelContext camelContext,
String key,
Exchange oldExchange,
Exchange newExchange)
Add the given
Exchange under the correlation key. |
Exchange |
AggregationRepository.get(CamelContext camelContext,
String key)
Gets the given exchange with the correlation key
This method is always invoked for any incoming exchange in the aggregator.
|
Exchange |
ClaimCheckRepository.get(String key)
Gets the exchange from the repository.
|
Exchange |
ClaimCheckRepository.getAndRemove(String key)
Gets and removes the exchange from the repository.
|
Exchange |
CamelEvent.ExchangeEvent.getExchange() |
Exchange |
InflightRepository.InflightExchange.getExchange()
The exchange being inflight
|
Exchange |
AsyncProcessorAwaitManager.AwaitThread.getExchange()
The exchange being processed by the other thread.
|
Exchange |
ClaimCheckRepository.pop()
Pops the repository and returns the latest.
|
Exchange |
ConsumerCache.receive(Endpoint endpoint) |
Exchange |
ConsumerCache.receive(Endpoint endpoint,
long timeout) |
Exchange |
ConsumerCache.receiveNoWait(Endpoint endpoint) |
Exchange |
RecoverableAggregationRepository.recover(CamelContext camelContext,
String exchangeId)
Recovers the exchange with the given exchange id
|
Exchange |
ProducerCache.send(Endpoint endpoint,
Exchange exchange,
Processor resultProcessor)
Sends the exchange to the given endpoint.
|
Modifier and Type | Method and Description |
---|---|
CompletableFuture<Exchange> |
ProducerCache.asyncSendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange exchange,
CompletableFuture<Exchange> future)
Asynchronously sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
List<Exchange> |
BrowsableEndpoint.getExchanges()
Return the exchanges available on this endpoint
|
Modifier and Type | Method and Description |
---|---|
Exchange |
AggregationRepository.add(CamelContext camelContext,
String key,
Exchange exchange)
Add the given
Exchange under the correlation key. |
Exchange |
OptimisticLockingAggregationRepository.add(CamelContext camelContext,
String key,
Exchange oldExchange,
Exchange newExchange)
Add the given
Exchange under the correlation key. |
void |
InflightRepository.add(Exchange exchange)
Adds the exchange to the inflight registry to the total counter
|
void |
InflightRepository.add(Exchange exchange,
String routeId)
Adds the exchange to the inflight registry associated to the given route
|
default boolean |
IdempotentRepository.add(Exchange exchange,
String key)
Adds the key to the repository.
|
boolean |
ClaimCheckRepository.add(String key,
Exchange exchange)
Adds the exchange to the repository.
|
void |
CamelInternalProcessorAdvice.after(Exchange exchange,
T data)
Callback executed after processing a step in the route.
|
void |
ManagementInterceptStrategy.InstrumentationProcessor.after(Exchange exchange,
T data) |
void |
Breakpoint.afterProcess(Exchange exchange,
Processor processor,
NamedNode definition,
long timeTaken)
Callback invoked when the breakpoint was hit and the
Exchange has been processed (after). |
boolean |
Debugger.afterProcess(Exchange exchange,
Processor processor,
NamedNode definition,
long timeTaken)
Callback invoked when an
Exchange has been processed which allows implementators
to notify breakpoints. |
void |
UnitOfWork.afterProcess(Processor processor,
Exchange exchange,
AsyncCallback callback,
boolean doneSync)
Strategy for optional work to be executed after the processing
|
void |
UnitOfWork.afterRoute(Exchange exchange,
Route route)
Invoked when this unit of work is done being routed by the given route.
|
boolean |
HeaderFilterStrategy.applyFilterToCamelHeaders(String headerName,
Object headerValue,
Exchange exchange)
Applies filtering logic to Camel Message header that is
going to be copied to target message such as CXF and JMS message.
|
boolean |
HeaderFilterStrategy.applyFilterToExternalHeaders(String headerName,
Object headerValue,
Exchange exchange)
Applies filtering logic to an external message header such
as CXF and JMS message that is going to be copied to Camel
message header.
|
CompletableFuture<Exchange> |
ProducerCache.asyncSendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange exchange,
CompletableFuture<Exchange> future)
Asynchronously sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
T |
CamelInternalProcessorAdvice.before(Exchange exchange)
Callback executed before processing a step in the route.
|
T |
ManagementInterceptStrategy.InstrumentationProcessor.before(Exchange exchange) |
void |
Breakpoint.beforeProcess(Exchange exchange,
Processor processor,
NamedNode definition)
Callback invoked when the breakpoint was hit and the
Exchange is about to be processed (before). |
boolean |
Debugger.beforeProcess(Exchange exchange,
Processor processor,
NamedNode definition)
Callback invoked when an
Exchange is about to be processed which allows implementators
to notify breakpoints. |
AsyncCallback |
UnitOfWork.beforeProcess(Processor processor,
Exchange exchange,
AsyncCallback callback)
Strategy for optional work to be execute before processing
For example the
org.apache.camel.impl.MDCUnitOfWork leverages this
to ensure MDC is handled correctly during routing exchanges using the
asynchronous routing engine. |
void |
UnitOfWork.beforeRoute(Exchange exchange,
Route route)
Invoked when this unit of work is about to be routed by the given route.
|
void |
UnitOfWork.beginSubUnitOfWork(Exchange exchange)
Begins a
SubUnitOfWork , where sub (child) unit of works participate in a parent unit of work. |
StreamCache |
StreamCachingStrategy.cache(Exchange exchange)
Caches the body aas a
StreamCache . |
default boolean |
IdempotentRepository.confirm(Exchange exchange,
String key)
Confirms the key, after the exchange has been processed successfully.
|
default boolean |
IdempotentRepository.contains(Exchange exchange,
String key)
Returns true if this repository contains the specified element.
|
UnitOfWork |
UnitOfWork.createChildUnitOfWork(Exchange childExchange)
Create a child unit of work, which is associated to this unit of work as its parent.
|
CamelEvent |
EventFactory.createExchangeCompletedEvent(Exchange exchange)
Creates an
CamelEvent when an Exchange has been completed successfully |
CamelEvent |
EventFactory.createExchangeCreatedEvent(Exchange exchange)
Creates an
CamelEvent when an Exchange has been created |
CamelEvent |
EventFactory.createExchangeFailedEvent(Exchange exchange)
Creates an
CamelEvent when an Exchange has failed |
CamelEvent |
EventFactory.createExchangeFailureHandledEvent(Exchange exchange,
Processor failureHandler,
boolean deadLetterChannel,
String deadLetterUri)
Creates an
CamelEvent when an Exchange has failed
but was handled by the Camel error handlers such as an dead letter channel, or a doTry .. |
CamelEvent |
EventFactory.createExchangeFailureHandlingEvent(Exchange exchange,
Processor failureHandler,
boolean deadLetterChannel,
String deadLetterUri)
Creates an
CamelEvent when an Exchange has failed
but is being handled by the Camel error handlers such as an dead letter channel, or a doTry .. |
CamelEvent |
EventFactory.createExchangeRedeliveryEvent(Exchange exchange,
int attempt)
Creates an
CamelEvent when an Exchange is about to be redelivered |
CamelEvent |
EventFactory.createExchangeSendingEvent(Exchange exchange,
Endpoint endpoint)
Creates an
CamelEvent when an Exchange is about to be sent to the endpoint (eg before). |
CamelEvent |
EventFactory.createExchangeSentEvent(Exchange exchange,
Endpoint endpoint,
long timeTaken)
Creates an
CamelEvent when an Exchange has completely been sent to the endpoint (eg after). |
Processor |
SendDynamicAware.createPostProcessor(Exchange exchange,
SendDynamicAware.DynamicAwareEntry entry)
Creates an optional post
Processor that will be executed afterwards
when the message has been sent dynamic. |
Processor |
SendDynamicAware.createPreProcessor(Exchange exchange,
SendDynamicAware.DynamicAwareEntry entry)
|
CamelEvent |
EventFactory.createStepCompletedEvent(Exchange exchange,
String stepId)
Creates an
CamelEvent when a step has been completed successfully |
CamelEvent |
EventFactory.createStepFailedEvent(Exchange exchange,
String stepId)
Creates an
CamelEvent when a step has failed |
CamelEvent |
EventFactory.createStepStartedEvent(Exchange exchange,
String stepId)
Creates an
CamelEvent when a step has been started |
UnitOfWork |
UnitOfWorkFactory.createUnitOfWork(Exchange exchange)
Creates a new
UnitOfWork |
boolean |
ProducerCache.AsyncProducerCallback.doInAsyncProducer(AsyncProducer asyncProducer,
Exchange exchange,
AsyncCallback callback)
Performs operation on the given producer to send the given exchange.
|
boolean |
ProducerCache.doInAsyncProducer(Endpoint endpoint,
Exchange exchange,
AsyncCallback callback,
ProducerCache.AsyncProducerCallback producerCallback)
Sends an exchange to an endpoint using a supplied callback supporting the asynchronous routing engine.
|
void |
UnitOfWork.done(Exchange exchange)
Invoked when this unit of work has been completed, whether it has failed or completed
|
void |
UnitOfWork.endSubUnitOfWork(Exchange exchange)
Ends a
SubUnitOfWork . |
String |
ExchangeFormatter.format(Exchange exchange)
Generates a string representation of the exchange
|
void |
ExceptionHandler.handleException(String message,
Exchange exchange,
Throwable exception)
Handles the given exception
|
void |
UnitOfWork.handoverSynchronization(Exchange target)
Handover all the registered synchronizations to the target
Exchange . |
void |
UnitOfWork.handoverSynchronization(Exchange target,
Predicate<Synchronization> filter)
Handover all the registered synchronizations to the target
Exchange . |
void |
AsyncProcessorAwaitManager.interrupt(Exchange exchange)
To interrupt an exchange which may seem as stuck, to force the exchange to continue,
allowing any blocking thread to be released.
|
void |
DataFormat.marshal(Exchange exchange,
Object graph,
OutputStream stream)
Marshals the object to the given Stream.
|
boolean |
Condition.matchEvent(Exchange exchange,
CamelEvent.ExchangeEvent event)
Does the condition match
|
boolean |
Condition.matchProcess(Exchange exchange,
Processor processor,
NamedNode definition)
Does the condition match
|
void |
SynchronizationRouteAware.onAfterRoute(Route route,
Exchange exchange)
Invoked after the
Exchange has been routed by the given route. |
void |
SynchronizationRouteAware.onBeforeRoute(Route route,
Exchange exchange)
Invoked before the
Exchange is being routed by the given route. |
void |
Synchronization.onComplete(Exchange exchange)
Called when the processing of the message exchange is complete
|
void |
SubUnitOfWorkCallback.onDone(Exchange exchange)
The exchange is done.
|
boolean |
Debugger.onEvent(Exchange exchange,
CamelEvent.ExchangeEvent event)
Callback invoked when an
Exchange is being processed which allows implementators
to notify breakpoints. |
void |
Breakpoint.onEvent(Exchange exchange,
CamelEvent.ExchangeEvent event,
NamedNode definition)
|
void |
RoutePolicy.onExchangeBegin(Route route,
Exchange exchange)
|
void |
RoutePolicy.onExchangeDone(Route route,
Exchange exchange)
|
void |
SubUnitOfWorkCallback.onExhausted(Exchange exchange)
The exchange is exhausted, by a redeliverable error handler.
|
void |
Synchronization.onFailure(Exchange exchange)
Called when the processing of the message exchange has failed for some reason.
|
String |
LogListener.onLog(Exchange exchange,
CamelLogger camelLogger,
String message)
Invoked right before Log component or Log EIP logs.
|
SendDynamicAware.DynamicAwareEntry |
SendDynamicAware.prepare(Exchange exchange,
String uri,
String originalUri)
Prepares for using optimised dynamic to by parsing the uri and returning an entry of details that are
used for creating the pre and post processors, and the static uri.
|
void |
AsyncProcessorAwaitManager.process(AsyncProcessor processor,
Exchange exchange)
Process the given exchange sychronously.
|
void |
ClaimCheckRepository.push(Exchange exchange)
Pushes the exchange on top of the repository.
|
void |
AggregationRepository.remove(CamelContext camelContext,
String key,
Exchange exchange)
Removes the exchange with the given correlation key, which should happen
when an
Exchange is completed
Important: This method is not invoked if only one exchange was completed, and therefore
the exchange does not need to be added to a repository, as its completed immediately. |
void |
OptimisticLockingAggregationRepository.remove(CamelContext camelContext,
String key,
Exchange exchange)
Removes the given Exchange when both the supplied key and Exchange are present in the repository.
|
void |
InflightRepository.remove(Exchange exchange)
Removes the exchange from the inflight registry to the total counter
|
void |
InflightRepository.remove(Exchange exchange,
String routeId)
Removes the exchange from the inflight registry removing association to the given route
|
default boolean |
IdempotentRepository.remove(Exchange exchange,
String key)
Removes the key from the repository.
|
String |
SendDynamicAware.resolveStaticUri(Exchange exchange,
SendDynamicAware.DynamicAwareEntry entry)
|
Exchange |
ProducerCache.send(Endpoint endpoint,
Exchange exchange,
Processor resultProcessor)
Sends the exchange to the given endpoint.
|
Object |
DataFormat.unmarshal(Exchange exchange,
InputStream stream)
Unmarshals the given stream into an object.
|
Modifier and Type | Method and Description |
---|---|
CompletableFuture<Exchange> |
ProducerCache.asyncSendExchange(Endpoint endpoint,
ExchangePattern pattern,
Processor processor,
Processor resultProcessor,
Exchange exchange,
CompletableFuture<Exchange> future)
Asynchronously sends an exchange to an endpoint using a supplied
Processor to populate the exchange |
Apache Camel