/**
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package org.apache.camel;
import java.util.Map;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Future;
import java.util.concurrent.TimeUnit;
import java.util.concurrent.TimeoutException;
import org.apache.camel.spi.Synchronization;
/**
* Template for working with Camel and sending {@link Message} instances in an
* {@link Exchange} to an {@link Endpoint}.
* <br/>
* <p/><b>Important:</b> Read the javadoc of each method carefully to ensure the behavior of the method is understood.
* Some methods is for <tt>InOnly</tt>, others for <tt>InOut</tt> MEP. And some methods throws
* {@link org.apache.camel.CamelExecutionException} while others stores any thrown exception on the returned
* {@link Exchange}.
* <br/>
* <p/>The {@link ProducerTemplate} is <b>thread safe</b>.
* <br/>
* <p/>All the methods which sends a message may throw {@link FailedToCreateProducerException} in
* case the {@link Producer} could not be created. Or a {@link NoSuchEndpointException} if the endpoint could
* not be resolved. There may be other related exceptions being thrown which occurs <i>before</i> the {@link Producer}
* has started sending the message.
* <br/>
* <p/>All the sendBody or requestBody methods will return the content according to this strategy:
* <ul>
* <li>throws {@link org.apache.camel.CamelExecutionException} if processing failed <i>during</i> routing
* with the caused exception wrapped</li>
* <li>The <tt>fault.body</tt> if there is a fault message set and its not <tt>null</tt></li>
* <li>Either <tt>IN</tt> or <tt>OUT</tt> body according to the message exchange pattern. If the pattern is
* Out capable then the <tt>OUT</tt> body is returned, otherwise <tt>IN</tt>.
* </ul>
* <br/>
* <p/>Before using the template it must be started.
* And when you are done using the template, make sure to {@link #stop()} the template.
* <br/>
* <p/><b>Important note on usage:</b> See this
* <a href="http://camel.apache.org/why-does-camel-use-too-many-threads-with-producertemplate.html">FAQ entry</a>
* before using.
*
* @see FluentProducerTemplate
* @see ConsumerTemplate
*/
public interface ProducerTemplate extends Service {
/**
* Get the {@link CamelContext}
*
* @return camelContext the Camel context
*/
CamelContext getCamelContext();
// Configuration methods
// -----------------------------------------------------------------------
/**
* Gets the maximum cache size used in the backing cache pools.
*
* @return the maximum cache size
*/
int getMaximumCacheSize();
/**
* Sets a custom maximum cache size to use in the backing cache pools.
*
* @param maximumCacheSize the custom maximum cache size
*/
void setMaximumCacheSize(int maximumCacheSize);
/**
* Gets an approximated size of the current cached resources in the backing cache pools.
*
* @return the size of current cached resources
*/
int getCurrentCacheSize();
/**
* Reports if async* methods will dispath processing from the calling thread (false) or through executor (true).
* In both cases asynchronous engine will be used, so this non-threaded can be useful for high-speed
* non-blocking processing.
* @return if async* methods will dipatch processing with the executor
*/
boolean isThreadedAsyncMode();
/**
* Reports if async* methods will dispath processing from the calling thread (false) or through executor (true).
* In both cases asynchronous engine will be used, so this non-threaded can be useful for high-speed
* non-blocking processing.
* @param useExecutor if async* methods will dipatch processing with the executor
*/
void setThreadedAsyncMode(boolean useExecutor);
/**
* Get the default endpoint to use if none is specified
*
* @return the default endpoint instance
*/
Endpoint getDefaultEndpoint();
/**
* Sets the default endpoint to use if none is specified
*
* @param defaultEndpoint the default endpoint instance
*/
void setDefaultEndpoint(Endpoint defaultEndpoint);
/**
* Sets the default endpoint uri to use if none is specified
*
* @param endpointUri the default endpoint uri
*/
void setDefaultEndpointUri(String endpointUri);
/**
* Sets whether the {@link org.apache.camel.spi.EventNotifier} should be
* used by this {@link ProducerTemplate} to send events about the {@link Exchange}
* being sent.
* <p/>
* By default this is enabled.
*
* @param enabled <tt>true</tt> to enable, <tt>false</tt> to disable.
*/
void setEventNotifierEnabled(boolean enabled);
/**
* Whether the {@link org.apache.camel.spi.EventNotifier} should be
* used by this {@link ProducerTemplate} to send events about the {@link Exchange}
* being sent.
*
* @return <tt>true</tt> if enabled, <tt>false</tt> otherwise
*/
boolean isEventNotifierEnabled();
/**
* Cleanup the cache (purging stale entries)
*/
void cleanUp();
// Synchronous methods
// -----------------------------------------------------------------------
/**
* Sends the exchange to the default endpoint
* <br/><br/>
* <b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param exchange the exchange to send
* @return the returned exchange
*/
Exchange send(Exchange exchange);
/**
* Sends an exchange to the default endpoint using a supplied processor
* <br/><br/>
* <b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @return the returned exchange
*/
Exchange send(Processor processor);
/**
* Sends the body to the default endpoint
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBody(Object body) throws CamelExecutionException;
/**
* Sends the body to the default endpoint with a specified header and header value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @param header the header name
* @param headerValue the header value
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndHeader(Object body, String header, Object headerValue) throws CamelExecutionException;
/**
* Sends the body to the default endpoint with a specified property and property value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @param property the property name
* @param propertyValue the property value
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndProperty(Object body, String property, Object propertyValue) throws CamelExecutionException;
/**
* Sends the body to the default endpoint with the specified headers and header values
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @param headers the headers
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndHeaders(Object body, Map<String, Object> headers) throws CamelExecutionException;
// Allow sending to arbitrary endpoints
// -----------------------------------------------------------------------
/**
* Sends the exchange to the given endpoint
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param exchange the exchange to send
* @return the returned exchange
* @throws CamelExecutionException if the processing of the exchange failed
*/
Exchange send(String endpointUri, Exchange exchange);
/**
* Sends an exchange to an endpoint using a supplied processor
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @return the returned exchange
* @throws CamelExecutionException if the processing of the exchange failed
*/
Exchange send(String endpointUri, Processor processor);
/**
* Sends an exchange to an endpoint using a supplied processor
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @return the returned exchange
*/
Exchange send(String endpointUri, ExchangePattern pattern, Processor processor);
/**
* Sends the exchange to the given endpoint
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpoint the endpoint to send the exchange to
* @param exchange the exchange to send
* @return the returned exchange
*/
Exchange send(Endpoint endpoint, Exchange exchange);
/**
* Sends an exchange to an endpoint using a supplied processor
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpoint the endpoint to send the exchange to
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @return the returned exchange
*/
Exchange send(Endpoint endpoint, Processor processor);
/**
* Sends an exchange to an endpoint using a supplied processor
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpoint the endpoint to send the exchange to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @return the returned exchange
*/
Exchange send(Endpoint endpoint, ExchangePattern pattern, Processor processor);
/**
* Sends an exchange to an endpoint using a supplied processor
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpoint the endpoint to send the exchange to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param processor the transformer used to populate the new exchange
* @param resultProcessor a processor to process the exchange when the send is complete.
* {@link Processor} to populate the exchange
* @return the returned exchange
*/
Exchange send(Endpoint endpoint, ExchangePattern pattern, Processor processor, Processor resultProcessor);
/**
* Send the body to an endpoint
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the endpoint to send the exchange to
* @param body the payload
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBody(Endpoint endpoint, Object body) throws CamelExecutionException;
/**
* Send the body to an endpoint
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the payload
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBody(String endpointUri, Object body) throws CamelExecutionException;
/**
* Send the body to an endpoint with the given {@link ExchangePattern}
* returning any result output body
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the endpoint to send the exchange to
* @param body the payload
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBody(Endpoint endpoint, ExchangePattern pattern, Object body) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBody(String endpointUri, ExchangePattern pattern, Object body) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified header and header value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload to send
* @param header the header name
* @param headerValue the header value
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndHeader(String endpointUri, Object body, String header, Object headerValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified header and header value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param body the payload to send
* @param header the header name
* @param headerValue the header value
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndHeader(Endpoint endpoint, Object body, String header, Object headerValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified header and header value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload to send
* @param header the header name
* @param headerValue the header value
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBodyAndHeader(Endpoint endpoint, ExchangePattern pattern, Object body,
String header, Object headerValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified header and header value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint URI to send to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload to send
* @param header the header name
* @param headerValue the header value
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBodyAndHeader(String endpoint, ExchangePattern pattern, Object body,
String header, Object headerValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified property and property value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload to send
* @param property the property name
* @param propertyValue the property value
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndProperty(String endpointUri, Object body, String property, Object propertyValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified property and property value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param body the payload to send
* @param property the property name
* @param propertyValue the property value
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndProperty(Endpoint endpoint, Object body, String property, Object propertyValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified property and property value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload to send
* @param property the property name
* @param propertyValue the property value
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBodyAndProperty(Endpoint endpoint, ExchangePattern pattern, Object body,
String property, Object propertyValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with a specified property and property value
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint URI to send to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload to send
* @param property the property name
* @param propertyValue the property value
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBodyAndProperty(String endpoint, ExchangePattern pattern, Object body,
String property, Object propertyValue) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload to send
* @param headers headers
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndHeaders(String endpointUri, Object body, Map<String, Object> headers) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the endpoint URI to send to
* @param body the payload to send
* @param headers headers
* @throws CamelExecutionException if the processing of the exchange failed
*/
void sendBodyAndHeaders(Endpoint endpoint, Object body, Map<String, Object> headers) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload to send
* @param headers headers
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBodyAndHeaders(String endpointUri, ExchangePattern pattern, Object body,
Map<String, Object> headers) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the endpoint URI to send to
* @param pattern the message {@link ExchangePattern} such as
* {@link ExchangePattern#InOnly} or {@link ExchangePattern#InOut}
* @param body the payload to send
* @param headers headers
* @return the result if {@link ExchangePattern} is OUT capable, otherwise <tt>null</tt>
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object sendBodyAndHeaders(Endpoint endpoint, ExchangePattern pattern, Object body,
Map<String, Object> headers) throws CamelExecutionException;
// Methods using an InOut ExchangePattern
// -----------------------------------------------------------------------
/**
* Sends an exchange to an endpoint using a supplied processor
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpoint the Endpoint to send to
* @param processor the processor which will populate the exchange before sending
* @return the result (see class javadoc)
*/
Exchange request(Endpoint endpoint, Processor processor);
/**
* Sends an exchange to an endpoint using a supplied processor
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is <b>not</b> thrown from this method, but you can access it from the returned exchange using
* {@link org.apache.camel.Exchange#getException()}.
*
* @param endpointUri the endpoint URI to send to
* @param processor the processor which will populate the exchange before sending
* @return the result (see class javadoc)
*/
Exchange request(String endpointUri, Processor processor);
/**
* Sends the body to the default endpoint and returns the result content
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBody(Object body) throws CamelExecutionException;
/**
* Sends the body to the default endpoint and returns the result content
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBody(Object body, Class<T> type) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param body the payload
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBody(Endpoint endpoint, Object body) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param body the payload
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBody(Endpoint endpoint, Object body, Class<T> type) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBody(String endpointUri, Object body) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBody(String endpointUri, Object body, Class<T> type) throws CamelExecutionException;
/**
* Sends the body to the default endpoint and returns the result content
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload
* @param header the header name
* @param headerValue the header value
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBodyAndHeader(Object body, String header, Object headerValue) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param body the payload
* @param header the header name
* @param headerValue the header value
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBodyAndHeader(Endpoint endpoint, Object body, String header, Object headerValue) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the Endpoint to send to
* @param body the payload
* @param header the header name
* @param headerValue the header value
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBodyAndHeader(Endpoint endpoint, Object body, String header, Object headerValue, Class<T> type) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload
* @param header the header name
* @param headerValue the header value
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBodyAndHeader(String endpointUri, Object body, String header, Object headerValue) throws CamelExecutionException;
/**
* Send the body to an endpoint returning any result output body.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload
* @param header the header name
* @param headerValue the header value
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBodyAndHeader(String endpointUri, Object body, String header, Object headerValue, Class<T> type) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload to send
* @param headers headers
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBodyAndHeaders(String endpointUri, Object body, Map<String, Object> headers) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpointUri the endpoint URI to send to
* @param body the payload to send
* @param headers headers
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBodyAndHeaders(String endpointUri, Object body, Map<String, Object> headers, Class<T> type) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the endpoint URI to send to
* @param body the payload to send
* @param headers headers
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBodyAndHeaders(Endpoint endpoint, Object body, Map<String, Object> headers) throws CamelExecutionException;
/**
* Sends the body to the default endpoint and returns the result content
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param body the payload to send
* @param headers headers
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
Object requestBodyAndHeaders(Object body, Map<String, Object> headers) throws CamelExecutionException;
/**
* Sends the body to an endpoint with the specified headers and header values.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
* <br/><br/>
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param endpoint the endpoint URI to send to
* @param body the payload to send
* @param headers headers
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T requestBodyAndHeaders(Endpoint endpoint, Object body, Map<String, Object> headers, Class<T> type) throws CamelExecutionException;
// Asynchronous methods
// -----------------------------------------------------------------------
/**
* Sets a custom executor service to use for async messaging.
*
* @param executorService the executor service.
*/
void setExecutorService(ExecutorService executorService);
/**
* Sends an asynchronous exchange to the given endpoint.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param exchange the exchange to send
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncSend(String endpointUri, Exchange exchange);
/**
* Sends an asynchronous exchange to the given endpoint.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param processor the transformer used to populate the new exchange
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncSend(String endpointUri, Processor processor);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOnly} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncSendBody(String endpointUri, Object body);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncRequestBody(String endpointUri, Object body);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param header the header name
* @param headerValue the header value
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncRequestBodyAndHeader(String endpointUri, Object body, String header, Object headerValue);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param headers headers
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncRequestBodyAndHeaders(String endpointUri, Object body, Map<String, Object> headers);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param type the expected response type
* @return a handle to be used to get the response in the future
*/
<T> CompletableFuture<T> asyncRequestBody(String endpointUri, Object body, Class<T> type);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param header the header name
* @param headerValue the header value
* @param type the expected response type
* @return a handle to be used to get the response in the future
*/
<T> CompletableFuture<T> asyncRequestBodyAndHeader(String endpointUri, Object body, String header, Object headerValue, Class<T> type);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param headers headers
* @param type the expected response type
* @return a handle to be used to get the response in the future
*/
<T> CompletableFuture<T> asyncRequestBodyAndHeaders(String endpointUri, Object body, Map<String, Object> headers, Class<T> type);
/**
* Sends an asynchronous exchange to the given endpoint.
*
* @param endpoint the endpoint to send the exchange to
* @param exchange the exchange to send
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncSend(Endpoint endpoint, Exchange exchange);
/**
* Sends an asynchronous exchange to the given endpoint.
*
* @param endpoint the endpoint to send the exchange to
* @param processor the transformer used to populate the new exchange
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncSend(Endpoint endpoint, Processor processor);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOnly} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncSendBody(Endpoint endpoint, Object body);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncRequestBody(Endpoint endpoint, Object body);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param header the header name
* @param headerValue the header value
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncRequestBodyAndHeader(Endpoint endpoint, Object body, String header, Object headerValue);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param headers headers
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncRequestBodyAndHeaders(Endpoint endpoint, Object body, Map<String, Object> headers);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param type the expected response type
* @return a handle to be used to get the response in the future
*/
<T> CompletableFuture<T> asyncRequestBody(Endpoint endpoint, Object body, Class<T> type);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param header the header name
* @param headerValue the header value
* @param type the expected response type
* @return a handle to be used to get the response in the future
*/
<T> CompletableFuture<T> asyncRequestBodyAndHeader(Endpoint endpoint, Object body, String header, Object headerValue, Class<T> type);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param headers headers
* @param type the expected response type
* @return a handle to be used to get the response in the future
*/
<T> CompletableFuture<T> asyncRequestBodyAndHeaders(Endpoint endpoint, Object body, Map<String, Object> headers, Class<T> type);
/**
* Gets the response body from the future handle, will wait until the response is ready.
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param future the handle to get the response
* @param type the expected response type
* @return the result (see class javadoc)
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T extractFutureBody(Future<?> future, Class<T> type) throws CamelExecutionException;
/**
* Gets the response body from the future handle, will wait at most the given time for the response to be ready.
* <p/><b>Notice:</b> that if the processing of the exchange failed with an Exception
* it is thrown from this method as a {@link org.apache.camel.CamelExecutionException} with
* the caused exception wrapped.
*
* @param future the handle to get the response
* @param timeout the maximum time to wait
* @param unit the time unit of the timeout argument
* @param type the expected response type
* @return the result (see class javadoc)
* @throws java.util.concurrent.TimeoutException if the wait timed out
* @throws CamelExecutionException if the processing of the exchange failed
*/
<T> T extractFutureBody(Future<?> future, long timeout, TimeUnit unit, Class<T> type) throws TimeoutException, CamelExecutionException;
// Asynchronous methods with callback
// -----------------------------------------------------------------------
/**
* Sends an asynchronous exchange to the given endpoint.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param exchange the exchange to send
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncCallback(String endpointUri, Exchange exchange, Synchronization onCompletion);
/**
* Sends an asynchronous exchange to the given endpoint.
*
* @param endpoint the endpoint to send the exchange to
* @param exchange the exchange to send
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncCallback(Endpoint endpoint, Exchange exchange, Synchronization onCompletion);
/**
* Sends an asynchronous exchange to the given endpoint using a supplied processor.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncCallback(String endpointUri, Processor processor, Synchronization onCompletion);
/**
* Sends an asynchronous exchange to the given endpoint using a supplied processor.
*
* @param endpoint the endpoint to send the exchange to
* @param processor the transformer used to populate the new exchange
* {@link Processor} to populate the exchange
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Exchange> asyncCallback(Endpoint endpoint, Processor processor, Synchronization onCompletion);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOnly} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncCallbackSendBody(String endpointUri, Object body, Synchronization onCompletion);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOnly} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncCallbackSendBody(Endpoint endpoint, Object body, Synchronization onCompletion);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpointUri the endpoint URI to send the exchange to
* @param body the body to send
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncCallbackRequestBody(String endpointUri, Object body, Synchronization onCompletion);
/**
* Sends an asynchronous body to the given endpoint.
* Uses an {@link ExchangePattern#InOut} message exchange pattern.
*
* @param endpoint the endpoint to send the exchange to
* @param body the body to send
* @param onCompletion callback invoked when exchange has been completed
* @return a handle to be used to get the response in the future
*/
CompletableFuture<Object> asyncCallbackRequestBody(Endpoint endpoint, Object body, Synchronization onCompletion);
}