XPath

The XPath language supports 11 options, which are listed below.

You can use namespaces with XPath expressions using the Namespaces helper class.

Variables in XPath are defined in different namespaces. The default namespace is http://camel.apache.org/schema/spring.

Camel will resolve variables according to either:

Camel adds the following XPath functions that can be used to access the exchange:

Here’s an example showing some of these functions in use.

If the message body is stream based, which means the input it receives is submitted to Camel as a stream. That means you will only be able to read the content of the stream once.

You often need to access the data multiple times when you use XPath as a Message Filter or Content-Based Router. Then, you should use Stream Caching or convert the message body to a String prior, which is safe to be re-read multiple times.

The XPath expression will return a result type using native XML objects such as org.w3c.dom.NodeList. However, many times you want a result type to be a String. To do this, you have to instruct the XPath which result type to use.

In Java DSL:

In XML DSL you use the resultType attribute to provide the fully qualified classname.

Using @XPath annotation:

Where we use the xpath function concat to prefix the order name with foo-. In this case we have to specify that we want a String as result type, so the concat function works.

Some users may have XML stored in a header. To apply an XPath to a header’s value, you can do this by defining the 'headerName' attribute.

And in Java DSL you specify the headerName as the second parameter as shown:

Here is a simple example using an XPath expression as a predicate in a Message Filter:

And in XML

If you have a standard set of namespaces you wish to work with and wish to share them across many XPath expressions, you can use the org.apache.camel.support.builder.Namespaces when using Java DSL as shown:

Notice how the namespaces are provided to xpath with the ns variable that are passed in as the second parameter.

Each namespace is a key=value pair, where the prefix is the key. In the XPath expression then the namespace is used by its prefix, e.g.:

The namespace builder supports adding multiple namespaces as shown:

When using namespaces in XML DSL, then it is different, as you set up the namespaces in the XML root tag (or one of the camelContext, routes, route tags).

In the XML example below we use Spring XML where the namespace is declared in the root tag beans, in the line with xmlns:foo="http://example.com/person":

This namespace uses foo as prefix, so the <xpath> expression uses foo: to use this namespace.

You can use Bean Integration to invoke a method on a bean and use various languages such as @XPath to extract a value from the message and bind it to a method parameter.

You can now use the org.apache.camel.language.xpath.XPathBuilder without the need for an Exchange. This comes handy if you want to use it as a helper to do custom XPath evaluations.

It requires that you pass in a CamelContext since a lot of the moving parts inside the XPathBuilder requires access to the Camel Type Converter and hence why CamelContext is needed.

For example, you can do something like this:

This will match the given predicate.

You can also evaluate as shown in the following three examples:

Evaluating with a String result is a common requirement and make this simpler:

You need to add camel-saxon as dependency to your project.

It’s now easier to use Saxon with the XPathBuilder which can be done in several ways as shown below

The easy one

Many XPath-related issues that users frequently face are linked to the usage of namespaces. You may have some misalignment between the namespaces present in your message and those that your XPath expression is aware of or referencing. XPath predicates or expressions that are unable to locate the XML elements and attributes due to namespaces issues may look like they are not working, when in reality all there is to it is a lack of namespace definition.

Namespaces in XML are completely necessary, and while we would love to simplify their usage by implementing some magic or voodoo to wire namespaces automatically, the truth is that any action down this path would disagree with the standards and would greatly hinder interoperability.

Therefore, the utmost we can do is assist you in debugging such issues by adding two new features to the XPath Expression Language and are thus accessible from both predicates and expressions.

You can externalize the script and have Apache Camel load it from a resource such as "classpath:", "file:", or "http:". This is done using the following syntax: "resource:scheme:location", e.g., to refer to a file on the classpath you can do:

For basic XML transformation where you have a fixed structure, you can represent with a combination of using Camel simple and XPath language as:

Given this XML body

Which you want to transform to a smaller structure:

Then you can use simple as template and XPath to grab the content from the message payload, as shown in the route snippet below:

Notice how we use ${xpath(exp} syntax in the simple template to use xpath that will be evaluated on the message body, to extract the content to be used in the output (see previous for output).

Since the simple language can output anything, you can also use this to output in plain text or JSON, etc.

To use XPath in your camel routes, you need to add the dependency on camel-xpath, which implements the XPath language.

If you use Maven, you could add the following to your pom.xml, substituting the version number for the latest & greatest release.

When using xpath with Spring Boot make sure to use the following Maven dependency to have support for auto configuration:

The component supports 12 options, which are listed below.