About Blaise Doughan

Team lead for the TopLink/EclipseLink JAXB & SDO implementations, and the Oracle representative on those specifications.

EclipseLink MOXy and the Java API for JSON Processing – Object Model APIs

The Java API for JSON Processing (JSR-353) is the Java standard for producing and consuming JSON which was introduced as part of Java EE 7.  JSR-353 includes object (DOM like) and stream (StAX like) APIs.  In this post I will demonstrate the initial JSR-353 support we have added to MOXy‘s JSON binding in EclipseLink 2.6.  You can now use MOXy to marshal to:

  • javax.json.JsonArrayBuilder
  • javax.json.JsonObjectBuilder

And unmarshal from:
 

  • javax.json.JsonStructure
  • javax.json.JsonObject
  • javax.json.JsonArray

You can try this out today using a nightly build of EclipseLink 2.6.0:

The JSR-353 reference implementation is available here:

Java Model

Below is the simple customer model that we will use for this post.  Note for this example we are only using the standard JAXB (JSR-222) annotations.

Customer

package blog.jsonp.moxy;

import java.util.*;
import javax.xml.bind.annotation.*;

@XmlType(propOrder={"id", "firstName", "lastName", "phoneNumbers"})
public class Customer {

    private int id;
    private String firstName;
    private String lastName;
    private List<PhoneNumber> phoneNumbers = new ArrayList<PhoneNumber>();

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    @XmlElement(nillable=true)
    public String getLastName() {
        return lastName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    @XmlElement
    public List<PhoneNumber> getPhoneNumbers() {
        return phoneNumbers;
    }

}

PhoneNumber 

package blog.jsonp.moxy;

import javax.xml.bind.annotation.*;

@XmlAccessorType(XmlAccessType.FIELD)
public class PhoneNumber {

    private String type;

    private String number;

    public String getType() {
        return type;
    }

    public void setType(String type) {
        this.type = type;
    }

    public String getNumber() {
        return number;
    }

    public void setNumber(String number) {
        this.number = number;
    }

}

jaxb.properties

To specify MOXy as your JAXB provider you need to include a file called jaxb.properties in the same package as your domain model with the following entry (see:  Specifying EclipseLink MOXy as your JAXB Provider)

javax.xml.bind.context.factory=org.eclipse.persistence.jaxb.JAXBContextFactory

Marshal Demo 

In the demo code below we will use a combination of JSR-353 and MOXy APIs to produce JSON.  JSR-353′s JsonObjectBuilder and JsonArrayBuilder are used to produces instances of JsonObject and JsonArray.  We can use MOXy to marshal to these builders by wrapping them in instances of MOXy’s JsonObjectBuilderResult and JsonArrayBuilderResult.

package blog.jsonp.moxy;

import java.util.*;
import javax.json.*;
import javax.json.stream.JsonGenerator;
import javax.xml.bind.*;
import org.eclipse.persistence.jaxb.JAXBContextProperties;
import org.eclipse.persistence.oxm.json.*;

public class MarshalDemo {

    public static void main(String[] args) throws Exception {
        // Create the EclipseLink JAXB (MOXy) Marshaller
        Map<String, Object> jaxbProperties = new HashMap<String, Object>(2);
        jaxbProperties.put(JAXBContextProperties.MEDIA_TYPE, "application/json");
        jaxbProperties.put(JAXBContextProperties.JSON_INCLUDE_ROOT, false);
        JAXBContext jc = JAXBContext.newInstance(new Class[] {Customer.class}, 
            jaxbProperties);
        Marshaller marshaller = jc.createMarshaller();

        // Create the JsonArrayBuilder
        JsonArrayBuilder customersArrayBuilder = Json.createArrayBuilder();

        // Build the First Customer
        Customer customer = new Customer();
        customer.setId(1);
        customer.setFirstName("Jane");
        customer.setLastName(null);

        PhoneNumber phoneNumber = new PhoneNumber();
        phoneNumber.setType("cell");
        phoneNumber.setNumber("555-1111");
        customer.getPhoneNumbers().add(phoneNumber);

        // Marshal the First Customer Object into the JsonArray
        JsonArrayBuilderResult result = 
            new JsonArrayBuilderResult(customersArrayBuilder);
        marshaller.marshal(customer, result);

        // Build List of PhoneNumer Objects for Second Customer
        List<PhoneNumber> phoneNumbers = new ArrayList<PhoneNumber>(2);

        PhoneNumber workPhone = new PhoneNumber();
        workPhone.setType("work");
        workPhone.setNumber("555-2222");
        phoneNumbers.add(workPhone);

        PhoneNumber homePhone = new PhoneNumber();
        homePhone.setType("home");
        homePhone.setNumber("555-3333");
        phoneNumbers.add(homePhone);

        // Marshal the List of PhoneNumber Objects
        JsonArrayBuilderResult arrayBuilderResult = new JsonArrayBuilderResult();
        marshaller.marshal(phoneNumbers, arrayBuilderResult);

        customersArrayBuilder
            // Use JSR-353 APIs for Second Customer's Data
            .add(Json.createObjectBuilder()
                .add("id", 2)
                .add("firstName", "Bob")
                .addNull("lastName")
                // Included Marshalled PhoneNumber Objects
                .add("phoneNumbers", arrayBuilderResult.getJsonArrayBuilder())
             )
        .build();

        // Write JSON to System.out
        Map<String, Object> jsonProperties = new HashMap<String, Object>(1);
        jsonProperties.put(JsonGenerator.PRETTY_PRINTING, true);
        JsonWriterFactory writerFactory = Json.createWriterFactory(jsonProperties);
        JsonWriter writer = writerFactory.createWriter(System.out);
        writer.writeArray(customersArrayBuilder.build());
        writer.close();
    }

}

Output

Below is the output from running the marshal demo (MarshalDemo).  The highlighted portions (lines 2-12 and 18-25) correspond to the portions that were populated from our Java model.

[
    {
        "id":1,
        "firstName":"Jane",
        "lastName":null,
        "phoneNumbers":[
            {
                "type":"cell",
                "number":"555-1111"
            }
        ]
    },
    {
        "id":2,
        "firstName":"Bob",
        "lastName":null,
        "phoneNumbers":[
            {
                "type":"work",
                "number":"555-2222"
            },
            {
                "type":"home",
                "number":"555-3333"
            }
        ]
    }
]

Unmarshal Demo 

MOXy enables you to unmarshal from a JSR-353 JsonStructure (JsonObject or JsonArray).  To do this simply wrap the JsonStructure in an instance of MOXy’s JsonStructureSource and use one of the unmarshal operations that takes an instance of Source.

package blog.jsonp.moxy;

import java.io.FileInputStream;
import java.util.*;
import javax.json.*;
import javax.xml.bind.*;
import org.eclipse.persistence.jaxb.JAXBContextProperties;
import org.eclipse.persistence.oxm.json.JsonStructureSource;

public class UnmarshalDemo {

    public static void main(String[] args) throws Exception {
        try (FileInputStream is = new FileInputStream("src/blog/jsonp/moxy/input.json")) {
            // Create the EclipseLink JAXB (MOXy) Unmarshaller
            Map<String, Object> jaxbProperties = new HashMap<String, Object>(2);
            jaxbProperties.put(JAXBContextProperties.MEDIA_TYPE, "application/json");
            jaxbProperties.put(JAXBContextProperties.JSON_INCLUDE_ROOT, false);
            JAXBContext jc = JAXBContext.newInstance(new Class[] {Customer.class}, 
                jaxbProperties);
            Unmarshaller unmarshaller = jc.createUnmarshaller();

            // Parse the JSON
            JsonReader jsonReader = Json.createReader(is);

            // Unmarshal Root Level JsonArray
            JsonArray customersArray = jsonReader.readArray();
            JsonStructureSource arraySource = new JsonStructureSource(customersArray);
            List<Customer> customers = 
                (List<Customer>) unmarshaller.unmarshal(arraySource, Customer.class)
                .getValue();
            for(Customer customer : customers) {
                System.out.println(customer.getFirstName());
            }

            // Unmarshal Nested JsonObject
            JsonObject customerObject = customersArray.getJsonObject(1);
            JsonStructureSource objectSource = new JsonStructureSource(customerObject);
            Customer customer = unmarshaller.unmarshal(objectSource, Customer.class)
                .getValue();
            for(PhoneNumber phoneNumber : customer.getPhoneNumbers()) {
                System.out.println(phoneNumber.getNumber());
            }
        }
    }

}

Input (input.json)

The following JSON input will be converted to a JsonArray using a JsonReader.

[
    {
        "id":1,
        "firstName":"Jane",
        "lastName":null,
        "phoneNumbers":[
            {
                "type":"cell",
                "number":"555-1111"
            }
        ]
    },
    {
        "id":2,
        "firstName":"Bob",
        "lastName":null,
        "phoneNumbers":[
            {
                "type":"work",
                "number":"555-2222"
            },
            {
                "type":"home",
                "number":"555-3333"
            }
        ]
    }
]

Output

Below is the output from running the unmarshal demo (UnmarshalDemo).

Jane
Bob
555-2222
555-3333

 

Related Whitepaper:

Bulletproof Java Code: A Practical Strategy for Developing Functional, Reliable, and Secure Java Code

Use Java? If you do, you know that Java software can be used to drive application logic of Web services or Web applications. Perhaps you use it for desktop applications? Or, embedded devices? Whatever your use of Java code, functional errors are the enemy!

To combat this enemy, your team might already perform functional testing. Even so, you're taking significant risks if you have not yet implemented a comprehensive team-wide quality management strategy. Such a strategy alleviates reliability, security, and performance problems to ensure that your code is free of functionality errors.Read this article to learn about this simple four-step strategy that is proven to make Java code more reliable, more secure, and easier to maintain.

Get it Now!  

Leave a Reply


7 + = fourteen



Java Code Geeks and all content copyright © 2010-2014, Exelixis Media Ltd | Terms of Use
All trademarks and registered trademarks appearing on Java Code Geeks are the property of their respective owners.
Java is a trademark or registered trademark of Oracle Corporation in the United States and other countries.
Java Code Geeks is not connected to Oracle Corporation and is not sponsored by Oracle Corporation.

Sign up for our Newsletter

15,153 insiders are already enjoying weekly updates and complimentary whitepapers! Join them now to gain exclusive access to the latest news in the Java world, as well as insights about Android, Scala, Groovy and other related technologies.

As an extra bonus, by joining you will get our brand new e-books, published by Java Code Geeks and their JCG partners for your reading pleasure! Enter your info and stay on top of things,

  • Fresh trends
  • Cases and examples
  • Research and insights
  • Two complimentary e-books