Call Java Methods with DataWeave

DataWeave 2.2 is compatible and bundled with Mule 4.2. Standard Support for Mule 4.2 ended on May 2, 2021, and this version of Mule will reach its End of Life on May 2, 2023, when Extended Support ends.

Deployments of new applications to CloudHub that use this version of Mule are no longer allowed. Only in-place updates to applications are permitted.

MuleSoft recommends that you upgrade to the latest version of Mule 4 that is in Standard Support so that your applications run with the latest fixes and security enhancements.

From a DataWeave statement, you can call Java methods from any Java class that’s in your Mule project. Note that you can only call Static methods via DataWeave (methods that belong to a Java class, not methods that belong to a specific instance of a class). Before you begin, note that DataWeave version 2 (%dw 2.0) is for Mule 4 apps. For a Mule 3 app, refer to DataWeave 1.0 (%dw 1.0) examples, within the Mule 3.9 documentation set. For other Mule versions, you can use the Mule Runtime version selector in the table of contents.

Call a Java Method

Before you can call a method, you must first import the class it belongs to into your DataWeave code. You can import Java classes just as you import DataWeave modules by including java! into the statement.

For example, below is a simple Java class with a single method that appends a random number at the end of a string. Assume that you created this class as part of a Java package named org.mycompany.utils in your Mule project’s src/main/java folder.

package org.mycompany.utils;

import java.util.Random;

public class MyUtils {

	public static String appendRandom(String base) {
		return base + new Random().nextInt();
	}

}

You can call the method appendRandom() from DataWeave code, in any of the following ways.

  • Import the class and then refer to the method:

    %dw 2.0
    import java!org::mycompany::utils::MyUtils
    output application/json
    ---
    {
    	a: MyUtils::appendRandom("myString")
    }
  • Import one or more methods instead of the whole class:

    %dw 2.0
    import java!org::mycompany::utils::MyUtils::appendRandom
    output application/json
    ---
    {
    	a: appendRandom("myString")
    }
  • If the method is a static method, import and call it in a single line:

    %dw 2.0
    output application/json
    ---
    {
    	a: java!org::mycompany::utils::MyUtils::appendRandom(vars.myString)
    }

All three methods return the variable value with a random string appended:

{
  "a":"myString969858409"
}

Instantiate a Java Class

Through DataWeave code, you can instantiate a new object of any class. Note that after creating an instance, you can’t call its instance methods through DataWeave. However, you can reference its variables.

This simple Java class has a method and a variable.

package org.mycompany.utils;
public class MyClass {

	private String foo;
	 public MyClass(String foo) {
		 this.foo = foo;
	}

	 public String getFoo() {
		return foo;
	}

}

To create the MyClass example in a Studio project:

  1. Create a project for the class in Studio by clicking NewMule Project and providing a name, such as my-app, and clicking Finish.

  2. From my-app, create the org.mycompany.utils package by right-clicking src/main/java from Studio’s Package Explorer, selecting NewPackage, and naming the package org.mycompany.utils.

  3. Create the MyClass class in the your new org.mycompany.utils package by right-clicking org.mycompany.utils, selecting NewClass, naming that class MyClass, and clicking Finish.

  4. In the MyClass.java tab that opens in Studio, copy, paste, and save the contents of MyClass.

The following DataWeave example imports MyClass, creates a new instance of the class, and calls its instance variable foo. (Note that it is not possible for DataWeave to call the object’s private getFoo() method.)

%dw 2.0
import java!org.mycompany.utils::MyClass
output application/json
---
{
	a: MyClass::new("myString").foo
}

To add this DataWeave example to your Studio project:

  1. Returning to my-app.xml in src/main/mule, drag a Transform Message component into the project’s canvas, and click to open it.

  2. In the component’s Transform Message tab, replace the entire script in the source code area (on the right) with the DataWeave script (above).

  3. Save your changes and click Preview (located farthest right on the tab) to view the following output:

    {
      "a":"myString"
    }

Note that the XML for the Transform Message configuration in the Mule flow looks something like this:

<flow name="my-appFlow" >
	<ee:transform doc:name="Transform Message" >
		<ee:message >
			<ee:set-payload ><![CDATA[%dw 2.0
import java!org::mycompany::utils::MyClass
output application/json
---
{
a: MyClass::new("myString").foo
}]]></ee:set-payload>
		</ee:message>
	</ee:transform>
</flow>

Was this article helpful?

💙 Thanks for your feedback!

Edit on GitHub