Manipuler des données XML avec Java et JDOM

Par Nicolas CYNOBER
 

Vous apprendrez dans cet article à manipuler des donnés XML avec le langage Java et l'API JDOM.
Nous étudierons les possibilités de cette api grâce à des exemples simples.
Nous apprendrons ainsi à créer un simple fichier XML, à parcourir son arborescence et à modifier son contenu.
Version HTML/ZIP
Version PDF

Introduction

Sun Microsystems (Comment on the JSR-102 Approval Ballot) In general we tend to prefer to avoid adding new APIs to the Java platform which replicate the functionality of existing APIs. However JDOM does appear to be significantly easier to use than the earlier APIs, so we believe it will be a useful addition to the platform.

1. Les origines de JDOM

1.1. Description de SAX

1.2. Description de DOM

1.3. Pourquoi JDOM ?

2. Crée un fichier XML avec JDOM

2.1. Téléchargement et installation l'API JDOM

2.2. Créer une arborescence simple

Fichier XML
<personnes>
   <etudiant classe="P2">
      <nom>CynO</nom>
   <etudiant>
<personnes>

JDOM1.java
import java.io.*;
import org.jdom.*;
import org.jdom.output.*;

public class JDOM1
{
   //Nous allons commencer notre arborescence en créant la racine XML
   //qui sera ici "personnes".
   static Element racine = new Element("personnes");

   //On crée un nouveau Document JDOM basé sur la racine que l'on vient de créer
   static org.jdom.Document document = new Document(racine);

   public static void main(String[] args)
   {
      //On crée un nouvel Element etudiant et on l'ajoute
      //en temps qu'Element de racine
      Element etudiant = new Element("etudiant");
      racine.addContent(etudiant);

      //On crée un nouvel Attribut classe et on l'ajoute à etudiant
     //grâce à la méthode setAttribute
      Attribute classe = new Attribute("classe","P2");
      etudiant.setAttribute(classe);

      //On crée un nouvel Element nom, on lui assigne du texte
      //et on l'ajoute en temps qu'Element de etudiant
      Element nom = new Element("nom");
      nom.setText("CynO");
      etudiant.addContent(nom);

      //Les deux méthodes qui suivent seront définies plus loin dans l'article
      affiche();
      enregistre("Exercice1.xml");
   }
}

2.3. Afficher et enregistrer son fichier XML

JDOM1.java
//Ajouter ces deux méthodes à notre classe JDOM1
static void affiche()
{
   try
   {
      //On utilise ici un affichage classique avec getPrettyFormat()
      XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
      sortie.output(document, System.out);
   }
   catch (java.io.IOException e){}
}

static void enregistre(String fichier)
{
   try
   {
      //On utilise ici un affichage classique avec getPrettyFormat()
      XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
      //Remarquez qu'il suffit simplement de créer une instance de FileOutputStream
      //avec en argument le nom du fichier pour effectuer la sérialisation.
      sortie.output(document, new FileOutputStream(fichier));
   }
   catch (java.io.IOException e){}
}

Exercice1.xml
<?xml version="1.0" encoding="UTF-8"?>
<personnes>
   <etudiant classe="P2">
      <nom>CynO</nom>
   </etudiant>
</personnes>

3. Parcourir un fichier XML

3.1. Parser un fichier XML

Exercice2.xml
<?xml version="1.0" encoding="UTF-8"?>
<personnes>
   <etudiant classe="P2">
      <nom>CynO</nom>
      <prenoms>
         <prenom>Nicolas</prenom>
         <prenom>Laurent</prenom>
      </prenoms>
   </etudiant>
   <etudiant classe="P1">
      <nom>Superwoman</nom>
   </etudiant>
   <etudiant classe="P1">
      <nom>Don Corleone</nom>
   </etudiant>
</personnes>

JDOM2.java
import java.io.*;
import org.jdom.*;
import org.jdom.input.*;
import org.jdom.filter.*;
import java.util.List;
import java.util.Iterator;

public class JDOM2
{
   static org.jdom.Document document;
   static Element racine;

   public static void main(String[] args)
   {
      //On crée une instance de SAXBuilder
      SAXBuilder sxb = new SAXBuilder();
      try
      {
         //On crée un nouveau document JDOM avec en argument le fichier XML
         //Le parsing est terminé ;)
         document = sxb.build(new File("Exercice2.xml"));
      }
      catch(Exception e){}

      //On initialise un nouvel élément racine avec l'élément racine du document.
      racine = document.getRootElement();

      //Méthode définie dans la partie 3.2. de cet article
      afficheALL();
   }
}

3.2. Parcourir une arborescence

JDOM2.java
//Ajouter cette méthodes à la classe JDOM2
static void afficheALL()
{
   //On crée une List contenant tous les noeuds "etudiant" de l'Element racine
   List listEtudiants = racine.getChildren("etudiant");

   //On crée un Iterator sur notre liste
   Iterator i = listEtudiants.iterator();
   while(i.hasNext())
   {
      //On recrée l'Element courant à chaque tour de boucle afin de
      //pouvoir utiliser les méthodes propres aux Element comme :
      //selectionner un noeud fils, modifier du texte, etc...
      Element courant = (Element)i.next();
      //On affiche le nom de l'element courant
      System.out.println(courant.getChild("nom").getText());
   }
}

3.3. Filtrer les éléments

• Un sous élément nom qui doit avoir pour valeur "CynO".
• Un sous élément prenoms qui doit posséder au moins un sous élément prenom dont la valeur est "Laurent".

JDOM2.java
//Ajouter cette méthode à la classe JDOM2
//Remplacer la ligne afficheALL(); par afficheFiltre();
static void afficheFiltre()
{
   //On crée un nouveau filtre
   Filter filtre = new Filter()
   {
      //On défini les propriétés du filtre à l'aide
      //de la méthode matches
      public boolean matches(Object ob)
      {
         //1 ère vérification : on vérifie que les objets
         //qui seront filtrés sont bien des Elements
         if(!(ob instanceof Element)){return false;}

         //On crée alors un Element sur lequel on va faire les
         //vérifications suivantes.
         Element element = (Element)ob;

         //On crée deux variables qui vont nous permettre de vérifier
         //les conditions de nom et de prenom
         int verifNom = 0;
         int verifPrenom = 0;

         //2 ème vérification: on vérifie que le nom est bien "CynO"
         if(element.getChild("nom").getTextTrim().equals("CynO"))
         {
            verifNom = 1;
         }
         //3 ème vérification: on vérifie que CynO possède un prenom "Laurent"
         //On commence par vérifier que la personne possède un prenom,
         //en effet notre fichier XML possède des étudiants sans prénom !
         Element prenoms = element.getChild("prenoms");
         if(prenoms == null){return false;}

         //On constitue une list avec tous les prenom
         List listprenom = prenoms.getChildren("prenom");

         //On effectue la vérification en parcourant notre liste de prenom
         //(voir: 3.1. Parcourir une arborescence)
         Iterator i = listprenom.iterator();
         while(i.hasNext())
         {
            Element courant = (Element)i.next();
            if(courant.getText().equals("Laurent"))
            {
               verifPrenom = 1;
            }
         }

         //Si nos conditions sont remplies on retourne true, false sinon
         if(verifNom == 1 && verifPrenom == 1)
         {
            return true;
         }
         return false;
      }
   };//Fin du filtre

   //getContent va utiliser notre filtre pour créer une liste d'étudiants répondant
   //à nos critères.
   List resultat = racine.getContent(filtre);
   //On affiche enfin l'attribut classe de tous les éléments de notre list
   Iterator i = resultat.iterator();
   while(i.hasNext())
   {
      Element courant = (Element)i.next();
      System.out.println(courant.getAttributeValue("classe"));
   }
}

4. Modifier une arborescence JDOM

4.1. Modifier des Elements

JDOM3.java
//Créer une nouvelle class JDOM3
import java.io.*;
import org.jdom.*;
import org.jdom.input.*;
import org.jdom.output.*;
import java.util.List;
import java.util.Iterator;

public class JDom
{
   static org.jdom.Document document;
   static Element racine;

   public static void main(String[] args)
   {
       try
       {
          lireFichier("Exercice 2.xml");
          supprElement("prenoms");
          enregistreFichier("Exercice 2.xml");
        }
        catch(Exception e){}
   }

   //On parse le fichier et on initialise la racine de
   //notre arborescence
   static void lireFichier(String fichier) throws Exception
   {
      SAXBuilder sxb = new SAXBuilder();
      document = sxb.build(new File(fichier));
      racine = document.getRootElement();
   }

   //On fait des modifications sur un Element
   static void supprElement(String element)
   {
      //Dans un premier temps on liste tous les étudiants
      List listEtudiant = racine.getChildren("etudiant");
      Iterator i = listEtudiant.iterator();
      //On parcours la liste grâce à un iterator
      while(i.hasNext())
      {
         Element courant = (Element)i.next();
         //Si l'etudiant possède l'Element en question on applique
         //les modifications.
         if(courant.getChild(element)!=null)
         {
            //On supprime l'Element en question
            courant.removeChild(element);
            //On renomme l'Element père sachant qu'une balise XML n'accepte
            //ni les espaces ni les caractères spéciaux
            //"etudiant modifié" devient "etudiant_modifie"
            courant.setName("etudiant_modifie");
         }
      }
   }

   //On enregsitre notre nouvelle arborescence dans le fichier
   //d'origine dans un format classique.
   static void enregistreFichier(String fichier) throws Exception
   {
         XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
         sortie.output(document, new FileOutputStream(fichier));
   }
}

Exemple2.xml
<?xml version="1.0" encoding="UTF-8"?>
<personnes>
   <etudiant_modifie classe="P2">
      <nom>CynO</nom>
   </etudiant_modifie>
   <etudiant classe="P1">
      <nom>Superwoman</nom>
   </etudiant>
   <etudiant classe="P1">
      <nom>Don Corleone</nom>
   </etudiant>
</personnes>

4.2. Passer de DOM à JDOM et l'inverse

//Pour être compilé cette fonction à besoin de l'importation suivante
//qui contient la classe DOMBuilder
import org.jdom.input.*;

org.jdom.Document DOMtoJDOM(org.w3c.dom.Document documentDOM) throws Exception
{
   //On utilise la classe DOMBuilder pour cette transformation
   DOMBuilder builder = new DOMBuilder();
   org.jdom.Document documentJDOM = builder.build(documentDOM);
   return documentJDOM;
}

//Pour être compilé cette fonction à besoin de l'importation suivante
//qui contient la classe DOMOutputter
import org.jdom.output.*;

org.w3c.dom.Document DOMtoJDOM(org.jdom.Document documentJDOM) throws Exception
{
   //On utilise la classe DOMOutputter pour cette transformation
   DOMOutputter domOutputter = new DOMOutputter();
   org.w3c.dom.Document documentDOM = domOutputter.output(documentJDOM);
   return documentDOM;
}

4.3. JDOM et XSLT

//Pour être compilé cette fonction à besoin des importations suivantes
import java.io.*;
//JDOM
import org.jdom.transform.*;
import org.jdom.output.*;
//TrAX
import javax.xml.transform.*;
import javax.xml.transform.stream.StreamSource;

void outputXSLT(org.jdom.Document documentJDOMEntree,String fichierXSL)
{
   //Document JDOMResult, résultat de la transformation TraX
   JDOMResult documentJDOMSortie = new JDOMResult();
   //Document JDOM après transformation
   org.jdom.Document resultat = null;

   try
   {
      //On définit un transformer avec la source XSL
      //qui va permettre la transformation
      TransformerFactory factory = TransformerFactory.newInstance();
      Transformer transformer = factory.newTransformer(new StreamSource(fichierXSL));

      //On transforme le document JDOMEntree grâce à notre transformer.
      //La méthoded transform() prend en argument le document d'entree associé au transformer
      //et un document JDOMResult, résultat de la transformation TraX
      transformer.transform(new org.jdom.transform.JDOMSource(documentJDOMEntree), documentJDOMSortie);

      //Pour récupérer le document JDOM issu de cette transformation
      //il faut utiliser la méthode getDocument()
      resultat = documentJDOMSortie.getDocument();

      //On crée un fichier xml corespondant au résultat
      XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
      outputter.output(resultat, new FileOutputStream("resultat.xml"));
   }
   catch(Exception e){}
}

Conclusion

• http://www.jdom.org
• http://java.sun.com