Wiki Pédagogique Bruno Mascret

Outils pour utilisateurs

Outils du site

Piste :
java:xml

Différences

Ci-dessous, les différences entre deux révisions de la page.

Lien vers cette vue comparative

Prochaine révision		Révision précédente
java:xml [2014/02/17 20:54] – créée brunojava:xml [2014/02/18 13:39] (Version actuelle) – [XML en deux mots...] bruno
Ligne 1: Ligne 1:
-====== introduction à XML et XSL en java ======+====== Introduction à XML et XSL en java ======
  
 Ce TP est une **introduction** à XML et XSL. Ce TP est une **introduction** à XML et XSL.
Ligne 6: Ligne 6:
  
 Si vous souhaitez en apprendre plus, la dernière section "Pour approfondir ce qui vient d'être présenté" vous propose une liste de liens vers d'autres tutoriels plus complets. Si vous souhaitez en apprendre plus, la dernière section "Pour approfondir ce qui vient d'être présenté" vous propose une liste de liens vers d'autres tutoriels plus complets.
 +{{:java:tpxml.tar.gz|archive des fichiers utilisés}}
  
 +===== XML en deux mots... =====
 +XML est un format de représentation de données. C'est à dire qu'il offre une manière particulière de stocker des données.
 +
 +XML utilise des représentations sous forme d'arbre: un arbre est composé d'une racine (le tronc), de branches et de feuilles.
 +
 +Ce qu'XML représente, ce sont des noeuds: le premier noeud d'un document est la racine du document, les autres noeuds sont des branches ou des feuilles.
 +
 +Regardez le document document1.xml de l'archive:
 +  - **quel est le noeud racine?**
 +  - **donnez quelques noeuds de type feuille**
 +  - **donnez quelques noeuds contenant d'autres feuilles**.
 +
 +Un noeud peut également contenir des propriétés (attribute) qui sont spécifiés lors de la déclaration sous forme de pair-valeur:
 +
 +<code xml>
 +<NomDuNoeud attribut1="valeur1" attribut2="valeur2">
 +contenu du noeud
 +<!-- un commentaire -->
 +  <UnAutreNoeud/>
 +</NomDuNoeud>
 +</code>
 +
 +Un format XML peut être décrit dans une DTD ou un schema XML: ces documents expliquent comment un document doit être organisé.
 +
 +Regardez par exemple la DTD et le schema proposé dans l'archive: **que décrivent-ils**?
 +
 +**Quel format XML connaissez-vous déjà** ?
 +
 +**Inventez un petit format XML** ?
 +
 +
 +===== XML et les API java =====
 +Java offre plusieurs API permettant de manipuler des fichiers XML.
 +
 +Nous vous en présentons deux par l'exemple, qui sont chacune représentatives des deux grandes techniques de parcours d'arbre XML: le parcours événementiel et le parcours global.
 +==== SAX ====
 +L'API SAX de java permet d'accéder aux document XML de manière événementielle.
 +
 +Prenez en main le code suivant:
 +
 +<code java>
 +package sax;
 +import org.xml.sax.Attributes;
 +import org.xml.sax.Locator;
 +import org.xml.sax.helpers.DefaultHandler;
 +
 +/**
 + * Handler trivial pour SAX
 + * Ce handler se contente d'afficher les balises ouvrantes et fermantes.
 + * @author O. Carton
 + * @version 1.0
 + */
 +public class TrivialSAXHandler extends DefaultHandler {
 +   public void setDocumentLocator(Locator locator) {
 +       System.out.println("Location : " + 
 +   "publicId=" + locator.getPublicId() + 
 +   " systemId=" + locator.getSystemId());
 +   }
 +   public void startDocument() {
 +       System.out.println("Debut du document");
 +   }
 +   public void endDocument() {
 +       System.out.println("Fin du document");
 +   }
 +   public void startElement(String namespace, 
 +     String localname,
 +     String qualname,
 +     Attributes  atts) {
 +       System.out.println("Balise ouvrante : " + 
 +   "namespace=" + namespace + 
 +   " localname=" + localname + 
 +   " qualname=" + qualname);
 +   }
 +   public void endElement(String  namespace, 
 +   String localname,
 +   String qualname) {
 +       System.out.println("Balise fermante : " + 
 +   "namespace=" + namespace + 
 +   " localname=" + localname + 
 +   " qualname=" + qualname);
 +   }
 +   public void characters(char[] ch, int start, int length) {
 +       System.out.print("Caractères : ");
 +       for(int i = start; i < start+length; i++)
 +    System.out.print(ch[i]);
 +       System.out.println();
 +   }
 +}
 +
 +</code>
 +
 +et la classe principale:
 +
 +<code java>
 +package sax;
 +// IO
 +import java.io.InputStream;
 +import java.io.FileInputStream;
 +// SAX
 +import javax.xml.parsers.SAXParserFactory;
 +import javax.xml.parsers.SAXParser;
 +
 +/**
 + * Lecture triviale d'un document XML avec SAX
 + * @author O. Carton
 + * @version 1.0
 + */
 +public class TrivialSAXRead {
 +   public static void main(String [] args)
 +       throws Exception
 +   {
 +       // Création de la fabrique de parsers
 +       SAXParserFactory parserFactory = SAXParserFactory.newInstance();
 +       // Création du parser
 +       SAXParser parser = parserFactory.newSAXParser();
 +
 +       // Lecture de chaque fichier passé en paramètre
 +       for(int i = 0; i < args.length; i++) {
 +    // Flux d'entrée
 +    InputStream is = new FileInputStream(args[i]);
 +    parser.parse(is, new TrivialSAXHandler());
 +       }
 +   }
 +}
 +</code>
 +
 +  - lisez et comprenez le code
 +  - qu'est-ce qu'un parser?
 +  - qu'est-ce qu'une fabrique?
 +  - que fait ce code?
 +  - testez ce code avec le fichier document1.xml: que se passe-t-il et quand?
 +  - testez ce code avec document2.xml: que se passe-t-il?
 +  - modifiez le code pour compter le nombre de mots et le nombre de phrases d'un document xml.
 +  - est-il possible de modifier ce code pour poursuivre le traitement du document1? Pourquoi? Comment?
 +==== DOM ====
 +L'API DOM de java permet de charger complètement et d'un seul coup un document XML en mémoire
 +
 +Prenez en main le code suivant:
 +
 +<code java>
 +package dom;
 +
 +//IO
 +import java.io.InputStream;
 +import java.io.FileInputStream;
 +//DOM
 +import javax.xml.parsers.DocumentBuilderFactory;
 +import javax.xml.parsers.DocumentBuilder;
 +import org.w3c.dom.Document;
 +
 +/**
 +* Lecture triviale d'un document XML avec DOM
 +* @author O. Carton
 +* @version 1.0
 +*/
 +public class TrivialDOMRead {
 + public static void main(String [] args)
 +     throws Exception
 + {
 +     // Création de la fabrique de constructeur de documents
 +     DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
 +     // Création du constructeur de documents
 +     DocumentBuilder documentBuilder = dbf.newDocumentBuilder();
 +
 +     // Lecture de chaque fichier passé en paramètre
 +     for(int i = 0; i < args.length; i++) {
 +    // Flux d'entrée
 +    InputStream is = new FileInputStream(args[i]);
 +    // Construction du document
 +    Document doc = documentBuilder.parse(is);
 +    // Exploitation du document ...
 +    System.out.println(doc);
 +     }
 + }
 +}
 +
 +</code>
 +
 +  - lisez et comprenez le code
 +  - que fait ce code?
 +  - testez ce code avec le fichier document1.xml: que se passe-t-il et quand?
 +  - testez ce code avec document2.xml: que se passe-t-il?
 +  - modifiez le code pour compter le nombre de mots et le nombre de phrases d'un document xml.
 +  - est-il possible de modifier ce code pour poursuivre le traitement du document1? Pourquoi? Comment?
 +  - quels différences y a-t-il avec l'API SAX?
 +
 +==== Modification et écriture ====
 +SAX et DOM offrent de nombreuses méthodes pour créer des document XML, les exploiter, les modifier, les sauvegarder, etc.
 +
 +Reagrdez le code suivant:
 +
 +<code java>
 +try
 +{
 +// Création d'un nouveau DOM
 +DocumentBuilderFactory fabrique =DocumentBuilderFactory.newInstance();
 +DocumentBuilder constructeur = fabrique.newDocumentBuilder();
 +Document document = constructeur.newDocument();
 +// Propriétés du DOM
 +document.setXmlVersion("1.0");
 +document.setXmlStandalone(true);
 +//Création de l'arborescence du DOM
 +/racine
 +Element racine = document.createElement("nomRacine");
 +racine.setAttribute("version", "v1.4");
 +Element fils = document.createElement("nomFils");
 +// ajout du fils à la racine
 +racine.appendChild(obs);
 +//ajout de la racine au document
 +document.appendChild(racine);
 +/* Sauvegarde du fichier xml */
 +Source source = new DOMSource(document);
 +// Création du fichier de sortie
 +File f = new File("fichier.xml");
 +Result resultat = new StreamResult(f);
 +// Configuration du transformer
 +TransformerFactory tfabrique = TransformerFactory.newInstance();
 +Transformer transformer = tfabrique.newTransformer();
 +transformer.setOutputProperty(OutputKeys.INDENT, "yes");
 +transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
 +// Transformation
 +transformer.transform(source, resultat);
 +}
 +catch (ParserConfigurationException pce) {pce.printStackTrace();}
 +catch (TransformerConfigurationException tce) {tce.printStackTrace();}
 +catch (TransformerException te) {te.printStackTrace();}
 +
 +</code>
 +  - regardez la spécification des API
 +  - créez un document XML au format que vous avez défini en première partie avec sax puis avec dom
 +  - essayer de modifier ce document: quelle API vous semble la plus efficace?
 +
 +===== XSL en deux mots... =====
 +XSL est un langage XML de transformation de document XML.
 +
 +XSL utilise une approche événementielle pour le traitement des document XML.
 +
 +Regardez le fichier transfo1.xsl. Que fait ce fichier? Comment utiliser ce fichier sur un document XML?
 +
 +
 +===== XSL et java =====
 +
 +Java permet l'appel de feuille xsl de transformation dans ses différentes API.
 +
 +Regardez le code suivant:
 +
 +<code java>
 +DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 +//configuration de la fabrique
 +factory.setNamespaceAware(true);
 +factory.setValidating(true);
 +factory.setIgnoringElementContentWhitespace(true);
 +factory.setIgnoringComments(true);
 +factory.setIgnoringElementContentWhitespace(false);
 +try
 +{
 +//sinon, génère parfois des null pointer exp au parsage (problème avecsimples quote)
 +factory.setFeature("http://apache.org/xml/features/dom/defer-node-expansion",
 +false);
 +DocumentBuilder builder = factory.newDocumentBuilder();
 +Document doc = builder.parse(new File(entree));
 +doc.setStrictErrorChecking(true);
 +TransformerFactory transformFactory = new TransformerFactoryImpl();
 +StreamSource styleSource = new StreamSource(new File(ADRESSE_XSL));
 +// lire le style
 +Transformer transform = transformFactory.newTransformer(styleSource);
 +//Si besoin : transform.setOutputProperty(name, value)
 +DOMSource in = new DOMSource(doc);
 +// Création du fichier de sortie
 +File file = new File(cible);
 +Result resultat = new StreamResult(fichier);
 +//Si besoin : transform.setParameter("nomDuParam",valeur);
 +transform.transform(in, out);
 +}
 +
 +</code>
 +
 +  - Quelle API de java est utilisée?
 +  - Où est déclarée la feuille de style (de transformation) XSL?
 +
 +Regardez la documentation de la fonction **count** de XSL.
 +
 +  - faites un programme permettant de compter le nombre de mots et le nombre de phrase d'un document XML. Le résultat sera stocké dans un fichier texte simple.
 +  - regardez la feuille de style document.xsl: que fait-elle? 
 +  - essayez de la modifier pour changer le rendu du document document2.xml
 +
 +**Quelle technique vous semble la plus facile à utiliser?**
 +
 +===== Pour approfondir ce qui vient d'être présenté =====
 +
 +  - FAQ sur XML et JAVA: [[http://java.developpez.com/faq/xml/?page=generalitesXML]]
 +  - sur XML et un peu java: [[http://www.liafa.univ-paris-diderot.fr/~carton/Enseignement/XML/Cours/]]
 +  - XML, XSL, un peu java: [[http://jean-luc.massat.perso.luminy.univ-amu.fr/ens/xml/index.html]]
 +  - le meilleur site sur les FAQ XSL de Dave Pawson:[[ http://dpawson.co.uk/xsl/index.html]]
 +  - tutoriel xsl:[[ http://zvon.org/comp/r/tut-XSLT_1.html]]
 +  - reférences XSL: [[http://zvon.org/xxl/XSLTreference/Output/index.html]]
java/xml.1392670452.txt.gz · Dernière modification : 2014/02/17 20:54 de bruno