Class JAXBHelperContext

java.lang.Object
org.eclipse.persistence.sdo.helper.SDOHelperContext
org.eclipse.persistence.sdo.helper.jaxb.JAXBHelperContext
All Implemented Interfaces:
HelperContext

public class JAXBHelperContext extends SDOHelperContext

The JAXBHelperContext is a bridge between POJOs and SDO DataObjects. The bridge is based on their corresponding XML representations. For the POJOs the XML representation is specified using JAXB annotations or object-to-XML mappings.

The following steps are required to create the JAXBHelperContext. The XML schema used in step #3 is the same one that the POJOs are mapped to. This step has been separated so that SDO annotations could be added to the XML schema.

Step #1 - Create the JAXBContext

 JAXBContext jaxbContext = JAXBContext.newInstance("com.example.customer");
 

Step #2 - Create the JAXBHelperContext

 JAXBHelperContext jaxbHelperContext = new JAXBHelperContext(jaxbContext);
 

Step #3 - Create the SDO Metadata from an XML Schema

 jaxbHelperContext.getXSDHelper().define(xmlSchema);
 

The JAXBHelperContext allows you to convert between POJOs and DataObjects using a wrap operation.

 Customer customer = new Customer();
 Address address new Address();
 address.setStreet("123 Any Street");
 customer.set(address);

 DataObject customerDO = jaxbHelperContext.wrap(customer);
 customerDO.getString("address/street");  // returns "123 Any Street"
 

The JAXBHelperContext allows you to convert between DataObjects and POJOs using an unwrap operation.

 Type customerType = jaxbHelperContext.getType(Customer.class);
 DataObject customerDO = jaxbHelperContext.getDataFactory().create(customerType);
 customerDO.set("first-name", "Jane");

 Customer customer = jaxbHelperContext.unwrap(customerDO);
 customer.getFirstName();  // returns "Jane"
 

Of course the POJOs may be JPA entities. Below is an example of wrapping the results of a JPA query.

 EntityManagerFactory emf = Persistence.createEntityManagerFactory("CustomerExample");
 EntityManager em = emf.createEntityManager();
 List<MyEntity> entities = em.createQuery("SELECT e FROM MyEntity e WHERE ...").getResultList();
 List<DataObject> dataObjects = hc.wrap(entities);
 
  • Constructor Details

    • JAXBHelperContext

      public JAXBHelperContext(JAXBContext aJAXBContext)
      Create a new instance of JAXBHelperContext
      Parameters:
      aJAXBContext - - The JAXBContext representing the class to XML schema mapping.
    • JAXBHelperContext

      public JAXBHelperContext(JAXBContext aJAXBContext, ClassLoader aClassLoader)
      Create a new instance of JAXBHelperContext
      Parameters:
      aJAXBContext - - The JAXBContext representing the class to XML schema mapping.
      aClassLoader - - The ClassLoader containing the generated SDO classes/interfaces (if any).
  • Method Details

    • initialize

      protected void initialize(ClassLoader aClassLoader)
      Override the default helpers/factories, replacing them with JAXB aware ones where necessary.
      Overrides:
      initialize in class SDOHelperContext
      Parameters:
      aClassLoader -
    • getJAXBContext

      public JAXBContext getJAXBContext()
      Return the JAXBContext. The JAXBContext represents the Java class to XML schema information for the POJOs.
    • getType

      public Type getType(Class<?> entityClass)
      Return the SDO type corresponding to the wrapped class.
       Type customerType = jaxbHelperContext.getType(Customer.class);
       DataObject customerDO = jaxbHelperContext.getDataFactory().create(customerType);
       
    • getClass

      public Class<?> getClass(Type type)
      Return the wrapped class corresponding to the SDO type.
       Type customerType = jaxbHelperContext.getTypeHelper().getType("urn:customer", "customer");
       Class customerClass = jaxbHelperContext.getClass(customerType);
       
    • wrap

      public DataObject wrap(Object entity)
      Return a DataObject that wraps a POJO. This call should be made on the root POJO.
       Customer customer = new Customer();
       Address address new Address();
       address.setStreet("123 Any Street");
       customer.set(address);
      
       DataObject customerDO = jaxbHelperContext.wrap(customer);
       customerDO.getString("address/street");  // returns "123 Any Street"
       
      Multiple calls to wrap for the same instance POJO return the same instance of DataObject, in other words the following is always true:
       jaxbHelperContext.wrap(customer123) == jaxbHelperContext.wrap(customer123)
       jaxbHelperContext.wrap(customer123) != jaxbHelperContext.wrap(customer456)
       
    • wrap

      public List<DataObject> wrap(Collection<Object> entities)
      Perform the wrap operation on each of the POJOs in the collection, and return the results as a List.
    • unwrap

      public Object unwrap(DataObject dataObject)
      Return the POJO that is wrapped by the DataObject.
       Type customerType = jaxbHelperContext.getType(Customer.class);
       DataObject customerDO = jaxbHelperContext.getDataFactory().create(customerType);
       DataObject addressDO = customerDO.create("address");
       addressDO.set("street", "123 Any Street");
      
       Customer customer = (Customer) jaxbHelperContext.unwrap(customerDO);
       customer.getAddress().getStreet();  // returns "123 Any Street"
       
      Multiple calls to unwrap for the same DataObject must return the same instance of Object, in other words the following is always true:
       jaxbHelperContext.unwrap(customerDO123) == jaxbHelperContext.unwrap(customerDO123)
       jaxbHelperContext.unwrap(customerDO123) != jaxbHelperContext.unwrap(customerDO456)
       customer123 == jaxbHelperContext.unwrap(jaxbHelperContext.wrap(customer123))
       
    • unwrap

      public List<Object> unwrap(Collection<DataObject> dataObjects)
      Perform the unwrap operation on each of the DataObjects in the collection, and return the results as a List.