Correspondances entre données - Data Binding

Cette correspondance est importante dans le sens où elle fait correspondre des objets sauvegardés dans une mémoire volatile avec des tuples appartenant à des tables sauvegardées dans une mémoire persistante, celle d'une base de données.

En Java, elle est spécifiée par une norme, "Java Persistence API", dite JPA, qui fait partie de la spécification JEE. L'implémentation de référence depuis la version 2.0 vient du projet EclipseLink (cf. le composant JPA). Les types et les annotations sont définis dans le paquet javax.persistence.

Bibliographie : cf. chap. 4 à 6, Beginning Java EE 7, d'Antonio Goncalves.

Cette correspondance est importante pour les services puisque XML est un des deux langages principaux d'échange de données, avec JSON.

En Java, il existe quatre méthodes pour traiter des documents XML.

• Flux d'événements : interface SAX ("simple API for XML") permettant de parcourir un document XML en produisant un flux d'événements (ouverture de balise, lecture d'attributs, lecture de contenu, fermeture de balise)
• Modèle universel : représentation d'un document XML par un modèle objet dit DOM (également utilisé dans les navigateurs pour représenter du HTML)
• Interfaçage avec des langages de manipulation de documents XML (particulièrement avec XSLT, "eXtensible Stylesheet Language Transformations")
• Modèle objet : correspondance fonctorielle entre les objets et les documents, spécifiée par une norme, JAXB (version 2), dont l'implémentation vient du projet Metro, inclus dans le projet Glassfish (serveur d'application JEE d'Oracle)

Les trois premières méthodes sont fournies par un ensemble de bibliothèques, appartenant à JAXP ("Java Architecture for XML Processing") et intégré à la version standard (JSE).

La dernière méthode définit une véritable correspondance entre données, appelée couramment "data binding" : elle est fournie par un ensemble de bibliothèques et outils, appartenant à JAXB ("Java Architecture for XML Binding") et intégré à la version standard (JSE).

Bibliographie : cf. chap. 12, Beginning Java EE 7, d'Antonio Goncalves.

Voici l'essentiel permettant d'utiliser JAXB dans un framework à objets pour développer des services Web. L'usage de JAXB repose principalement sur des annotations qu'on trouvera dans le paquet javax.xml.bind.annotation.

La correspondance définie par JAXB est un foncteur, suivant le schéma suivant. Elle ne préserve pas la relation de sous-typage.

classe <------> schéma
 objet <------> document

(Par schéma, nous entendons un schéma complet ou partiel.)

Deux outils fournissent la correspondance pour les types, le générateur de schémas, schemagen, et le compilateur, xjc.

shemagen : classe ------> schéma
           classe <------ schéma : xjc

Le générateur de schémas ne s'applique pas aux interfaces mais seulement aux classes. Il efface les paramètres de types, comme le compilateur Java.

Une classe non annotée produit un schéma partiel, correspondant à un type complexe. Pour obtenir un schéma complet, comportant la déclaration d'un élément racine, il suffit d'annoter la classe par @XmlRootElement, avec la possibilité de modifier le nom de l'élément. Pour modifier le nom du type, utiliser l'annotation @XmlType. Par défaut, le nom de la balise et du type correspondent au nom de la classe (la majuscule initiale devenant une minuscule). Pour obtenir un type anonyme, utiliser un nom vide.

@XmlRootElement(name = "racine")
@XmlType(name = "")
public class A { ... }

Résultat :

<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
<xs:schema version="1.0" xmlns:xs="http://www.w3.org/2001/XMLSchema">
  <xs:element name="racine">
    <xs:complexType>
      <xs:sequence>
       ...
      </xs:sequence>
    </xs:complexType>
  </xs:element>
</xs:schema>

La structure du type complexe est définie par les propriétés (au sens des JavaBeans, cf. annexe ci-dessous) déclarées dans la classe, en prenant en compte non seulement les champs privés avec des accesseurs publics (la convention JavaBean) mais aussi les champs publics. Cette sélection peut être modulée en utilisant l'annotation @XmlAccessorType(XmlAccessType.X) , où X, par défaut PUBLIC_MEMBER, peut exprimer les différentes combinaisons pour les membres publics (accesseurs et champs, accesseurs ou champs, ni l'un ni l'autre sauf mention explicite). On peut retirer un membre de la sélection en utilisant l'annotation XmlTransient.

Par défaut, le type complexe est formé par une séquence d'éléments. L'ordre des éléments est modulable : il suffit d'utiliser l'annotation @XmlType et son attribut propOrder.

@XmlType(propOrder={"un", "deux" , "trois"})
public class A {
  ... // Propriétés un, deux, trois dans un ordre quelconque
}

Résultat :

<xs:complexType name="a">
  <xs:sequence>
    <xs:element name="un" type="..."/>
    <xs:element name="deux" type="..."/>
    <xs:element name="trois" type="..."/>
  </xs:sequence>
</xs:complexType>

Plutôt qu'une séquence, on peut spécifier un ensemble (pour lequel l'ordre est indifférent) par l'annotation @XmlType(propOrder={}). Pour renommer un élément, utiliser l'annotation @XmlElement(name="nouveauNom"). Enfin, on peut traduire une propriété en un attribut plutôt qu'un élément (à condition que son type soit simple) : il suffit de l'annoter par @XmlAttribute(required=true).

Il existe depuis peu une norme (JSON Processing) fournissant deux méthodes de traitement, par flux d'événements (style SAX) et par un modèle universel (style DOM). En revanche, il n'existe pas encore de norme pour un data binding. Elle est en cours d'élaboration et bénéficiera des frameworks existants, comme Jettison ou Jackson.

Bibliographie : cf. chap. 12, Beginning Java EE 7, d'Antonio Goncalves.