Manipuler des données XML avec Java et JDOM

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

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 tant 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 tant 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");
   }
}

//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 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){}
}

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

<?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>

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();
   }
}

//Ajouter cette méthode à la classe JDOM2
static void afficheALL()
{
   //On crée une List contenant tous les nœuds "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 :
      //sélectionner un nœud fils, modifier du texte, etc.
      Element courant = (Element)i.next();
      //On affiche le nom de l'élément courant
      System.out.println(courant.getChild("nom").getText());
   }
}

//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éfinit les propriétés du filtre à l'aide
      //de la méthode matches
      public boolean matches(Object ob)
      {
         //1re 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;

         //2e vérification: on vérifie que le nom est bien "CynO"
         if(element.getChild("nom").getTextTrim().equals("CynO"))
         {
            verifNom = 1;
         }
         //3e 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 liste 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 liste
   Iterator i = resultat.iterator();
   while(i.hasNext())
   {
      Element courant = (Element)i.next();
      System.out.println(courant.getAttributeValue("classe"));
   }
}

//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 parcourt la liste grâce à un iterator
      while(i.hasNext())
      {
         Element courant = (Element)i.next();
         //Si l’étudiant 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
            //"étudiant modifié" devient "etudiant_modifie"
            courant.setName("etudiant_modifie");
         }
      }
   }

   //On enregistre 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));
   }
}

<?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>

//Pour être compilée cette fonction a 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ée cette fonction a 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;
}

//Pour être compilée cette fonction a 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éthode transform() prend en argument le document d’entrée 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 correspondant au résultat
      XMLOutputter outputter = new XMLOutputter(Format.getPrettyFormat());
      outputter.output(resultat, new FileOutputStream("resultat.xml"));
   }
   catch(Exception e){}
}