org.apache.camel.util
Class ExchangeHelper

java.lang.Object
  extended by org.apache.camel.util.ExchangeHelper

public final class ExchangeHelper
extends Object

Some helper methods for working with Exchange objects

Version:
$Revision: 20094 $

Method Summary
static
<T> T
convertToMandatoryType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type or throws an exception
static
<T> T
convertToType(Exchange exchange, Class<T> type, Object value)
          Converts the value to the given expected type returning null if it could not be converted
static void copyResults(Exchange result, Exchange source)
          Copies the results of a message exchange from the source exchange to the result exchange which will copy the out and fault message contents and the exception
static void copyResultsPreservePattern(Exchange result, Exchange source)
          Copies the source exchange to target exchange preserving the ExchangePattern of target.
static Exchange createCorrelatedCopy(Exchange exchange, boolean handover)
          Creates a new instance and copies from the current message exchange so that it can be forwarded to another destination as a new instance.
static String createExceptionMessage(String message, Exchange exchange, Throwable cause)
          Creates an exception message with the provided details.
static Map<String,Object> createVariableMap(Exchange exchange)
          Creates a Map of the variables which are made available to a script or template
static
<T> T
extractFutureBody(CamelContext context, Future<Object> future, Class<T> type)
          Extracts the body from the given future, that represents a handle to an asynchronous exchange.
static
<T> T
extractFutureBody(CamelContext context, Future<Object> future, long timeout, TimeUnit unit, Class<T> type)
          Extracts the body from the given future, that represents a handle to an asynchronous exchange.
static Object extractResultBody(Exchange exchange, ExchangePattern pattern)
          Extracts the body from the given exchange.
static
<T> T
getBinding(Exchange exchange, Class<T> type)
          Extracts the Exchange.BINDING of the given type or null if not present
static String getContentEncoding(Exchange exchange)
          Returns the MIME content encoding on the input message or null if one is not defined
static String getContentType(Exchange exchange)
          Returns the MIME content type on the input message or null if one is not defined
static Exchange getExchangeById(Iterable<Exchange> exchanges, String exchangeId)
          Returns the first exchange in the given collection of exchanges which has the same exchange ID as the one given or null if none could be found
static
<T> T
getMandatoryHeader(Exchange exchange, String propertyName, Class<T> type)
           
static Object getMandatoryInBody(Exchange exchange)
          Returns the mandatory inbound message body of the correct type or throws an exception if it is not present
static
<T> T
getMandatoryInBody(Exchange exchange, Class<T> type)
          Returns the mandatory inbound message body of the correct type or throws an exception if it is not present
static Object getMandatoryOutBody(Exchange exchange)
          Returns the mandatory outbound message body of the correct type or throws an exception if it is not present
static
<T> T
getMandatoryOutBody(Exchange exchange, Class<T> type)
          Returns the mandatory outbound message body of the correct type or throws an exception if it is not present
static
<T> T
getMandatoryProperty(Exchange exchange, String propertyName, Class<T> type)
           
static Message getResultMessage(Exchange exchange)
          Returns the message where to write results in an exchange-pattern-sensitive way.
static boolean hasFaultMessage(Exchange exchange)
          Tests whether the exchange has a fault message set and that its not null.
static boolean isFailureHandled(Exchange exchange)
           
static boolean isOutCapable(Exchange exchange)
          Returns true if the given exchange pattern (if defined) can support OUT messages
static boolean isRedeliveryExhausted(Exchange exchange)
           
static Object lookupBean(Exchange exchange, String name)
          Performs a lookup in the registry of the bean name
static
<T> T
lookupBean(Exchange exchange, String name, Class<T> type)
          Performs a lookup in the registry of the bean name and type
static Object lookupMandatoryBean(Exchange exchange, String name)
          Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found
static
<T> T
lookupMandatoryBean(Exchange exchange, String name, Class<T> type)
          Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found
static
<T> T
newInstance(Exchange exchange, Class<T> type)
          Creates a new instance of the given type from the injector
static void populateVariableMap(Exchange exchange, Map<String,Object> map)
          Populates the Map with the variables which are made available to a script or template
static void prepareAggregation(Exchange oldExchange, Exchange newExchange)
          Prepares the exchanges for aggregation.
static void prepareOutToIn(Exchange exchange)
          Strategy to prepare results before next iterator or when we are complete, which is done by copying OUT to IN, so there is only an IN as input for the next iteration.
static Endpoint resolveEndpoint(Exchange exchange, Object value)
          Attempts to resolve the endpoint for the given value
static void setFailureHandled(Exchange exchange)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Method Detail

getBinding

public static <T> T getBinding(Exchange exchange,
                               Class<T> type)
Extracts the Exchange.BINDING of the given type or null if not present

Parameters:
exchange - the message exchange
type - the expected binding type
Returns:
the binding object of the given type or null if it could not be found or converted

resolveEndpoint

public static Endpoint resolveEndpoint(Exchange exchange,
                                       Object value)
                                throws NoSuchEndpointException
Attempts to resolve the endpoint for the given value

Parameters:
exchange - the message exchange being processed
value - the value which can be an Endpoint or an object which provides a String representation of an endpoint via Object.toString()
Returns:
the endpoint
Throws:
NoSuchEndpointException - if the endpoint cannot be resolved

getMandatoryProperty

public static <T> T getMandatoryProperty(Exchange exchange,
                                         String propertyName,
                                         Class<T> type)
                              throws NoSuchPropertyException
Throws:
NoSuchPropertyException

getMandatoryHeader

public static <T> T getMandatoryHeader(Exchange exchange,
                                       String propertyName,
                                       Class<T> type)
                            throws NoSuchHeaderException
Throws:
NoSuchHeaderException

getMandatoryInBody

public static Object getMandatoryInBody(Exchange exchange)
                                 throws InvalidPayloadException
Returns the mandatory inbound message body of the correct type or throws an exception if it is not present

Throws:
InvalidPayloadException

getMandatoryInBody

public static <T> T getMandatoryInBody(Exchange exchange,
                                       Class<T> type)
                            throws InvalidPayloadException
Returns the mandatory inbound message body of the correct type or throws an exception if it is not present

Throws:
InvalidPayloadException

getMandatoryOutBody

public static Object getMandatoryOutBody(Exchange exchange)
                                  throws InvalidPayloadException
Returns the mandatory outbound message body of the correct type or throws an exception if it is not present

Throws:
InvalidPayloadException

getMandatoryOutBody

public static <T> T getMandatoryOutBody(Exchange exchange,
                                        Class<T> type)
                             throws InvalidPayloadException
Returns the mandatory outbound message body of the correct type or throws an exception if it is not present

Throws:
InvalidPayloadException

convertToMandatoryType

public static <T> T convertToMandatoryType(Exchange exchange,
                                           Class<T> type,
                                           Object value)
                                throws NoTypeConversionAvailableException
Converts the value to the given expected type or throws an exception

Throws:
NoTypeConversionAvailableException

convertToType

public static <T> T convertToType(Exchange exchange,
                                  Class<T> type,
                                  Object value)
Converts the value to the given expected type returning null if it could not be converted


createCorrelatedCopy

public static Exchange createCorrelatedCopy(Exchange exchange,
                                            boolean handover)
Creates a new instance and copies from the current message exchange so that it can be forwarded to another destination as a new instance. Unlike regular copy this operation will not share the same UnitOfWork so its should be used for async messaging, where the original and copied exchange are independent.

Parameters:
exchange - original copy of the exchange
handover - whether the on completion callbacks should be handed over to the new copy.

copyResults

public static void copyResults(Exchange result,
                               Exchange source)
Copies the results of a message exchange from the source exchange to the result exchange which will copy the out and fault message contents and the exception

Parameters:
result - the result exchange which will have the output and error state added
source - the source exchange which is not modified

copyResultsPreservePattern

public static void copyResultsPreservePattern(Exchange result,
                                              Exchange source)
Copies the source exchange to target exchange preserving the ExchangePattern of target.

Parameters:
source - source exchange.
result - target exchange.

getResultMessage

public static Message getResultMessage(Exchange exchange)
Returns the message where to write results in an exchange-pattern-sensitive way.

Parameters:
exchange - message exchange.
Returns:
result message.

isOutCapable

public static boolean isOutCapable(Exchange exchange)
Returns true if the given exchange pattern (if defined) can support OUT messages

Parameters:
exchange - the exchange to interrogate
Returns:
true if the exchange is defined as an ExchangePattern which supports OUT messages

newInstance

public static <T> T newInstance(Exchange exchange,
                                Class<T> type)
Creates a new instance of the given type from the injector


createVariableMap

public static Map<String,Object> createVariableMap(Exchange exchange)
Creates a Map of the variables which are made available to a script or template

Parameters:
exchange - the exchange to make available
Returns:
a Map populated with the require variables

populateVariableMap

public static void populateVariableMap(Exchange exchange,
                                       Map<String,Object> map)
Populates the Map with the variables which are made available to a script or template

Parameters:
exchange - the exchange to make available
map - the map to populate

getContentType

public static String getContentType(Exchange exchange)
Returns the MIME content type on the input message or null if one is not defined


getContentEncoding

public static String getContentEncoding(Exchange exchange)
Returns the MIME content encoding on the input message or null if one is not defined


lookupMandatoryBean

public static Object lookupMandatoryBean(Exchange exchange,
                                         String name)
Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found


lookupMandatoryBean

public static <T> T lookupMandatoryBean(Exchange exchange,
                                        String name,
                                        Class<T> type)
Performs a lookup in the registry of the mandatory bean name and throws an exception if it could not be found


lookupBean

public static Object lookupBean(Exchange exchange,
                                String name)
Performs a lookup in the registry of the bean name


lookupBean

public static <T> T lookupBean(Exchange exchange,
                               String name,
                               Class<T> type)
Performs a lookup in the registry of the bean name and type


getExchangeById

public static Exchange getExchangeById(Iterable<Exchange> exchanges,
                                       String exchangeId)
Returns the first exchange in the given collection of exchanges which has the same exchange ID as the one given or null if none could be found


prepareAggregation

public static void prepareAggregation(Exchange oldExchange,
                                      Exchange newExchange)
Prepares the exchanges for aggregation.

This implementation will copy the OUT body to the IN body so when you do aggregation the body is only in the IN body to avoid confusing end users.

Parameters:
oldExchange - the old exchange
newExchange - the new exchange

isFailureHandled

public static boolean isFailureHandled(Exchange exchange)

setFailureHandled

public static void setFailureHandled(Exchange exchange)

isRedeliveryExhausted

public static boolean isRedeliveryExhausted(Exchange exchange)

extractResultBody

public static Object extractResultBody(Exchange exchange,
                                       ExchangePattern pattern)
Extracts the body from the given exchange.

If the exchange pattern is provided it will try to honor it and retrieve the body from either IN or OUT according to the pattern.

Parameters:
exchange - the exchange
pattern - exchange pattern if given, can be null
Returns:
the result body, can be null.
Throws:
CamelExecutionException - is thrown if the processing of the exchange failed

hasFaultMessage

public static boolean hasFaultMessage(Exchange exchange)
Tests whether the exchange has a fault message set and that its not null.

Parameters:
exchange - the exchange
Returns:
true if fault message exists

extractFutureBody

public static <T> T extractFutureBody(CamelContext context,
                                      Future<Object> future,
                                      Class<T> type)
Extracts the body from the given future, that represents a handle to an asynchronous exchange.

Will wait until the future task is complete.

Parameters:
context - the camel context
future - the future handle
type - the expected body response type
Returns:
the result body, can be null.
Throws:
CamelExecutionException - is thrown if the processing of the exchange failed

extractFutureBody

public static <T> T extractFutureBody(CamelContext context,
                                      Future<Object> future,
                                      long timeout,
                                      TimeUnit unit,
                                      Class<T> type)
                           throws TimeoutException
Extracts the body from the given future, that represents a handle to an asynchronous exchange.

Will wait for the future task to complete, but waiting at most the timeout value.

Parameters:
context - the camel context
future - the future handle
timeout - timeout value
unit - timeout unit
type - the expected body response type
Returns:
the result body, can be null.
Throws:
CamelExecutionException - is thrown if the processing of the exchange failed
TimeoutException - is thrown if a timeout triggered

createExceptionMessage

public static String createExceptionMessage(String message,
                                            Exchange exchange,
                                            Throwable cause)
Creates an exception message with the provided details.

All fields is optional so you can pass in only an exception, or just a message etc. or any combination.

Parameters:
message - the message
exchange - the exchange
cause - the caused exception
Returns:
an error message (without stacktrace from exception)

prepareOutToIn

public static void prepareOutToIn(Exchange exchange)
Strategy to prepare results before next iterator or when we are complete, which is done by copying OUT to IN, so there is only an IN as input for the next iteration.

Parameters:
exchange - the exchange to prepare


Copyright © 2007-2010 IONA Open Source Community. All Rights Reserved.