Simple _expression_ Language
The Simple _expression_ Language is a really simple language you can use. Its primarily intended for being a really small and simple language for testing without requiring any new dependencies or knowledge of XPath; so its ideal for testing in camel-core. However for real world use cases you are generally recommended to choose a more expressive and powerful language such as:
The simple language uses ${body} placeholders for complex expressions where the _expression_ contains constant literals. The ${ } placeholders can be omitted if the _expression_ is only the token itself.
To get the body of the in message: "body", or "in.body" or "${body}".
A complex _expression_ must use ${ } placeholders, such as: "Hello ${in.header.name} how are you?".
You can have multiple tokens in the same _expression_: "Hello ${in.header.name} this is ${in.header.me} speaking".
However you can not nest tokens (i.e. having another ${ } placeholder in an existing, is not allowed).
Variables
| Variable |
Type |
Description |
| id |
String |
the input message id |
| body |
Object |
the input body |
| in.body |
Object |
the input body |
| out.body |
Object |
the output body |
| header.foo |
Object |
refer to the input foo header |
| headers.foo |
Object |
refer to the input foo header |
| in.header.foo |
Object |
refer to the input foo header |
| in.headers.foo |
Object |
refer to the input foo header |
| out.header.foo |
Object |
refer to the out header foo |
| out.headers.foo |
Object |
refer to the out header foo |
| property.foo |
Object |
refer to the foo property on the exchange |
| sys.foo |
String |
refer to the system property |
| date:command:pattern |
String |
New in Camel 1.5. Date formatting using the java.text.SimepleDataFormat patterns. Supported commands are: now for current timestamp, in.header.xxx or header.xxx to use the Date object in the IN header with the key xxx. out.header.xxx to use the Date object in the OUT header with the key xxx. |
| bean:bean _expression_ |
Object |
New in Camel 1.5. Invoking a bean _expression_ using the Bean language. |
Samples
In the Spring XML sample below we filter based on a header value:
<from uri="seda:orders">
<filter>
<simple>in.header.foo</simple>
<to uri="mock:fooOrders"/>
</filter>
</from>
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 mock:foo endpoint, otherwise its lost in the deep blue sea ![]()
.
The same example in Java DSL:
from("seda:orders")
.filter().simple("in.header.foo").to("seda:fooOrders");
You can also use the simple language for simple text concatenations such as:
from("direct:hello").transform().simple("Hello ${in.header.user} how are you?").to("mock:reply");
Notice that we must use ${ } placeholders in the _expression_ now to let Camel be able to parse it correctly.
And this sample uses the date command to output current date.
from("direct:hello").transform().simple("The today is ${date:now:yyyyMMdd} and its a great day.").to("mock:reply");
And in the sample below we invoke the bean language to invoke a method on a bean to be included in the returned string:
from("direct:order").transform().simple("OrderId: ${bean:orderIdGenerator}").to("mock:reply");
Where orderIdGenerator is the id of the bean registered in the Registry. If using Spring then its the Spring bean id.
Dependencies
The Bean language is part of camel-core.
