2.6. Transforming Message Content

Abstract

Apache Camel supports a variety of approaches to transforming message content. In addition to a simple native API for modifying message content, Apache Camel supports integration with several different third-party libraries and transformation standards.

2.6.1. Simple Message Transformations

Overview

The Java DSL has a built-in API that enables you to perform simple transformations on incoming and outgoing messages. For example, the rule shown in Example 2.1, “Simple Transformation of Incoming Messages” appends the text, World!, to the end of the incoming message body.

Example 2.1. Simple Transformation of Incoming Messages

from("SourceURL").setBody(body().append(" World!")).to("TargetURL");

Where the setBody() command replaces the content of the incoming message's body.

API for simple transformations

You can use the following API classes to perform simple transformations of the message content in a router rule:

org.apache.camel.model.ProcessorDefinition
org.apache.camel.builder.Builder
org.apache.camel.builder.ValueBuilder

ProcessorDefinition class

The org.apache.camel.model.ProcessorDefinition class defines the DSL commands you can insert directly into a router rule—for example, the setBody() command in Example 2.1, “Simple Transformation of Incoming Messages”. Table 2.5, “Transformation Methods from the ProcessorDefinition Class” shows the ProcessorDefinition methods that are relevant to transforming message content:

Table 2.5. Transformation Methods from the ProcessorDefinition Class

Method	Description
`Type convertBodyTo(Class type)`	Converts the IN message body to the specified type.
`Type removeFaultHeader(String name)`	Adds a processor which removes the header on the FAULT message.
`Type removeHeader(String name)`	Adds a processor which removes the header on the IN message.
`Type removeProperty(String name)`	Adds a processor which removes the exchange property.
`ExpressionClause<ProcessorDefinition<Type>> setBody()`	Adds a processor which sets the body on the IN message.
`Type setFaultBody(Expression expression)`	Adds a processor which sets the body on the FAULT message.
`Type setFaultHeader(String name, Expression expression)`	Adds a processor which sets the header on the FAULT message.
`ExpressionClause<ProcessorDefinition<Type>> setHeader(String name)`	Adds a processor which sets the header on the IN message.
`Type setHeader(String name, Expression expression)`	Adds a processor which sets the header on the IN message.
`ExpressionClause<ProcessorDefinition<Type>> setOutHeader(String name)`	Adds a processor which sets the header on the OUT message.
`Type setOutHeader(String name, Expression expression)`	Adds a processor which sets the header on the OUT message.
`ExpressionClause<ProcessorDefinition<Type>> setProperty(String name)`	Adds a processor which sets the exchange property.
`Type setProperty(String name, Expression expression)`	Adds a processor which sets the exchange property.
`ExpressionClause<ProcessorDefinition<Type>> transform()`	Adds a processor which sets the body on the OUT message.
`Type transform(Expression expression)`	Adds a processor which sets the body on the OUT message.

Builder class

The org.apache.camel.builder.Builder class provides access to message content in contexts where expressions or predicates are expected. In other words, Builder methods are typically invoked in the arguments of DSL commands—for example, the body() command in Example 2.1, “Simple Transformation of Incoming Messages”. Table 2.6, “Methods from the Builder Class” summarizes the static methods available in the Builder class.

Table 2.6. Methods from the Builder Class

Method	Description
`static <E extends Exchange> ValueBuilder<E> body()`	Returns a predicate and value builder for the inbound body on an exchange.
`static <E extends Exchange,T> ValueBuilder<E> bodyAs(Class<T> type)`	Returns a predicate and value builder for the inbound message body as a specific type.
`static <E extends Exchange> ValueBuilder<E> constant(Object value)`	Returns a constant expression.
`static <E extends Exchange> ValueBuilder<E> faultBody()`	Returns a predicate and value builder for the fault body on an exchange.
`static <E extends Exchange,T> ValueBuilder<E> faultBodyAs(Class<T> type)`	Returns a predicate and value builder for the fault message body as a specific type.
`static <E extends Exchange> ValueBuilder<E> header(String name)`	Returns a predicate and value builder for headers on an exchange.
`static <E extends Exchange> ValueBuilder<E> outBody()`	Returns a predicate and value builder for the outbound body on an exchange.
`static <E extends Exchange> ValueBuilder<E> outBodyAs(Class<T> type)`	Returns a predicate and value builder for the outbound message body as a specific type.
`static ValueBuilder property(String name)`	Returns a predicate and value builder for properties on an exchange.
`static ValueBuilder regexReplaceAll(Expression content, String regex, Expression replacement)`	Returns an expression that replaces all occurrences of the regular expression with the given replacement.
`static ValueBuilder regexReplaceAll(Expression content, String regex, String replacement)`	Returns an expression that replaces all occurrences of the regular expression with the given replacement.
`static ValueBuilder sendTo(String uri)`	Returns an expression processing the exchange to the given endpoint uri.
`static <E extends Exchange> ValueBuilder<E> systemProperty(String name)`	Returns an expression for the given system property.
`static <E extends Exchange> ValueBuilder<E> systemProperty(String name, String defaultValue)`	Returns an expression for the given system property.

ValueBuilder class

The org.apache.camel.builder.ValueBuilder class enables you to modify values returned by the Builder methods. In other words, the methods in ValueBuilder provide a simple way of modifying message content. Table 2.7, “Modifier Methods from the ValueBuilder Class” summarizes the methods available in the ValueBuilder class. That is, the table shows only the methods that are used to modify the value they are invoked on (for full details, see the API Reference documentation).

Table 2.7. Modifier Methods from the ValueBuilder Class

Method	Description
`ValueBuilder<E> append(Object value)`	Appends the string evaluation of this expression with the given value.
`Predicate contains(Object value)`	Create a predicate that the left hand expression contains the value of the right hand expression.
`ValueBuilder<E> convertTo(Class type)`	Converts the current value to the given type using the registered type converters.
`ValueBuilder<E> convertToString()`	Converts the current value a String using the registered type converters.
`Predicate endsWith(Object value)`
`<T> T evaluate(Exchange exchange, Class<T> type)`
`Predicate in(Object... values)`
`Predicate in(Predicate... predicates)`
`Predicate isEqualTo(Object value)`	Returns true, if the current value is equal to the given `value` argument.
`Predicate isGreaterThan(Object value)`	Returns true, if the current value is greater than the given `value` argument.
`Predicate isGreaterThanOrEqualTo(Object value)`	Returns true, if the current value is greater than or equal to the given `value` argument.
`Predicate isInstanceOf(Class type)`	Returns true, if the current value is an instance of the given type.
`Predicate isLessThan(Object value)`	Returns true, if the current value is less than the given `value` argument.
`Predicate isLessThanOrEqualTo(Object value)`	Returns true, if the current value is less than or equal to the given `value` argument.
`Predicate isNotEqualTo(Object value)`	Returns true, if the current value is not equal to the given `value` argument.
`Predicate isNotNull()`	Returns true, if the current value is not `null`.
`Predicate isNull()`	Returns true, if the current value is `null`.
`Predicate matches(Expression expression)`
`Predicate not(Predicate predicate)`	Negates the predicate argument.
`ValueBuilder prepend(Object value)`	Prepends the string evaluation of this expression to the given value.
`Predicate regex(String regex)`
`ValueBuilder<E> regexReplaceAll(String regex, Expression<E> replacement)`	Replaces all occurrencies of the regular expression with the given replacement.
`ValueBuilder<E> regexReplaceAll(String regex, String replacement)`	Replaces all occurrencies of the regular expression with the given replacement.
`ValueBuilder<E> regexTokenize(String regex)`	Tokenizes the string conversion of this expression using the given regular expression.
`ValueBuilder sort(Comparator comparator)`	Sorts the current value using the given comparator.
`Predicate startsWith(Object value)`	Returns true, if the current value matches the string value of the `value` argument.
`ValueBuilder<E> tokenize()`	Tokenizes the string conversion of this expression using the comma token separator.
`ValueBuilder<E> tokenize(String token)`	Tokenizes the string conversion of this expression using the given token separator.

2.6.2. Marshalling and Unmarshalling

Java DSL commands

You can convert between low-level and high-level message formats using the following commands:

marshal()— Converts a high-level data format to a low-level data format.
unmarshal() — Converts a low-level data format to a high-level data format.

Data formats

Apache Camel supports marshalling and unmarshalling of the following data formats:

Java serialization
JAXB
XMLBeans
XStream

Java serialization

Enables you to convert a Java object to a blob of binary data. For this data format, unmarshalling converts a binary blob to a Java object, and marshalling converts a Java object to a binary blob. For example, to read a serialized Java object from an endpoint, SourceURL, and convert it to a Java object, you use a rule like the following:

from("SourceURL").unmarshal().serialization()
.<FurtherProcessing>.to("TargetURL");

Or alternatively, in Spring XML:

<camelContext id="serialization" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURL"/>
    <unmarshal>
      <serialization/>
    </unmarshal>
    <to uri="TargetURL"/>
  </route>
</camelContext>

JAXB

Provides a mapping between XML schema types and Java types (see https://jaxb.dev.java.net/). For JAXB, unmarshalling converts an XML data type to a Java object, and marshalling converts a Java object to an XML data type. Before you can use JAXB data formats, you must compile your XML schema using a JAXB compiler to generate the Java classes that represent the XML data types in the schema. This is called binding the schema. After the schema is bound, you define a rule to unmarshal XML data to a Java object, using code like the following:

org.apache.camel.spi.DataFormat jaxb = new org.apache.camel.model.dataformat.JaxbDataFormat("GeneratedPackageName");

from("SourceURL").unmarshal(jaxb)
.<FurtherProcessing>.to("TargetURL");

where GeneratedPackagename is the name of the Java package generated by the JAXB compiler, which contains the Java classes representing your XML schema.

Or alternatively, in Spring XML:

<camelContext id="jaxb" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURL"/>
    <unmarshal>
      <jaxb prettyPrint="true" contextPath="GeneratedPackageName"/>
    </unmarshal>
    <to uri="TargetURL"/>
  </route>
</camelContext>

XMLBeans

Provides an alternative mapping between XML schema types and Java types (see http://xmlbeans.apache.org/). For XMLBeans, unmarshalling converts an XML data type to a Java object and marshalling converts a Java object to an XML data type. For example, to unmarshal XML data to a Java object using XMLBeans, you use code like the following:

from("SourceURL").unmarshal().xmlBeans()
.<FurtherProcessing>.to("TargetURL");

Or alternatively, in Spring XML:

<camelContext id="xmlBeans" xmlns="http://camel.apache.org/schema/spring">
  <route>
    <from uri="SourceURL"/>
    <unmarshal>
      <xmlBeans prettyPrint="true"/>
    </unmarshal>
    <to uri="TargetURL"/>
  </route>
</camelContext>

XStream

Provides another mapping between XML types and Java types (see http://www.xml.com/pub/a/2004/08/18/xstream.html). XStream is a serialization library (like Java serialization), enabling you to convert any Java object to XML. For XStream, unmarshalling converts an XML data type to a Java object, and marshalling converts a Java object to an XML data type.

from("SourceURL").unmarshal().xstream()
.<FurtherProcessing>.to("TargetURL");

Note

The XStream data format is currently not supported in Spring XML.

2.6.3. Endpoint Bindings

What is a binding?

In Apache Camel, a binding is a way of wrapping an endpoint in a contract—for example, by applying a Data Format, a Content Enricher or a validation step. A condition or transformation is applied to the messages coming in, and a complementary condition or transformation is applied to the messages going out.

DataFormatBinding

The DataFormatBinding class is useful for the specific case where you want to define a binding that marshals and unmarshals a particular data format (see Section 2.6.2, “Marshalling and Unmarshalling”). In this case, all that you need to do to create a binding is to create a DataFormatBinding instance, passing a reference to the relevant data format in the constructor.

For example, the XML DSL snippet in Example 2.2, “JAXB Binding” shows a binding (with ID, jaxb) that is capable of marshalling and unmarshalling the JAXB data format when it is associated with an Apache Camel endpoint:

Example 2.2. JAXB Binding

<beans ... >
    ...
    <bean id="jaxb" class="org.apache.camel.processor.binding.DataFormatBinding">
        <constructor-arg ref="jaxbformat"/>
    </bean>

    <bean id="jaxbformat" class="org.apache.camel.model.dataformat.JaxbDataFormat">
        <property name="prettyPrint" value="true"/>
        <property name="contextPath" value="org.apache.camel.example"/>
    </bean>

</beans>

Associating a binding with an endpoint

The following alternatives are available for associating a binding with an endpoint:

Binding URI

To associate a binding with an endpoint, you can prefix the endpoint URI with binding:NameOfBinding, where NameOfBinding is the bean ID of the binding (for example, the ID of a binding bean created in Spring XML).

For example, the following example shows how to associate ActiveMQ endpoints with the JAXB binding defined in Example 2.2, “JAXB Binding”.

<beans ...>
    ...    
    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="binding:jaxb:activemq:orderQueue"/>
            <to uri="binding:jaxb:activemq:otherQueue"/>
        </route>
    </camelContext>
    ...    
</beans>

BindingComponent

Instead of using a prefix to associate a binding with an endpoint, you can make the association implicit, so that the binding does not need to appear in the URI. For existing endpoints that do not have an implicit binding, the easiest way to achieve this is to wrap the endpoint using the BindingComponent class.

For example, to associate the jaxb binding with activemq endpoints, you could define a new BindingComponent instance as follows:

<beans ... >
    ...
    <bean id="jaxbmq" class="org.apache.camel.component.binding.BindingComponent">
        <constructor-arg ref="jaxb"/>
        <constructor-arg value="activemq:foo."/>
    </bean>

    <bean id="jaxb" class="org.apache.camel.processor.binding.DataFormatBinding">
        <constructor-arg ref="jaxbformat"/>
    </bean>

    <bean id="jaxbformat" class="org.apache.camel.model.dataformat.JaxbDataFormat">
        <property name="prettyPrint" value="true"/>
        <property name="contextPath" value="org.apache.camel.example"/>
    </bean>

</beans>

Where the (optional) second constructor argument to jaxbmq defines a URI prefix. You can now use the jaxbmq ID as the scheme for an endpoint URI. For example, you can define the following route using this binding component:

<beans ...>
    ...    
    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="jaxbmq:firstQueue"/>
            <to uri="jaxbmq:otherQueue"/>
        </route>
    </camelContext>
    ...    
</beans>

The preceding route is equivalent to the following route, which uses the binding URI approach:

<beans ...>
    ...    
    <camelContext xmlns="http://camel.apache.org/schema/spring">
        <route>
            <from uri="binding:jaxb:activemq:foo.firstQueue"/>
            <to uri="binding:jaxb:activemq:foo.otherQueue"/>
        </route>
    </camelContext>
    ...    
</beans>

Note

For developers that implement a custom Apache Camel component, it is possible to achieve this by implementing an endpoint class that inherits from the org.apache.camel.spi.HasBinding interface.

BindingComponent constructors

The BindingComponent class supports the following constructors:

public BindingComponent(): No arguments form. Use property injection to configure the binding component instance.
public BindingComponent(Binding binding): Associate this binding component with the specified Binding object, binding.
public BindingComponent(Binding binding, String uriPrefix): Associate this binding component with the specified Binding object, binding, and URI prefix, uriPrefix. This is the most commonly used constructor.
public BindingComponent(Binding binding, String uriPrefix, String uriPostfix): This constructor supports the additional URI post-fix, uriPostfix, argument, which is automatically appended to any URIs defined using this binding component.

Implementing a custom binding

In addition to the DataFormatBinding, which is used for marshalling and unmarshalling data formats, you can implement your own custom bindings. Define a custom binding as follows:

Implement an org.apache.camel.Processor class to perform a transformation on messages incoming to a consumer endpoint (appearing in a from element).
Implement a complementary org.apache.camel.Processor class to perform the reverse transformation on messages outgoing from a producer endpoint (appearing in a to element).
Implement the org.apache.camel.spi.Binding interface, which acts as a factory for the processor instances.

Binding interface

Example 2.3, “The org.apache.camel.spi.Binding Interface” shows the definition of the org.apache.camel.spi.Binding interface, which you must implement to define a custom binding.

Example 2.3. The org.apache.camel.spi.Binding Interface

// Java
package org.apache.camel.spi;

import org.apache.camel.Processor;

/**
 * Represents a <a href="http://camel.apache.org/binding.html">Binding</a> or contract
 * which can be applied to an Endpoint; such as ensuring that a particular
 * <a href="http://camel.apache.org/data-format.html">Data Format</a> is used on messages in and out of an endpoint.
 */
public interface Binding {

    /**
     * Returns a new {@link Processor} which is used by a producer on an endpoint to implement
     * the producer side binding before the message is sent to the underlying endpoint.
     */
    Processor createProduceProcessor();

    /**
     * Returns a new {@link Processor} which is used by a consumer on an endpoint to process the
     * message with the binding before its passed to the endpoint consumer producer.
     */
    Processor createConsumeProcessor();
}

When to use bindings

Bindings are useful when you need to apply the same kind of transformation to many different kinds of endpoint.

Where did the comment section go?

Red Hat's documentation publication system recently went through an upgrade to enable speedier, more mobile-friendly content. We decided to re-evaluate our commenting platform to ensure that it meets your expectations and serves as an optimal feedback mechanism. During this redesign, we invite your input on providing feedback on Red Hat documentation via the discussion platform.