7 Mapping JPA to XML

7.2.1.1 Task 1: Define the Accessor Type and Import Packages

Since all of the following examples use the same accessor type, FIELD, define it at the package level by using the JAXB annotation @XmlAccessorType. At this point, you would also import the necessary packages:

@XmlAccessorType(XmlAccessType.FIELD)
package com.example.model;
 
import javax.xml.bind.annotation.XmlAccessType;
import javax.xml.bind.annotation.XmlAccessorType;

7.2.1.2 Task 2: Map Privately-Owned Relationships

A "privately-owned" relationship occurs when the target object is only referenced by a single source object. This type of relationship can be either one-to-one and embedded or one-to-many.

This Task shows how to create bi-directional mappings for both of these types of relationships between the Employee entity and the Address and PhoneNumber entities.

7.2.1.3 Task 3: Map the Shared Reference Relationship

A shared reference relationship occurs when target objects are referenced by multiple source objects. For example, a business might be segregated into multiple departments, such as IT, human resources, finance, and so on. Each of these departments has multiple employees of differing job descriptions, pay grades, locations, and so on. Managing departments and employees requires shared reference relationships.

Since a shared reference relationship cannot be safely represented as nesting in XML, we use key relationships. In order to leverage the ID fields on JPA entities, you need to use the TopLink JAXB @XmlID annotation on non-String fields and properties and @XmlIDREF on string fields and properties.

This section contains examples that show how to map a many-to-one shared reference relationship and a many-to-many shared reference relationship.

7.2.1.4 JPA Entities

Once the mappings are created, the entities should look like those in the following examples:

• Example 7-1, "Employee Entity"

• Example 7-2, "Address Entity"

• Example 7-3, "PhoneNumber Entity"

• Example 7-4, "Department Entity"

@Entity
public class Employee {
 
    @Id
    @Column(name="E_ID")
    private BigDecimal eId;
 
    private String name;
 
    @OneToOne(mappedBy="resident")
    private Address residence;
 
    @OneToMany(mappedBy="contact")
    private List<PhoneNumber> contactNumber;
 
    @ManyToMany(mappedBy="member")
    private List<Department> team;
 
}

@Entity
public class Address {
 
    @Id
    @Column(name="E_ID", insertable=false, updatable=false)
    private BigDecimal eId;
 
    private String city;
 
    private String street;
 
    @OneToOne
    @JoinColumn(name="E_ID")
    private Employee resident;
 
}

@Entity
@Table(name="PHONE_NUMBER")
public class PhoneNumber {
 
    @Id
    @Column(name="P_ID")
    private BigDecimal pId;
 
    @ManyToOne
    @JoinColumn(name="E_ID", referencedColumnName = "E_ID")
    private Employee contact;
 
    private String num;
 
}

@Entity
public class Department {
 
    @Id
    @Column(name="D_ID")
    private BigDecimal dId;
 
    private String name;
 
    @ManyToMany
    @JoinTable(name="DEPT_EMP", joinColumns = 
        @JoinColumn(name="D_ID", referencedColumnName = "D_ID"), 
            inverseJoinColumns = @JoinColumn(name="E_ID", 
                referencedColumnName = "E_ID"))
    private List<Employee> member;
 
}

7.2.2.1 Task1: Define the XML Accessor Type

Define the accessor type as FIELD, as described in Section 7.2.1.1, "Task 1: Define the Accessor Type and Import Packages"

7.2.2.2 Task 2: Create the Target Object

To create the target object, do the following:

1. Create an Employee entity with a composite primary key class called EmployeeID to map to multiple fields or properties of the entity:

   @Entity
   @IdClass(EmployeeId.class)
   public class Employee {
   

2. Specify the first primary key, eId, of the entity and map it to a column:

   @Id
       @Column(name="E_ID")
       @XmlID
       private BigDecimal eId;
   

3. Specify the second primary key, country. In this instance, you need to use @XmlKey to identify the primary key because only one property—here, eId—can be annotated with the @XmlID.Cre

   @Id
       @XmlKey
       private String country;
   

   The @XmlKey annotation marks a property as a key that will be referenced by using a key-based mapping via the @XmlJoinNode annotation in the source object. This is similar to the @XmlKey annotation except it doesn't require the property be bound to the schema type ID. This is a typical application of the @XmlKey annotation.

4. Create a many-to-one mapping of the Employee property on PhoneNumber by inserting the following code:

   @OneToMany(mappedBy="contact")
       @XmlInverseReference(mappedBy="contact")
       private List<PhoneNumber> contactNumber;
   

The Employee entity should look like Example 7-5

@Entity
@IdClass(EmployeeId.class)
public class Employee {
 
    @Id
    @Column(name="E_ID")
    @XmlID
    private BigDecimal eId;
 
    @Id
    @XmlKey
    private String country;
 
    @OneToMany(mappedBy="contact")
    @XmlInverseReference(mappedBy="contact")
    private List<PhoneNumber> contactNumber;
 
}

7.2.2.3 Task 3: Create the Source Object

This Task creates the source object, the PhoneNumber entity. Because the target object has a compound key, we need to use the Oracle TopLink's @XmlJoinNodes annotation to set up the mapping.

To create the source object:

1. Create the PhoneNumber entity:

   @Entity
   public class PhoneNumber {
   

2. Create a many-to-one relationship and define the join columns:

   @ManyToOne
       @JoinColumns({
           @JoinColumn(name="E_ID", referencedColumnName = "E_ID"),
           @JoinColumn(name="E_COUNTRY", referencedColumnName = "COUNTRY")
      })
   

3. Set up the mapping by using the Oracle TopLink's @XmlJoinNodes annotation

   @XmlJoinNodes( {
           @XmlJoinNode(xmlPath="contact/id/text()", referencedXmlPath="id/text()"),
           @XmlJoinNode(xmlPath="contact/country/text()", referencedXmlPath="country/text()")
       })
   

4. Define the contact property:

   private Employee contact;
    
   }
   

The target object should look like Example 7-6.

@Entity
public class PhoneNumber {
 
    @ManyToOne
    @JoinColumns({
        @JoinColumn(name="E_ID", referencedColumnName = "E_ID"),
        @JoinColumn(name="E_COUNTRY", referencedColumnName = "COUNTRY")
    })
    @XmlJoinNodes( {
        @XmlJoinNode(xmlPath="contact/id/text()", referencedXmlPath="id/text()"),
        @XmlJoinNode(xmlPath="contact/country/text()", referencedXmlPath="country/text()")
    })
    private Employee contact;
 
}

7.2.3.1 Task1: Define the XML Accessor Type

Define the XML accessor type as FIELD, as described in Section 7.2.1.1, "Task 1: Define the Accessor Type and Import Packages"

7.2.3.2 Task 2: Create the Target Object

The target object is an entity called Employee and contains the mapping for an employee's contact phone number. Creating this target object requires implementing a DescriptorCustomizer interface, so you must include TopLink's @XmlCustomizer annotation Also, since the relationship is bidirectional, you must also implement the @XmlInverseReference. annotation.

To create the target object:

1. Create the Employee entity. Use the @IdClass annotation to specify that the EmployeeID class will be mapped to multiple properties of the entity and use the @XmlCustomizer annotation to indicate that the class EmployeeCustomizer will implement the DescriptorCustomizer interface (see Section 7.2.3.3, "Task 3: Implement the DescriptorOrganizer as EmployeeCustomizer Class").

   @Entity
   @IdClass(EmployeeId.class)
   public class Employee {
   

2. Define the id property and make it embeddable.

   @EmbeddedId
       @XmlPath(".");
       private EmployeeId id;
   

3. Define a one-to-many mapping—in this case, the employee property on PhoneNumber. Because the relationship is bi-directional, use @XmlInverseReference to define the return mapping. Both of these relationships will be owned by the contact field, as indicated by the mappedBy argument.

   @OneToMany(mappedBy="contact")
       @XmlInverseReference(mappedBy="contact")
       private List<PhoneNumber> contactNumber;
   

The completed target object should look like Example 7-7.

@Entity
@IdClass(EmployeeId.class)
@XmlCustomizer(EmployeeCustomizer.class)
public class Employee {
 
    @EmbeddedId
    private EmployeeId id;
 
    @OneToMany(mappedBy="contact")
    @XmlInverseReference(mappedBy="contact")
    private List<PhoneNumber> contactNumber;
 
}

7.2.3.3 Task 3: Implement the DescriptorOrganizer as EmployeeCustomizer Class

In Task 2: Create the Target Object, DescriptorCustomizer was implemented as the class EmployeeCustomizer. This allows changing the XML Path (XPath) on the mapping for the id property to either self or "." and then specifying the XPath to the XML nodes that represent the ID. To do this:

1. Implement the DescriptorOrganizer class as EmployeeOrganizer.

   import org.eclipse.persistence.oxm.mappings.XMLCompositeObjectMapping;
    
   public class EmployeeCustomizer implements DescriptorCustomizer {
   

2. Specify the XPath to the XML nodes which represent the ID:

   descriptor.addPrimaryKeyFieldName("eId/text()");
           descriptor.addPrimaryKeyFieldName("country/text()");
   

The EmployeeCustomizer class should look like Example 7-8.

import org.eclipse.persistence.config.DescriptorCustomizer;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.oxm.mappings.XMLCompositeObjectMapping;
 
public class EmployeeCustomizer implements DescriptorCustomizer {
 
        descriptor.addPrimaryKeyFieldName("eId/text()");
        descriptor.addPrimaryKeyFieldName("country/text()");
    }
 
}

7.2.3.4 Task 4: Create the Source Object

The source object in this example has a compound key, so you must mark the field @XmlTransient to prevent a key from being mapped by itself. Use TopLink's @XmlCustomizer annotation to set up the mapping.

To create the source object, do the following:

1. Create the PhoneNumber entity and specify another class, PhoneNumberCustomizer to implement the DescriptorCustomizer interface.

   @Entity
   @XmlCustomizer(PhoneNumberCustomizer.class)
   public class PhoneNumber {
   

2. Create a many-to-one mapping and define the join columns.

   @ManyToOne
       @JoinColumns({
           @JoinColumn(name="E_ID", referencedColumnName = "E_ID"),
           @JoinColumn(name="E_COUNTRY", referencedColumnName = "COUNTRY")
       })
   

3. Define the contact property. Be sure to use the @XmlTranscient annotation to prevent this key from being mapped by itself.

@XmlTransient
    private Employee contact;

The completed PhoneNumber class should look like Example 7-9.

@Entity
@XmlCustomizer(PhoneNumberCustomizer.class)
public class PhoneNumber {
 
    @ManyToOne
    @JoinColumns({
        @JoinColumn(name="E_ID", referencedColumnName = "E_ID"),
        @JoinColumn(name="E_COUNTRY", referencedColumnName = "COUNTRY")
    })
    @XmlTransient
    private Employee contact;
 
}

7.2.3.5 Task 5: Implement the DescriptorCustomizer as PhoneNumberCustomizer Class

Code added in Task 4 indicated the need to create the XMLObjectReferenceMappings to the new values. This requires to implementing the DescriptorCustomizer as the PhoneNumberCustomizer and adding the multiple key mappings. To do this:

1. Implement DescriptorCustomizer as PhoneNumberCustomizer. Be sure to import org.eclipse.persistence.oxm.mappings.XMLObjectReferenceMapping:

   import org.eclipse.persistence.oxm.mappings.XMLObjectReferenceMapping;
    
   public class PhoneNumberCustomizer implements DescriptorCustomizer {
   

2. In the customize method, update the following mappings:

   • contactMapping.setAttributeName to "contact".

   • contactMapping.addSourceToTargetKeyFieldAssociation to "contact/@eID", "eId/text()".

   • contactMapping.addSourceToTargetKeyFieldAssociation to "contact/@country", "country/text()".

PhoneNumberCustomizer should look like Example 7-10.

import org.eclipse.persistence.config.DescriptorCustomizer;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.oxm.mappings.XMLObjectReferenceMapping;
 
public class PhoneNumberCustomizer implements DescriptorCustomizer {
 
    public void customize(ClassDescriptor descriptor) throws Exception {
        XMLObjectReferenceMapping contactMapping = new XMLObjectReferenceMapping();
        contactMapping.setAttributeName("contact");
        contactMapping.setReferenceClass(Employee.class);
        contactMapping.addSourceToTargetKeyFieldAssociation("contact/@eID", "eId/text()");
        contactMapping.addSourceToTargetKeyFieldAssociation("contact/@country", "country/text()");
        descriptor.addMapping(contactMapping);
    }
 
}

7.3.1.1 Mapping from the Java Object

The key to creating this mapping from a Java object is the @XmlAttribute JAXB annotation, which maps the field to the XML attribute. To create this mapping:

1. Create the object and import javax.xml.bind.annotation.*:

   package example;
    
   import javax.xml.bind.annotation.*;
   

2. Declare the Customer class and use the @XmlRootElement annotation to make it the root element. Set the XML accessor type to FIELD:

   @XmlRootElement
   @XmlAccessorType(XmlAccessType.FIELD)
   public class Customer {
   

3. Map the id property in the Customer class as an attribute:

   @XmlAttribute
      private Integer id;
   

The object should look like Example 7-12.

package example;
 
import javax.xml.bind.annotation.*;
 
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
   @XmlAttribute
   private Integer id;
 
   ...
}

7.3.1.2 Defining the Mapping in OXM Metadata Format

If you want to represent the mapping in Oracle TopLink's OXM metadata format, you need to use the XML tags defined in the eclipselink-oxm.xml file and populate them with the appropriate values, as shown in Example 7-13.

...
<java-type name="Customer">
   <xml-root-element name="customer"/>
   <java-attributes>
      <xml-attribute java-attribute="id"/>
   </java-attributes>
</java-type>
...

For more information on the OXM metadata format, see Section 7.4, "Using XML Metadata Representation to Override JAXB Annotations".

7.3.2.1 Mapping a Value to a Simple Text Node

You can map a value from a Java object either by using JAXB annotations in the Java object or, alternately, by representing the mapping in TopLink's OXM metadata format.

package example;
 
import javax.xml.bind.annotation.*;
 
@XmlRootElement(name="phone-number")
@XmlAccessorType(XmlAccessType.FIELD)
public class PhoneNumber {
   @XmlValue
   private String number;
 
   ...
}

...
<java-type name="PhoneNumber">
   <xml-root-element name="phone-number"/>
   <java-attributes>
      <xml-value java-attribute="number"/>
   </java-attributes>
</java-type>
...

7.3.2.2 Mapping Values to a Text Node in a Simple Sequence

You can map a sequence of values, for example a customer's first and last name, as separate elements either by using JAXB annotations or by representing the mapping in TopLink's OXM metadata format. The following procedures illustrate how to map values for a customers' first names and last names

package example;
 
import javax.xml.bind.annotation.*;
 
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
   @XmlElement(name="first-name")
   private String firstName;
 
   @XmlElement(name="last-name")
   private String lastName;
 
   ...
}

...
<java-type name="Customer">
   <xml-root-element name="customer"/>
   <java-attributes>
      <xml-element java-attribute="firstName" name="first-name"/>
      <xml-element java-attribute="lastName" name="last-name"/>
   </java-attributes>
</java-type>
...

7.3.2.3 Mapping a Value to a Text Node in a Sub-element

You can map values from a Java object to text nodes that are nested as a subelement in the XML document by using JAXB annotations or by representing the mapping in Oracle TopLink's OXM metadata format. For example, if you want to populate <first-name> and <last-name> elements, which are sub-elements of a <personal-info> element under a <customer> root, you could use the following procedures to achieve these mappings.

package example;
 
import javax.xml.bind.annotation.*;
import org.eclipse.persistence.oxm.annotations.*;
 
@XmlRootElement
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
   @XmlPath("personal-info/first-name/text()")
   private String firstName;
 
   @XmlPath("personal-info/last-name/text()")
   private String lastName;
 
   ...
}

...
<java-type name="Customer">
   <xml-root-element name="customer"/>
   <java-attributes>
      <xml-element java-attribute="firstName" xml-path="personal-info/first-name/text()"/>
      <xml-element java-attribute="lastName" xml-path="personal-info/last-name/text()"/>
   </java-attributes>
</java-type>
...

7.3.2.4 Mapping Values to a Text Node by Position

When multiple nodes have the same name, map their values from the Java object by specifying their position in the XML document. Do this by using mapping the values to the position of the attribute rather than the attribute's name. You can do this either by using JAXB annotations or by or by representing the mapping in TopLink's OXM metadata format. In the following example, XML contains two <name> elements; the first occurrence of name should represent the Customer's first name, the second name their last name.

package example;
 
import javax.xml.bind.annotation.*;
 
import org.eclipse.persistence.oxm.annotations.XmlPath;
 
@XmlRootElement
@XmlType(propOrder={"firstName", "lastName"})
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
    @XmlPath("name[1]/text()")
    private String firstName;
 
    @XmlPath("name[2]/text()")
    private String lastName;
 
    ...
}

7.5.3.1 Task 1: Create the Customer Entity

To create the Customer class entity:

1. Import the necessary JPA packages by adding the following code:

   import javax.xml.bind.annotation.*;
    
   import org.eclipse.persistence.oxm.annotations.XmlPath;
    
   

2. Declare the Customer class and use the @XmlRootElement annotation to make it the root element. Set the XML accessor type to FIELD:

   @XmlRootElement
   @XmlAccessorType(XmlAccessType.FIELD)
   public class Customer {
   

3. Declare local to the Customer class these properties:

   • firstName (String type)

   • lastName (String)

   • Address (Address)

   For each property, set the Xpath predicate by preceding the property declaration with the annotation @XmlPath(element-name[@attribute-name='value']); for example, for firstName, you would set the XPath predicate with this statement:

   @XmlPath("node[@name='first-name']/text()")
   

4. Also local to the Customer class, declare the phoneNumber property as a List<PhoneNumber> type and assign it the value new ArrayList<PhoneNumber>().

The Customer class should look like the snippet in Example 7-23.

package example;
 
import javax.xml.bind.annotation.*;
 
import org.eclipse.persistence.oxm.annotations.XmlPath;
 
@XmlRootElement(name="node")
@XmlAccessorType(XmlAccessType.FIELD)
public class Customer {
 
    @XmlPath("node[@name='first-name']/text()")
    private String firstName;
 
    @XmlPath("node[@name='last-name']/text()")
    private String lastName;
 
    @XmlPath("node[@name='address']")
    private Address address;
 
    @XmlPath("node[@name='phone-number']")
    private List<PhoneNumber> phoneNumbers = new ArrayList<PhoneNumber>();
 
    ...
}

7.5.3.2 Task 2: Create the Address Entity

To create the Address class, do the following:

1. Import the necessary JPA packages by adding the following code:

   import javax.xml.bind.annotation.*;
    
   import org.eclipse.persistence.oxm.annotations.XmlPath;
    
   

2. Declare the Address class and set the XML accessor type to FIELD:

   @XmlAccessorType(XmlAccessType.FIELD)
   public class Address {
   

   This instance does not require the @XmlRootElement annotation as in the previous Tasks because the Address class is root not a root element in the XML document.

3. Declare local to the Address class the String property street. Set the XPath predicate by preceding the property declaration with the annotation @XmlPath("node[@name='street']/text()").

The Address class should look like Example 7-24.

package example;
 
import javax.xml.bind.annotation.*;
 
import org.eclipse.persistence.oxm.annotations.XmlPath;
 
@XmlAccessorType(XmlAccessType.FIELD)
public class Address {
 
    @XmlPath("node[@name='street']/text()")
    private String street;
 
    ...
}

7.5.3.3 Task 3: Create the PhoneNumber Entity

To create the PhoneNumber entity:

1. Import the necessary JPA packages by adding the following code:

   import javax.xml.bind.annotation.*;
    
   import org.eclipse.persistence.oxm.annotations.XmlPath;
    
   

2. Declare the PhoneNumber class and use the @XmlRootElement annotation to make it the root element. Set the XML accessor type to FIELD:

   @XmlRootElement
   @XmlAccessorType(XmlAccessType.FIELD)
   public class Customer {
   

3. Create the type and string properties and define their mapping as attributes under the PhoneNumber root element by using the @XmlAttribute. annotation.

   @XmlAttribute
       private String type;
    
       @XmlValue
       private String number;
   

The PhoneNumber object should look like Example 7-25.

package example;
 
import javax.xml.bind.annotation.*;
 
@XmlAccessorType(XmlAccessType.FIELD)
public class PhoneNumber {
 
    @XmlAttribute
    private String type;
 
    @XmlValue
    private String number;
 
    ...
}

7.6.1.1 Bootstrapping from an XML Schema

Use the DynamicJAXBContextFactory to create a dynamic JAXBContext. Example 7-27 to bootstrap a DynamicJAXBContext from the customer.xsd schema (Example 7-28) by using createContextFromXSD().

import java.io.FileInputStream;
 
import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContext;
import org.eclipse.persistence.jaxb.dynamic.DynamicJAXBContextFactory;
 
public class Demo {
 
    public static void main(String[] args) throws Exception {
        FileInputStream xsdInputStream = new FileInputStream("src/example/customer.xsd");
        DynamicJAXBContext jaxbContext = 
            DynamicJAXBContextFactory.createContextFromXSD(xsdInputStream, null, null, null);

The first parameter represents the XML schema itself and must be in one of the following forms: java.io.InputStream, org.w3c.dom.Node, or javax.xml.transform.Source.

7.6.1.2 The XML Schema

Example 7-28 shows the customer.xsd schema that represents the metadata for the dynamic JAXBContext you are bootstrapping.

<xsd:schema 
   xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
   xmlns="http://www.example.org" 
   targetNamespace="http://www.example.org"
   elementFormDefault="qualified">
 
   <xsd:complexType name="address">
      <xsd:sequence>
         <xsd:element name="street" type="xsd:string" minOccurs="0"/>
         <xsd:element name="city" type="xsd:string" minOccurs="0"/>
      </xsd:sequence>
   </xsd:complexType>
 
   <xsd:element name="customer">
      <xsd:complexType>
         <xsd:sequence>
            <xsd:element name="name" type="xsd:string" minOccurs="0"/>
            <xsd:element name="address" type="address" minOccurs="0"/>
         </xsd:sequence>
      </xsd:complexType>
   </xsd:element>
 
</xsd:schema>

7.6.1.3 Handling Schema Import/Includes

To bootstrap DynamicJAXBContext from an XML schema that contains imports of other schemas, you need to configure an org.xml.sax.EntityResolver to resolve the locations of the imported schemas and pass the EntityResolver to DynamicJAXBContextFactory.

The following example shows two schema documents, customer.xsd (Example 7-29) and address.xsd Example 7-30). You can see that customer.xsd imports address.xsd by using the statement:

<xsd:import namespace="http://www.example.org/address" schemaLocation="address.xsd"/>

<?xml version="1.0" encoding="UTF-8"?>
   xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
   xmlns:add="http://www.example.org/address"
   xmlns="http://www.example.org/customer" 
   targetNamespace="http://www.example.org/customer"
   elementFormDefault="qualified">
 
   <xsd:import namespace="http://www.example.org/address" schemaLocation="address.xsd"/>
 
   <xsd:element name="customer">
      <xsd:complexType>
         <xsd:sequence>
            <xsd:element name="name" type="xsd:string" minOccurs="0"/>
            <xsd:element name="address" type="add:address" minOccurs="0"/>
         </xsd:sequence>
      </xsd:complexType>
   </xsd:element>
 
</xsd:schema>

<?xml version="1.0" encoding="UTF-8"?>
    xmlns:xsd="http://www.w3.org/2001/XMLSchema" 
    xmlns="http://www.example.org/address" 
    targetNamespace="http://www.example.org/address"
    elementFormDefault="qualified">
 
    <xsd:complexType name="address">
        <xs:sequence>
            <xs:element name="street" type="xs:string"/>
            <xs:element name="city" type="xs:string"/>
        </xs:sequence>
    </xsd:complexType>
 
</xsd:schema>

7.6.1.4 Implementing and Passing an EntityResolver

If you want to bootstrap DynamicJAXBContext from the customer.xsd schema, you need to pass an entity resolver. Do the following:

1. To resolve the locations of the imported schemas, you need to implement an entityResolver by supplying the code shown in Example 7-31.

   Example 7-31 Implementing an EntityResolver

   class MyEntityResolver implements EntityResolver {
   
       public InputSource resolveEntity(String publicId, String systemId) throws SAXException, IOException {
         // Imported schemas are located in ext\appdata\xsd\
   
          // Grab only the filename part from the full path
         String filename = new File(systemId).getName();
   
         // Now prepend the correct path
         String correctedId = "ext/appdata/xsd/" + filename;
   
         InputSource is = new InputSource(ClassLoader.getSystemResourceAsStream(correctedId));
         is.setSystemId(correctedId);
   
         return is;
      }
   
   }
   

2. After you implement your DynamicJAXBContext, pass the EntityResolver, as shown in Example 7-32.

   Example 7-32 Passing in the Entityresolver

   FileInputStream xsdInputStream = new FileInputStream("src/example/customer.xsd");
   DynamicJAXBContext jaxbContext = 
       DynamicJAXBContextFactory.createContextFromXSD(xsdInputStream, new MyEntityResolver(), null, null);
   

7.6.1.5 Error Handling

You might see the following exception when importing another schema:

Internal Exception: org.xml.sax.SAXParseException: schema_reference.4: Failed to read schemadocument '<imported-schema-name>', because 1) could not find the document; 2) the document couldnot be read; 3) the root element of the document is not <xsd:schema>.

To work around this exception, disable XJC's schema correctness check by setting the noCorrectnessCheck Java property. You can set this property one of two ways:

• From within the code, by adding this line:

  System.setProperty("com.sun.tools.xjc.api.impl.s2j.SchemaCompilerImpl.noCorrectnessCheck", "true")
  

• From the command line, by using this command:

  -Dcom.sun.tools.xjc.api.impl.s2j.SchemaCompilerImpl.noCorrectnessCheck=true
  

7.6.1.6 Specifying a ClassLoader

Use your application's current class loader as the classLoader parameter. This parameter verifies that specified classes exist before new DynamicTypes are generated. In most cases you can pass null for this parameter and use Thread.currentThread().getContextClassLoader() instead.

7.6.2.1 Creating the Dynamic Entities

Use the DynamicJAXBContext to create instances of DynamicEntity. The entity and property names correspond to the class and property names—in this case, the customer and address—that would have been generated if you had used static JAXB.

DynamicEntity customer = jaxbContext.newDynamicEntity("org.example.Customer");
customer.set("name", "Jane Doe");
 
DynamicEntity address = jaxbContext.newDynamicEntity("org.example.Address");
address.set("street", "1 Any Street").set("city", "Any Town");
customer.set("address", address);

7.6.2.2 Marshalling the Dynamic Entities to XML

The marshaller obtained from the DynamicJAXBContext is a standard marshaller and can be used normally to marshal instances of DynamicEntity.

Marshaller marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);marshaller.marshal(customer, System.out);

Example 7-35 show resultant XML document:

<?xml version="1.0" encoding="UTF-8"?>
<customer xmlns="www.example.org">
   <name>Jane Doe</name>
   <address>
      <street>1 Any Street</street>
      <city>Any Town</city>
   </address>
</customer>

7.6.3.1 Unmarshal DynamicEntities from XML

The Unmarshaller obtained from the DynamicJAXBContext is a standard unmarshaller, and can be used normally to unmarshal instances of DynamicEntity.

FileInputStream xmlInputStream = new FileInputStream("src/example/dynamic/customer.xml");
Unmarshaller unmarshaller = jaxbContext.createUnmarshaller();
DynamicEntity customer = (DynamicEntity) unmarshaller.unmarshal(xmlInputStream);

7.6.3.2 Get Data from the Dynamic Entity

Next, specify which data in the dynamic entity to obtain. Specify this value by using System.out.println() and passing in the entity name. DynamicEntity offers property-based data access; for example, get("name") instead of getName():

System.out.println(customer.<String>get("name"));

7.6.3.3 Use DynamicType to Introspect Dynamic Entity

Instances of DynamicEntity have a corresponding DynamicType, which you can use to introspect the DynamicEntity, as shown in Example 7-37.

DynamicType addressType = jaxbContext.getDynamicType("org.example.Address"); DynamicEntity address = customer.<DynamicEntity>get("address");for(String propertyName: addressType.getPropertiesNames()) {    System.out.println(address.get(propertyName));}