JPA Entities to XML - Bidirectional Relationships

JAXB is your best choice when binding Java objects to XML.  But what happens when those Java objects turn out to be JPA entities?  For the most part it is business as usual, although there are a couple things to be aware of.  In this post we'll cover a MOXy extension that can be used to map a bidirectional relationship.


We'll use the following model.  Notice how Customer has a relationship to Address, and Address has a relationship back to Customer.  In JPA one direction of the relationship is mapped (in this case the customer property on Address), and the other direction specifies a mapping to leverage.

import javax.persistence.*;

@Entity
public class Customer {

    @Id
    private long id;

    @OneToOne(mappedBy="customer", cascade={CascadeType.ALL})
    private Address address;

}

import javax.persistence.*;

@Entity
public class Address implements Serializable {

    @Id
    private long id;

    @MapsId
    @OneToOne
    @JoinColumn(name="ID")
    private Customer customer;

}

Using vanilla JAXB to marshal these objects to XML you need to mark one direction @XmlTrasient, this prevents JAXB from entering an infinite loop during marshalling (object-to-XML).  During unmarshalling (XML-to-object) however you are responsible for populating the back pointer yourself.

import javax.persistence.*;
import javax.xml.bind.annotation.*;

@Entity
public class Address implements Serializable {

    @Id
    private long id;

    @OneToOne
    @JoinColumn(name="ID")
    @MapsId
    @XmlTransient
    private Customer customer;

}

MOXy offers an extension that will populate the back pointer for you, this is done with the @XmlInverseReference annotation.  Note how @XmlInverseReference annotation leverages the same "mappedBy" concept.

import javax.persistence.*;
import org.eclipse.persistence.oxm.annotations.*;

@Entity
public class Address implements Serializable {

    @Id
    private long id;

    @OneToOne
    @JoinColumn(name="ID")
    @MapsId
    @XmlInverseReference(mappedBy="address")
    private Customer customer;

}

Now as I'll demonstrate below you can move your data from JPA to JAXB and back again without having to modify the data:

// Read customer from database
EntityManagerFactory emf = 
    Persistence.createEntityManagerFactory("CustomerService");
EntityManager em = emf.createEntityManager();
Customer customer = em.find(Customer.class, (long) 1);
        
// Save customer to XML
JAXBContext jc = JAXBContext.newInstance(Customer.class);
Marshaller marshaller = jc.createMarshaller();
StringWriter writer = new StringWriter();
marshaller.marshal(customer, writer);
       
// Load customer from XML 
Unmarshaller unmarshaller = jc.createUnmarshaller();
StringReader reader = new StringReader(writer.toString());
Customer detachedCustomer = 
    (Customer) unmarshaller.unmarshal(reader);
detachedCustomer.setLastName("Jones");

// Persist customer to database
Customer mergedCustomer = em.merge(detachedCustomer);
em.getTransaction().begin();
em.persist(mergedCustomer);
em.getTransaction().commit();
em.close();

In future posts I'll describe other MOXy extensions used to map JPA entities to XML.