Package org.apache.camel

Interface ProducerTemplate

  • All Superinterfaces:
    AutoCloseable, Service
    public interface ProducerTemplate
extends Service
    Template for working with Camel and sending Message instances in an Exchange to an Endpoint.

    Important: Read the javadoc of each method carefully to ensure the behavior of the method is understood. Some methods is for InOnly, others for InOut MEP. And some methods throws CamelExecutionException while others stores any thrown exception on the returned Exchange.

    The ProducerTemplate is thread safe.

    All the methods which sends a message may throw FailedToCreateProducerException in case the Producer could not be created. Or a NoSuchEndpointException if the endpoint could not be resolved. There may be other related exceptions being thrown which occurs before the Producer has started sending the message.

    All the sendBody or requestBody methods will return the content according to this strategy:

    • throws CamelExecutionException if processing failed during routing with the caused exception wrapped
    • The fault.body if there is a fault message set and its not null
    • Either IN or OUT body according to the message exchange pattern. If the pattern is Out capable then the OUT body is returned, otherwise IN.

    Before using the template it must be started. And when you are done using the template, make sure to Service.stop() the template.

    Important note on usage: See this FAQ entry before using.

    See Also:
    FluentProducerTemplate, ConsumerTemplate

    • Method Detail

      • getMaximumCacheSize

        int getMaximumCacheSize()
        Gets the maximum cache size used in the backing cache pools.
        Returns:
        the maximum cache size

      • setMaximumCacheSize

        void setMaximumCacheSize​(int maximumCacheSize)
        Sets a custom maximum cache size to use in the backing cache pools.
        Parameters:
        maximumCacheSize - the custom maximum cache size

      • getCurrentCacheSize

        int getCurrentCacheSize()
        Gets an approximated size of the current cached resources in the backing cache pools.
        Returns:
        the size of current cached resources

      • isThreadedAsyncMode

        boolean isThreadedAsyncMode()
        Reports if async* methods will dispatch 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.
        Returns:
        if async* methods will dispatch processing with the executor

      • setThreadedAsyncMode

        void setThreadedAsyncMode​(boolean useExecutor)
        Reports if async* methods will dispatch 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.
        Parameters:
        useExecutor - if async* methods will dispatch processing with the executor

      • getDefaultEndpoint

        Endpoint getDefaultEndpoint()
        Get the default endpoint to use if none is specified
        Returns:
        the default endpoint instance

      • setDefaultEndpoint

        void setDefaultEndpoint​(Endpoint defaultEndpoint)
        Sets the default endpoint to use if none is specified
        Parameters:
        defaultEndpoint - the default endpoint instance

      • setDefaultEndpointUri

        void setDefaultEndpointUri​(String endpointUri)
        Sets the default endpoint uri to use if none is specified
        Parameters:
        endpointUri - the default endpoint uri

      • setEventNotifierEnabled

        void setEventNotifierEnabled​(boolean enabled)
        Sets whether the EventNotifier should be used by this ProducerTemplate to send events about the Exchange being sent.

        By default this is enabled.

        Parameters:
        enabled - true to enable, false to disable.

      • isEventNotifierEnabled

        boolean isEventNotifierEnabled()
        Whether the EventNotifier should be used by this ProducerTemplate to send events about the Exchange being sent.
        Returns:
        true if enabled, false otherwise

      • cleanUp

        void cleanUp()
        Cleanup the cache (purging stale entries)

      • send

        Exchange 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 Exchange.getException().
        Parameters:
        exchange - the exchange to send
        Returns:
        the returned exchange

      • send

        Exchange 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 Exchange.getException().
        Parameters:
        processor - the transformer used to populate the new exchange Processor to populate the exchange
        Returns:
        the returned exchange

      • sendBody

        void sendBody​(Object body)
       throws CamelExecutionException
        Sends the body to the default endpoint

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndHeader

        void sendBodyAndHeader​(Object body,
                       String header,
                       Object headerValue)
                throws CamelExecutionException
        Sends the body to the default endpoint with a specified header and header value

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        header - the header name
        headerValue - the header value
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndProperty

        void sendBodyAndProperty​(Object body,
                         String property,
                         Object propertyValue)
                  throws CamelExecutionException
        Sends the body to the default endpoint with a specified property and property value

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        property - the property name
        propertyValue - the property value
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndHeaders

        void sendBodyAndHeaders​(Object body,
                        Map<String,​Object> headers)
                 throws CamelExecutionException
        Sends the body to the default endpoint with the specified headers and header values

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        headers - the headers
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • send

        Exchange 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 Exchange.getException().

        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        exchange - the exchange to send
        Returns:
        the returned exchange
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • send

        Exchange 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 Exchange.getException().

        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        processor - the transformer used to populate the new exchange Processor to populate the exchange
        Returns:
        the returned exchange
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • send

        Exchange 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 Exchange.getException().

        Parameters:
        endpoint - the endpoint to send the exchange to
        exchange - the exchange to send
        Returns:
        the returned exchange

      • send

        Exchange 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 Exchange.getException().

        Parameters:
        endpoint - the endpoint to send the exchange to
        processor - the transformer used to populate the new exchange Processor to populate the exchange
        Returns:
        the returned exchange

      • send

        Exchange 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 Exchange.getException().

        Parameters:
        endpoint - the endpoint to send the exchange to
        pattern - the message ExchangePattern such as ExchangePattern.InOnly or ExchangePattern.InOut
        processor - the transformer used to populate the new exchange
        resultProcessor - a processor to process the exchange when the send is complete. Processor to populate the exchange
        Returns:
        the returned exchange

      • sendBody

        void sendBody​(Endpoint endpoint,
              Object body)
       throws CamelExecutionException
        Send the body to an endpoint

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the payload
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBody

        void sendBody​(String endpointUri,
              Object body)
       throws CamelExecutionException
        Send the body to an endpoint

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the payload
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndHeader

        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

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload to send
        header - the header name
        headerValue - the header value
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndHeader

        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

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the Endpoint to send to
        body - the payload to send
        header - the header name
        headerValue - the header value
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndProperty

        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

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload to send
        property - the property name
        propertyValue - the property value
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndProperty

        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

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the Endpoint to send to
        body - the payload to send
        property - the property name
        propertyValue - the property value
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndHeaders

        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

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload to send
        headers - headers
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • sendBodyAndHeaders

        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

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the endpoint URI to send to
        body - the payload to send
        headers - headers
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • request

        Exchange request​(Endpoint endpoint,
                 Processor processor)
        Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern.

        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 Exchange.getException().

        Parameters:
        endpoint - the Endpoint to send to
        processor - the processor which will populate the exchange before sending
        Returns:
        the result (see class javadoc)

      • request

        Exchange request​(String endpointUri,
                 Processor processor)
        Sends an exchange to an endpoint using a supplied processor Uses an ExchangePattern.InOut message exchange pattern.

        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 Exchange.getException().

        Parameters:
        endpointUri - the endpoint URI to send to
        processor - the processor which will populate the exchange before sending
        Returns:
        the result (see class javadoc)

      • requestBody

        Object requestBody​(Object body)
            throws CamelExecutionException
        Sends the body to the default endpoint and returns the result content Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBody

        <T> T requestBody​(Object body,
                  Class<T> type)
           throws CamelExecutionException
        Sends the body to the default endpoint and returns the result content Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBody

        Object requestBody​(Endpoint endpoint,
                   Object body)
            throws CamelExecutionException
        Send the body to an endpoint returning any result output body. Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the Endpoint to send to
        body - the payload
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBody

        <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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the Endpoint to send to
        body - the payload
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBody

        Object requestBody​(String endpointUri,
                   Object body)
            throws CamelExecutionException
        Send the body to an endpoint returning any result output body. Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBody

        <T> T requestBody​(String endpointUri,
                  Object body,
                  Class<T> type)
           throws CamelExecutionException
        Send the body to an endpoint returning any result output body. Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeader

        Object requestBodyAndHeader​(Object body,
                            String header,
                            Object headerValue)
                     throws CamelExecutionException
        Sends the body to the default endpoint and returns the result content Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload
        header - the header name
        headerValue - the header value
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeader

        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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the Endpoint to send to
        body - the payload
        header - the header name
        headerValue - the header value
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeader

        <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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the Endpoint to send to
        body - the payload
        header - the header name
        headerValue - the header value
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeader

        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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload
        header - the header name
        headerValue - the header value
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeader

        <T> T requestBodyAndHeader​(String endpointUri,
                           Object body,
                           String header,
                           Object headerValue,
                           Class<T> type)
                    throws CamelExecutionException
        Send the body to an endpoint returning any result output body. Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload
        header - the header name
        headerValue - the header value
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeaders

        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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload to send
        headers - headers
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeaders

        <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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpointUri - the endpoint URI to send to
        body - the payload to send
        headers - headers
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeaders

        Object requestBodyAndHeaders​(Endpoint endpoint,
                             Object body,
                             Map<String,​Object> headers)
                      throws CamelExecutionException
        Sends the body to an endpoint with the specified headers and header values. Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the endpoint URI to send to
        body - the payload to send
        headers - headers
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeaders

        Object requestBodyAndHeaders​(Object body,
                             Map<String,​Object> headers)
                      throws CamelExecutionException
        Sends the body to the default endpoint and returns the result content Uses an ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        body - the payload to send
        headers - headers
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • requestBodyAndHeaders

        <T> T requestBodyAndHeaders​(Endpoint endpoint,
                            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 ExchangePattern.InOut message exchange pattern.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        endpoint - the endpoint URI to send to
        body - the payload to send
        headers - headers
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • setExecutorService

        void setExecutorService​(ExecutorService executorService)
        Sets a custom executor service to use for async messaging.
        Parameters:
        executorService - the executor service.

      • asyncSend

        CompletableFuture<Exchange> asyncSend​(String endpointUri,
                                      Exchange exchange)
        Sends an asynchronous exchange to the given endpoint.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        exchange - the exchange to send
        Returns:
        a handle to be used to get the response in the future

      • asyncSend

        CompletableFuture<Exchange> asyncSend​(String endpointUri,
                                      Processor processor)
        Sends an asynchronous exchange to the given endpoint. Important: The transformer processor is invoked by a thread from the underlying thread pool, when the task is running to send the exchange asynchronously. In other words mind about thread-safety when using the transformer processor.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        processor - the transformer used to populate the new exchange
        Returns:
        a handle to be used to get the response in the future

      • asyncSendBody

        CompletableFuture<Object> asyncSendBody​(String endpointUri,
                                        Object body)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOnly message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBody

        CompletableFuture<Object> asyncRequestBody​(String endpointUri,
                                           Object body)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeader

        CompletableFuture<Object> asyncRequestBodyAndHeader​(String endpointUri,
                                                    Object body,
                                                    String header,
                                                    Object headerValue)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        header - the header name
        headerValue - the header value
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeaders

        CompletableFuture<Object> asyncRequestBodyAndHeaders​(String endpointUri,
                                                     Object body,
                                                     Map<String,​Object> headers)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        headers - headers
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBody

        <T> CompletableFuture<T> asyncRequestBody​(String endpointUri,
                                          Object body,
                                          Class<T> type)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        type - the expected response type
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeader

        <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 ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        header - the header name
        headerValue - the header value
        type - the expected response type
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeaders

        <T> CompletableFuture<T> asyncRequestBodyAndHeaders​(String endpointUri,
                                                    Object body,
                                                    Map<String,​Object> headers,
                                                    Class<T> type)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        headers - headers
        type - the expected response type
        Returns:
        a handle to be used to get the response in the future

      • asyncSend

        CompletableFuture<Exchange> asyncSend​(Endpoint endpoint,
                                      Exchange exchange)
        Sends an asynchronous exchange to the given endpoint.
        Parameters:
        endpoint - the endpoint to send the exchange to
        exchange - the exchange to send
        Returns:
        a handle to be used to get the response in the future

      • asyncSend

        CompletableFuture<Exchange> asyncSend​(Endpoint endpoint,
                                      Processor processor)
        Sends an asynchronous exchange to the given endpoint. Important: The transformer processor is invoked by a thread from the underlying thread pool, when the task is running to send the exchange asynchronously. In other words mind about thread-safety when using the transformer processor.
        Parameters:
        endpoint - the endpoint to send the exchange to
        processor - the transformer used to populate the new exchange
        Returns:
        a handle to be used to get the response in the future

      • asyncSendBody

        CompletableFuture<Object> asyncSendBody​(Endpoint endpoint,
                                        Object body)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOnly message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBody

        CompletableFuture<Object> asyncRequestBody​(Endpoint endpoint,
                                           Object body)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeader

        CompletableFuture<Object> asyncRequestBodyAndHeader​(Endpoint endpoint,
                                                    Object body,
                                                    String header,
                                                    Object headerValue)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        header - the header name
        headerValue - the header value
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeaders

        CompletableFuture<Object> asyncRequestBodyAndHeaders​(Endpoint endpoint,
                                                     Object body,
                                                     Map<String,​Object> headers)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        headers - headers
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBody

        <T> CompletableFuture<T> asyncRequestBody​(Endpoint endpoint,
                                          Object body,
                                          Class<T> type)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        type - the expected response type
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeader

        <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 ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        header - the header name
        headerValue - the header value
        type - the expected response type
        Returns:
        a handle to be used to get the response in the future

      • asyncRequestBodyAndHeaders

        <T> CompletableFuture<T> asyncRequestBodyAndHeaders​(Endpoint endpoint,
                                                    Object body,
                                                    Map<String,​Object> headers,
                                                    Class<T> type)
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        headers - headers
        type - the expected response type
        Returns:
        a handle to be used to get the response in the future

      • extractFutureBody

        <T> T extractFutureBody​(Future<?> future,
                        Class<T> type)
                 throws CamelExecutionException
        Gets the response body from the future handle, will wait until the response is ready.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        future - the handle to get the response
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        CamelExecutionException - if the processing of the exchange failed

      • extractFutureBody

        <T> T extractFutureBody​(Future<?> future,
                        long timeout,
                        TimeUnit unit,
                        Class<T> type)
                 throws TimeoutException,
                        CamelExecutionException
        Gets the response body from the future handle, will wait at most the given time for the response to be ready.

        Notice: that if the processing of the exchange failed with an Exception it is thrown from this method as a CamelExecutionException with the caused exception wrapped.

        Parameters:
        future - the handle to get the response
        timeout - the maximum time to wait
        unit - the time unit of the timeout argument
        type - the expected response type
        Returns:
        the result (see class javadoc)
        Throws:
        TimeoutException - if the wait timed out
        CamelExecutionException - if the processing of the exchange failed

      • asyncCallback

        @Deprecated
CompletableFuture<Exchange> asyncCallback​(String endpointUri,
                                          Exchange exchange,
                                          Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous exchange to the given endpoint.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        exchange - the exchange to send
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallback

        @Deprecated
CompletableFuture<Exchange> asyncCallback​(Endpoint endpoint,
                                          Exchange exchange,
                                          Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous exchange to the given endpoint.
        Parameters:
        endpoint - the endpoint to send the exchange to
        exchange - the exchange to send
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallback

        @Deprecated
CompletableFuture<Exchange> asyncCallback​(String endpointUri,
                                          Processor processor,
                                          Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous exchange to the given endpoint using a supplied processor.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        processor - the transformer used to populate the new exchange Processor to populate the exchange
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallback

        @Deprecated
CompletableFuture<Exchange> asyncCallback​(Endpoint endpoint,
                                          Processor processor,
                                          Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous exchange to the given endpoint using a supplied processor.
        Parameters:
        endpoint - the endpoint to send the exchange to
        processor - the transformer used to populate the new exchange Processor to populate the exchange
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallbackSendBody

        @Deprecated
CompletableFuture<Object> asyncCallbackSendBody​(String endpointUri,
                                                Object body,
                                                Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOnly message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallbackSendBody

        @Deprecated
CompletableFuture<Object> asyncCallbackSendBody​(Endpoint endpoint,
                                                Object body,
                                                Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOnly message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallbackRequestBody

        @Deprecated
CompletableFuture<Object> asyncCallbackRequestBody​(String endpointUri,
                                                   Object body,
                                                   Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpointUri - the endpoint URI to send the exchange to
        body - the body to send
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future

      • asyncCallbackRequestBody

        @Deprecated
CompletableFuture<Object> asyncCallbackRequestBody​(Endpoint endpoint,
                                                   Object body,
                                                   Synchronization onCompletion)
        Deprecated.
        Sends an asynchronous body to the given endpoint. Uses an ExchangePattern.InOut message exchange pattern.
        Parameters:
        endpoint - the endpoint to send the exchange to
        body - the body to send
        onCompletion - callback invoked when exchange has been completed
        Returns:
        a handle to be used to get the response in the future