--- schema_version: "1" id: f65cb7cebcca415f9191e75ba264405e3d4868150554fd9846d92bb8ce51a110 title: Call Java Methods with DataWeave collection: mulesoft version: current locale: en-us portal_url: https://docs.salesforce.com/mulesoft/current/en-us/dataweave/2.11/dataweave-cookbook-java-methods.md canonical_url: https://docs.mulesoft.com/dataweave/2.11/dataweave-cookbook-java-methods source_site: docs.mulesoft.com content_type: documentation content_hash: 71857edc4b4462ba99568ade77d04d28468e95d7b8b0410b176ff5c274973f3b description: MuleSoft Documentation Site release: "2.11" latest: false --- --- product: DataWeave version: 2.11 keywords: studio, anypoint, esb, transform, transformer, format, aggregate, rename, split, filter convert, xml, json, csv, pojo, java object, metadata, dataweave, data weave, datamapper, dwl, dfl, dw, output structure, input structure, map, mapping --- # Call Java Methods with DataWeave > For the full documentation index, see: https://docs.mulesoft.com/llms.txt 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). ## 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. ```java 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: ```json { "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. ```java 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 **New** → **Mule 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 **New** → **Package**, 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 **New** → **Class**, naming that class `MyClass`, and clicking **Finish**. 4. In the **MyClass.java** tab that opens in Studio, copy, paste, and save the contents `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.) ```dataweave %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: ```xml ``` ## Use a Java Bridge DataWeave enables you to call any Java static function or constructor by using the Java bridge. This feature is useful when you need to reuse business logic written in Java or to instantiate any Java object that does not have an empty public constructor. To use a Java bridge, transform a fully qualified Java name to a DataWeave name: 1. Add the prefix `!java`. 2. Replace the dots in the fully qualified name with `::`. When invoking the Java function, DataWeave transforms each argument to the expected type in the function parameter. The following example shows how to create a new instance of a `java.lang.NullPointerException`: ```dataweave %dw 2.0 output application/json --- java!java::lang::NullPointerException::new("foo") ``` The following example invokes the function `java.lang.String.valueOf`: ```dataweave %dw 2.0 output text/plain import valueOf from java!java::lang::String --- valueOf(true) ``` ## Java Bridge Example The following example shows an API that returns a greeting message based on the input `uriParam`. The Java bridge calls a static method within the `my.class.org.Greeter` class that builds the response message. ```dataweave %dw 2.0 output application/json import java!my::class::org::Greeter --- { response: Greeter::greet(attributes.uriParams."name" } ``` ### XML for Java Bridge Example Paste this code into your Studio XML editor to quickly load the flow for this example into your Mule app: ```xml ``` ### Test the App To test your app, follow these steps: 1. Save and run your Mule app. 2. Run the following curl command: `http://localhost:8081/greet/Username`. The Mule app returns the following response message: ```xml { "response": "Greetings, Username!" } ``` ## See Also - [Java Format](https://docs.mulesoft.com/dataweave/2.11/dataweave-formats-java) - [Supported Data Formats](https://docs.mulesoft.com/dataweave/2.11/dataweave-formats)