Mule Expression Language (MEL)

The Context and Functions section describes the context objects and their properties. The syntax of a property expression is contextObject.property. This can appear as an operand in most MEL expressions, including on the left side of an assignment if the property is writable from MEL. You can use the same syntax to refer to the properties of a Java bean as you can with a context object.

Mule Expression Language uses standard Java method invocation. You can provide a fully qualified class name or import a class and use the unqualified name. MEL automatically imports a number of Java classes (see Appendix).

The following examples illustrate Java method calls.

message.payload.getName()

If payload is a Java object—for example, representing a person—this code invokes its getName method. The value of the expression is the value that getName returns—presumably a string representing the person’s name.

java.lang.System.currentTimeMillis()

The value is the current time in milliseconds, as returned by Java. Because MEL automatically imports java.lang.System (see Appendix), you can also write this as:

System.currentTimeMillis()

Numeric literals are integers and floating point numbers, with the same ranges of values as the underlying Java system.

Integers are assumed to be decimal unless they begin with 0. An integer consisting of 0 followed by digits ranging from 0 to 7 is interpreted as octal. An integer starting with 0x followed by digits ranging from 0 to 9 or letters ranging from a to f is interpreted as hexadecimal. An integer ending in an uppercase I is interpreted as a BigInteger.

MEL recognizes floating point numbers by the presence of a decimal point. Floating point numbers can optionally have suffixes of d, f, or B to represent double, float, or BigDecimal.

The following are examples of numeric literals: 255, 0377, 0xff (all represent 255); 3.14159, 3.14159f, 3.14159265358979d (all represent pi).

Literals that include alphabetic characters are case sensitive.

String literals are sequences of characters enclosed in single quotes.

Within String literals you can use the following escape sequences to represent non-printable characters, Unicode characters, and the escape character.

Boolean literals are the values true and false. These are case sensitive.

A null literal takes the form null or nil. These are case sensitive.

You can refer to any Java class by its fully qualified name or if it is one of the classes in the Appendix, by its unqualified name. References use the same dot notation as in Java, except that you must use $ rather than a dot to refer to a nested class.

MEL provides a streamlined way to access map data.

Rather than constructing a map with a new statement, and then using its put method to populate it, you can simply write the following:

[key1 : value1, key2 : value2, . . .]

You can use this literal form wherever you would otherwise use a map by name, including as a method argument.

You can use similar literal forms for lists ({item1, item2, . . .}) and arrays ([item1, item2, . . .]).

Arrays in Java must specify the type of their contents, but in MEL they are untyped. MEL supplies the correct type when you use them – either by determining it at compile time or coercing the array to the correct type at run time.

MEL provides a simpler way to refer to map items than java.util.Map provides. For example, Mule associates a map containing properties set by the inbound endpoint processor with each message. You can refer to this map as message.inboundProperties.

For example, to retrieve the inbound property with key name foo, write 'message.inboundProperties[foo]'.

If that property can be set (never the case with inbound properties, but true of some properties in other maps), you can write message.inboundProperties[foo] on the left side of an assignment. The Context and Functions section explains which items in the context can be set and which cannot. If you try to set a property that cannot be set, Mule indicates failure by throwing org.mvel2.PropertyAccessException.

This object provides read-only access to the properties of the hardware, operating system, user, and network interface listed in the table.

For example, the value of ‘server.userName’ is a string representing the name of the user.

This object provides read-only access to the properties of the Mule instance listed in the table.

For example, the value of ' mule.version ' is a string representing the Mule version.

This object provides access to the properties of the Mule application listed in the table.

For example, the value of ‘app.name’ is a string representing the application name.

For example, ‘app.registry['foo']’ refers to the object named foo in the Mule registry map. You can set or retrieve its value.

This object provides access to the properties of the Mule message listed in the table. The meanings of most of these properties are documented elsewhere, not here.

Using the syntax described in the Referring to Map Data section, you can refer to the maps in the table. You can read, and where allowed write values and even add new keys. To remove a key, you must use the map’s remove method explicitly: message.outboundProperties.remove('key'). The keys in these maps are not fixed. They depend on agreement between the message processor setting them and the message processor using them.

For example, message.outboundProperties['dog'] = 'fido' sets the value of the outbound property called dog to ‘fido’.

The functions xpath and regex provide ways of extracting context information extract information that doesn’t already exist as a single value that can be embodied in a property. By default they work on the payload, but you can pass them different arguments explicitly.

Mule message filters are message processors that follow the enterprise integration pattern called Message Filter.

In their simplest form they either route a message from their input to their output or discard the message. You can find out more about Mule filters here.

A message filter that passes book orders and discards other messages might use the following MEL expression:

xpath ('/order/@type') == 'book'

In the configuration file, it looks like this:

A filter that discards incoming HTTP requests that don’t contain the attribute Authorization HTTP header with a value of true might look like this:

A choice router is a message processor that decides where to send a message based on their contents.

A choice exception strategy is a way of deciding which way to route a message that must deviate from the normal processing path. Choice exception strategies use MEL expressions. For more information, click here

Here is another example of a choice router. This flow watches your download folder, and then moves files to photos, docs or misc folders based on the file extensions.

An expression transformer is a message processor that executes expressions on the current message. The results of the expressions replace the payload.

This transformer transforms the message by appending “Received !” to the message payload.

<expression-transformer expression="#message.payload + 'Received!'"/>

A connector interfaces a Mule flow to an online service.

For example, if the inbound message has a property called myMessage to be used as a Twitter status update, you can pass it to the Twitter connector after extracting it with the following MEL expression:

message.inboundProperties['myMessage']

The following example posts a new tweet via an http endpoint. Using the following URL in a web browser results in a new tweet being created in the given Twitter account.

http://localhost:8081/tweet?status=hello

MEL is used here to select the value that should be used for the status attribute of the connector which in turn is the value used for the tweet/message.

A logger is a message processor that logs message via Mules logging sub-system.

The message to be logged is configured as an attribute of the logger. This message attribute supports tokens (placeholders). The tokens can contain MEL expressions.

For example:

This logs (using the INFO level) every time there is a new message (this assumes there is a file inbound endpoint before this). It outputs “File Received” but also includes the file size, which it determines using the embedded MEL expression #[message.inboundProperties['fileSize']/1024]. The property expression message.inboundProperties['fileSize'] provides the size of the file in bytes from the fileSize key of the inboundProperties map.

A dynamic endpoint is an endpoint whose URI contains a MEL expression. As an example, let’s implement some file sorting similar to what we did with the choice router, but this time we use a dynamic endpoint and use the file extension itself, putting all files with the same name in a new folder with the same name as the extension.

The embedded MEL token in this configuration consists of two MEL expressions separated by a semicolon. The first sets the variable filename using the property expression message.inboundProperties['fileName']. The second is a Java method invocation. in which two of the method arguments come from other Java method invocations. Because filename is a Java String, it has length, lastIndexOf, and substring methods. The expression uses them to extract the filename extension and use it as the name of a subdirectory of /home/me/. This becomes the endpoint.

Expression components allow ad hoc use of MEL. The result does not replace the payload (use set-payload for this). Other message processors use the result of the expression evaluation to:

The following example shows an expression component.

Once a message it does the following: