Simple - Advanced Features

Starting from Camel 4.18 you can in the top of your Simple expressions declare an initialization block that are used to define a set of local variables that are pre-computed, and can be used in the following Simple expression. This allows to reuse variables, and also avoid making the simple expression complicated when having inlined functions, and in general make the simple expression easier to maintain and understand.

The init block is declared as follows:

Notice how the block uses the $init{ …​ }init$ markers to indicate the start and end of the block.

Inside the init block, then you can assign local variables in the syntax $key := <statement>; where you can then use simple language to compute the value of the variable.

Here are a couple of examples:

You can have Java style code comments in the init block using // comment here as follows:

The local variables can then easily be used in the Simple language either using the ${variable.foo} syntax or the shorthand syntax $foo.

For example as below where we do a basic JSON mapping:

The assigned variables from the init block are stored as Variables on the Exchange which allows to use the variables later in the Camel routes.

For example:

Notice how we can refer to the variable ($level) in the log statement using the standard ${variable.xxx} syntax.

Below we filter based on a header value:

The Simple language can be used for the predicate test above in the Message Filter pattern, where we test if the in message has a foo header (a header with the key foo exists). If the expression evaluates to true, then the message is routed to the seda:fooOrders endpoint, otherwise the message is dropped.

You can also use the simple language for simple text concatenations such as:

Notice that we must use ${ } placeholders in the expression now to allow Camel to parse it correctly.

And this sample uses the date command to output current date.

And in the sample below, we invoke the bean language to invoke a method on a bean to be included in the returned string:

Where orderIdGenerator is the id of the bean registered in the Registry. If using Spring, then it is the Spring bean id.

If we want to declare which method to invoke on the order id generator bean we must prepend .method name such as below where we invoke the generateId method.

We can use the ?method=methodname option that we are familiar with the Bean component itself:

You can also convert the body to a given type, for example, to ensure that it is a String you can do:

There are a few types which have a shorthand notation, so we can use String instead of java.lang.String. These are: byte[], String, Integer, Long. All other types must use their FQN name, e.g. org.w3c.dom.Document.

It is also possible to look up a value from a header Map:

In the code above we look up the header with name type and regard it as a java.util.Map and we then look up with the key gold and return the value. If the header is not convertible to Map, an exception is thrown. If the header with name type does not exist null is returned.

You can nest functions, such as shown below:

You can use the substring function to more easily clip the message body. For example if the message body contains the following 10 letters ABCDEFGHIJ then:

Then the message body after the substring will be DEFGHIJ. If you want to clip from the end instead, then use negative values such as substring(-3).

You can also clip from both ends at the same time such as substring(1,-1) that will clip the first and last character in the String.

If the number is higher than the length of the message body, then an empty string is returned, for example substring(99).

Instead of the message body then a simple expression can be nested as input, for example, using a variable, as shown below:

You can use the replace function to more easily replace all single or double quotes in the message body, using the XML escape syntax. This avoids to fiddle with enclosing a double quote or single quotes with outer quotes, that can get confusing to be correct as you may need to escape the quotes as well. So instead you can use the XML escape syntax where double quote is " and single quote is ' (yeah that is the name).

For example, to replace all double quotes with single quotes:

And to replace all single quotes with double quotes:

Or to remove all double quotes:

You can now provide a result type to the Simple expression, which means the result of the evaluation will be converted to the desired type. This is most usable to define types such as booleans, integers, etc.

For example, to set a header as a boolean type, you can do:

And in XML DSL

It is easier to specify new lines or tabs in XML DSLs as you can escape the value now

The trim attribute of the expression can be used to control whether the leading and trailing whitespace characters are removed or preserved. The default value is true, which removes the whitespace characters.

You can externalize the script and have 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:

From Camel 4.18 onwards then the Simple language can pretty format the output.

You turn this on via the pretty option set to true:

This works with XML, JSON and text content:

You can add custom functions to the Simple language by adding to the org.apache.camel.spi.SimpleFunctionRegistry.

A custom function should either be an Expression or a org.apache.camel.spi.SimpleFunction implementation.

You may want to use Expression when you build custom functions from the built-in functions in Camel. This can be done programmatically such as:

Here we add a custom function named foo which is implemented as a org.apache.camel.Expression which conveniently can be done by using the org.apache.camel.support.ExpressionAdapter class as above.

The foo function can now be used in simple such as:

Notice how the foo function is used just like it was a built-in function using ${foo} syntax.

Since a custom function is just an Expression then it’s possible to build custom functions from all the Camel languages such as Groovy, JSonPath and even Simple as well.

The bar function is build using simple functions using the ~> chain operators to perform a sequence of functions on the payload.

Custom functions will by default use the message body as the payload. But they also support a single parameter as the input, which allows to provide the input as fixed value such as a string literal or to refer to an existing header or variable.

For example the foo function uses variable with name msg as the input:

And instead of nesting the variable inside the foo function, we can also use the ~> chain operator:

You can also build custom functions as a Java class as below:

This gives you the full power to implement the function logic in standard Java.

This function can be added programmatically:

The camel-catalog JAR includes a self-contained JavaScript validator for the Simple language. It can syntax-check expressions and predicates in any browser or Node.js environment — no Java backend required.

The files are located in the JAR under:

The .js file is auto-generated from simple.json during the Maven build, so its list of functions and operators always matches the current Camel version.