--- schema_version: "1" id: 4f514c614c4e3553e6f423f990963fe47365499989970e35181dfacde62c393c title: Java Format collection: mulesoft version: current locale: en-us portal_url: https://docs.salesforce.com/mulesoft/current/en-us/dataweave/2.11/dataweave-formats-java.md canonical_url: https://docs.mulesoft.com/dataweave/2.11/dataweave-formats-java source_site: docs.mulesoft.com content_type: documentation content_hash: 1d6fcd2c08d1f7598f16bada018028f7455016779e183623ead3126c1e403526 description: MuleSoft Documentation Site release: "2.11" latest: false --- --- product: DataWeave version: 2.11 keywords: format, java, */java, application/java --- # Java Format > For the full documentation index, see: https://docs.mulesoft.com/llms.txt MIME type: `application/java` ID: `java` For the Java data format, DataWeave attempts to map any Java value to a DataWeave value, most often by matching the semantics of DataWeave and Java. ## Java Value Mapping This table maps Java classes to DataWeave types:

Java Class	DataWeave
`java.lang.String`	`String`
`Enum`	`String`
`Class`	`String`
`UUID`	`String`
`CharSequence`	`String`
`Char`	`String`
`java.sql.Clob`	`String`
`java.io.Reader`	`String`
`int`	`Number`
`long`	`Number`
`double`	`Number`
`short`	`Number`
`BigInteger`	`Number`
`BigDecimal`	`Number`
`AtomicInteger`	`Number`
`AtomicLong`	`Number`
`boolean`	`Boolean`
`AtomicBoolean`	`Boolean`
`java.util.Collection`	`Array`
`java.lang.Iterable`	`Array`
`java.util.Iterator`	`Array`
`java.util.Map`	`Object`
`java.util.Optional`	`Null` or `Value`
`java.util.OptionalInt`	`Null` or `Number`
`java.util.OptionalDouble`	`Null` or `Number`
`java.util.OptionalLong`	`Null` or `Number`
`byte[]`	`Binary`
`java.lang.InputStream`	`Binary`
`java.nio.ByteBuffer`	`Binary`
`byte`	`Binary`
`java.lang.File`	`Binary`
`java.time.Instant`	`LocalDateTime`
`java.time.LocalDateTime`	`LocalDateTime`
`java.sql.Timestamp`	`LocalDateTime`
`java.sql.Date`	`LocalDateTime`
`java.util.Date`	`LocalDateTime`
`java.time.ZonedDateTime`	`DateTime`
`java.time.LocalTime`	`LocalTime`
`java.time.OffsetTime`	`Time`
`java.time.LocalDate`	`Date`
`java.time.ZoneOffset`	`TimeZone`
`java.util.Calendar`	`DateTime`
`java.util.XMLGregorianCalendar`	`DateTime`
`*[]`	`Array`

> [!IMPORTANT] If a Java class isn’t present in the table, DataWeave treats it as a `JavaBean` and > maps it as an `Object` type. In this case, DataWeave takes all properties from the Java getters. ## Metadata DataWeave supports the `^class` metadata for the Java format. All Java objects are associated with a class. DataWeave maintains this association by mapping the class to a Metadata property. `payload.^class` returns the name of the class of the `payload`. The Java writer uses the metadata property to discover the Java class to which the DataWeave value maps. That is, DataWeave uses the metadata property to determine which Java class is to be created from a given DataWeave value. For example, the expression `output application/java --- now() as DateTime {class: "java.util.Calendar"}` creates a `java.util.Calendar`. ## Enum Custom Type The Java format supports the `Enum` custom type. To put a Java `enum` value into a `java.util.Map`, the DataWeave Java module defines a custom type called `Enum`. This custom type enables you to handle a given string as the name of a specified `enum` type. You must use the `class` metadata property when specifying the Java class name of the enum, for example: `{gender: "Female" as Enum {class: "org.mycompany.Gender"}}` ## Handling `java.io.InputStream` Instances Using `java.io.InputStream` instances in DataWeave, whether running DataWeave functions, calling Java methods from DataWeave code, or writing them to an output, requires understanding how DataWeave manages `java.io.InputStream` instances. The Java format makes a deep copy of the `java.io.InputStream` instance. As a result, DataWeave creates a new `java.io.InputStream` instance that can be reused later in your script while retaining the content of the original stream. However, if the original `java.io.InputStream` doesn’t support repeatable streams, it may get consumed and become unusable. To avoid unexpected behavior, always check whether your `java.io.InputStream` is repeatable before processing it multiple times. ## Examples The following examples show uses of the Java format. - [Example: Access Values of Java Properties](#example1) - [Example: Create a Customer Object](#example2) - [Example: Use a Generic](#example3) ### Class Definitions The Java examples use these class definitions: - [`User`](#class_user) - [`Customer`](#class_customer) (which extends `User`) User class: ```java class User { private String name; private String lastName; public User(){ } public User(String name, String lastName){ this.name = name; this.lastName = lastName; } public void setName(String name){ this.name = name; } public void setLastName(String lastName){ this.lastName = lastName; } public String getName(){ return name; } public String getLastName(){ return lastName; } } ``` This class extends `User`. Customer class: ```java import java.util.Calendar; class Customer extends User { private Calendar expirationDate; private User salesRepr; public User(){ } public User(String name, String lastName,Calendar expirationDate){ super(name,lastName); this.expirationDate = expirationDate; } public void setSalesRepr(User salesRepr){ this.salesRepr = salesRepr; } public User getSalesRepr(){ return this.salesRepr; } public void setExpirationDate(Calendar expirationDate){ this.expirationDate = expirationDate; } public Calendar getExpirationDate(){ return this.expirationDate; } } ``` ### Example: Access Values of Java Properties This example shows how to access the values of Java properties. #### Input The `User` values serves as the input payload to the DataWeave script. ```groovy new User("Leandro", "Shokida") ``` #### Source The DataWeave scripts transforms the input value to JSON. ```dataweave output application/json --- { a: payload.name, b: payload.lastName } ``` #### Output The output is a JSON object that contains key-value pairs. The values are the `name` and `lastName` values from the input `User` object. ```json { "a": "Leandro", "b": "Shokida" } ``` ### Example: Create a Customer Object This example shows how to create an instance of a `Customer` class. The script outputs the object in the JSON format and MIME type. Notice that it’s not necessary to specify the class of inner properties because their class is inferred from the parent class definition. ```dataweave output application/json --- { name: "Tomo", lastName: "Chibana", expirationDate: now(), salesRepr: { name: "Mariano", lastName: "de Achaval", } } as Object {class: "Customer"} ``` ### Example: Use a Generic This example relies on generic support in the class name to create a `java.util.ArrayList` of `User` objects. Don’t use a generic to specify the class in each instance. The class is taken from the generic in the list. ```dataweave output application/json --- [{ name: "Tomo", lastName: "Chibana" }, { name: "Ana", lastName: "Felissati" }, { name: "Leandro", lastName: "Shokida" } ] as Array {class: "java.util.ArrayList"} ``` ## Java Support Starting with version 2.6, DataWeave supports Java 17. Java 17 adds restrictions in encapsulation and reflective access that affects the [Java Format](https://docs.mulesoft.com/dataweave/latest/dataweave-formats-java). Because DataWeave uses Java’s reflection API to read and write Java objects, ensure that the objects your application uses are Plain Old Java Objects (POJOs) containing: - Default constructor - Getters for all properties - Setters for all properties ## Examples of Java Support These examples run using Java 17 and [language level 2.6](https://docs.mulesoft.com/dataweave/latest/dataweave-versioning-behavior.adoc). - [Example: Create a Java Object Instance](#example4) - [Example: Access the Values of Java Properties](#example5) ### Example: Create a Java Object Instance This example shows how to create a Java object instance. #### User Class The Java example uses this class: ```java public class User { private String name; private String lastName; public User(){ } public String getName(){ return name; } public String getLastName(){ return lastName; } } ``` #### DataWeave Script ```java {name: "Tomo", lastName: "Chibana" } as Object {class: "User"} ``` #### Output The expected output is an instance of the user class. Because the user class definition doesn’t have the proper setters, the output is `IllegalAccessException`. ```java java.lang.IllegalAccessException - class org.mule.weave.v2.module.pojo.reader.PropertyDefinition (in module org.mule.weave.module.java) cannot access a member of class User with modifiers "private ``` ### Example: Access the Values of Java Properties This example shows how to access the values of Java properties. #### Item Class The Java example uses the following class: ```java public class Item { private String name; private int quantity; public Item() { } public Item(String name, int quantity) { this.name = name; this.quantity = quantity; } public void setName(String name) { this.name = name; } public void setQuantity(int quantity) { this.quantity = quantity; } } ``` #### Input new Item("Pencil", 5) #### DataWeave Script ```dataweave output application/json --- { "name": "payload.name", "quantity": "payload.quantity" } ``` #### Output The expected output is a JSON object. ```json { "name": "Pencil", "quantity": "5" } ``` Because the item class definition doesn’t have the proper getters, the output is `IllegalAccessException`. ```java java.lang.IllegalAccessException: class org.mule.weave.v2.module.pojo.reader.PropertyDefinition (in module org.mule.weave.module.java) cannot access a member of class Item with modifiers "private" ``` ### Troubleshooting Common Errors To resolve conflicts, ensure that you: - Update your class definitions to follow the POJOs structure (recommended). - Use the compatibility flag `com.mulesoft.dw.java.disable_set_accessible=false` to allow accessible flag modification for reflection objects. This approach is a workaround and works for customer domain classes only. Note that the usage of this compatibility flag might not affect future versions. ## Configuration Properties DataWeave supports these configuration properties for this format. ### Reader Properties There are no reader properties for this format. ### Writer Properties This format accepts properties that provide instructions for writing output data.

Parameter	Type	Default	Description
`duplicateKeyAsArray`	`Boolean`	`false`	Converts the values of duplicate keys in an object to a single array of values to the duplicated key. Valid values are `true` or `false`.
`writeAttributes`	`Boolean`	`false`	Converts attributes of a key into child key-value pairs of that key. The attribute key name starts with @. Valid values are `true` or `false`.

## Supported MIME Types This format supports this MIME type: - `*/java`