FAQ Java XMLConsultez toutes les FAQ

Nombre d'auteurs : 5, nombre de questions : 59, dernière mise à jour : 3 septembre 2014  Ajouter une question

 

Cette FAQ a été réalisée à partir des questions fréquemment posées sur les forums de http://www.developpez.com et de l'expérience personnelle des auteurs.

Nous tenons à souligner que cette FAQ ne garantit en aucun cas que les informations qu'elle propose sont correctes. Les auteurs font leur maximum, mais l'erreur est humaine. Cette FAQ ne prétend pas non plus être complète. Si vous trouvez une erreur, ou que vous souhaitez nous aider en devenant rédacteur, lisez ceci.


SommaireGénéralités (12)
précédent sommaire suivant
 

Tout d'abord, rappellons ce qu'est XML. XML (pour eXtensible Markup Language) est un langage de balisage (comme le HTML, par exemple), utilisé pour la représentation et structuration de données. Voici quelques caractéristiques de ce standard :

  • Extensible : au contraire du HTML, qui contient un jeu limité de balises, le XML permet la création de ses propres balises.
  • Méta-langage : grâce à son exstensibilité, le XML est un standard tout à fait approprié pour la création d'autres langages (XHTML, par exemple).
  • Portable : le XML n'est rien d'autre que du texte entre des balises.

Les questions de cette partie de la FAQ portent uniquement sur la manipulation de XML avec la technologie Java. Pour des informations plus spécifiques sur le standard XML, en lui-même, regardez : Où trouver plus d'informations sur le format XML ?

L'API Java standard pour la manipulation du format XML est JAXP (Java API for XML Processing). Cette API permet la lecture, la transformation et l'écriture de fichiers ou flux XML. C'est cette API que nous allons étudier dans la partie XML de cette FAQ.

JAXP n'est pas la seule API disponible pour travailler avec XML. Pour plus d'informations sur les autres API disponibles regardez : Quelles autres API existent pour travailler avec XML ?

Mis à jour le 4 décembre 2004 Ioan

JAXP (Java API for XML Processing) est composée de quatre packages. Cette API met à la disposition du développeur trois ensembles de fonctionnalités (la modélisation, le parsing et la transformation) regroupées en quatre packages distincts.

  • javax.xml.parsers : ce package contient un ensemble d'interfaces devant être implémentées par les différents parseurs (SAX ou DOM). Ce package fournit aussi un ensemble de factory permettant l'accès aux parseurs.
  • org.w3c.dom : ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec DOM (modélisation).
  • org.xml.sax : ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec SAX (parsing).
  • javax.xml.transform : ce package contient l'ensemble des classes et interfaces nécessaires pour travailler avec XSLT (transformation).

Pour savoir ce que sont SAX, DOM, XSLT et savoir quand et comment les utiliser, regardez : Que sont les API SAX, DOM et XSLT ?

Mis à jour le 4 décembre 2004 Ioan

Les API SAX, DOM et XSLT sont les trois composantes de l'API JAXP. Voici leurs fonctionnalités et principes :

  • SAX :
    Simple API for XML travaille les documents XML de manière événementielle.
    C'est-à-dire que le parseur va lire (parcourir) le fichier ou flux XML et lever tout un ensemble d'événements lors de la rencontre avec un élément. Les éléments pouvant être des balises (ouvrantes ou fermantes), des portions de texte, des commentaires ou encore des instructions.
    Cette API est particulièrement mise en avant pour sa rapidité de traitement. Par contre, son fonctionnement est peut-être un peu plus complexe à appréhender que celui de DOM.
    Pour bien comprendre la structure et le fonctionnement de cette API, regardez : Comment fonctionne l'API SAX ?
  • DOM :
    Document Object Model, à la différence de SAX, ne va pas seulement parcourir le document XML, mais va, en plus, en fabriquer une représentation en mémoire.
    Cette représentation est un arbre, que vous pourrez facilement parcourir (cf. org.w3c.dom.Document). Cet arbre représente l'organisation et le contenu du document XML. En contrepartie de sa facilité d'utilisation, DOM est plus gourmand en ressources et en temps.
    Pour débuter avec DOM, regardez : Comment ouvrir un fichier XML avec DOM ?
  • XSLT :
    eXtensible Stylesheet Language for Transformations, permet la transformation des documents XML.
    Les « transformations » consistent soit en une modification d'un XML avec sauvegarde des modifications, soit en une transformation en un autre type de document (HTML et PDF, par exemple).
    Quelle que soit votre manière de lire votre document XML (SAX ou DOM), vous serez amené à utiliser XSLT pour sa modification.

Mis à jour le 4 décembre 2004 Ioan

SAX, DOM et XSLT sont les principales fonctionnalités offertes par JAXP. Mais ce ne sont pas les seules. Voici une liste plus détaillée des spécifications supportées par JAXP 1.3 :


Pour des détails sur les autres versions de JAXP, vous pouvez regarder les liens ci-dessous.

Mis à jour le 1er février 2005 Ioan

Voici les différentes versions des spécifications XML supportées par JAXP RI (Reference Implementation) 1.2 et 1.3.

Versions XML SAX DOM XSLT XPath
JAXP RI 1.3 (présent dans le JDK 1.5) 1.1/1.0 SAX 2.0.2 DOM 3.0 XSLT 1.0 XPath 1.0
JAXP RI 1.2 (présent dans le JDK 1.4) 1.0 SAX 2.0.0 DOM 2.0 XSLT 1.0 -/-

Pour les anciennes versions de JAXP, vous pouvez trouver de plus amples informations à partir du site de Oracle : https://docs.oracle.com/javase/tutorial/jaxp/

Pour connaître les versions des parseurs et processeurs utilisés par JAXP RI, regardez : Quels sont les parseurs XML et processeurs XSLT utilisés par JAXP RI ?

Mis à jour le 1er février 2005 Ioan

Si vous n'avez pas le dernier JDK et que vous désirez profiter de toutes les fonctionnalités de JAXP, vous pouvez télécharger l'API séparément sur Java.NET. JAXP Reference Implementation Project : https://jaxp.dev.java.net/

N'oubliez pas que vous pouvez aussi télécharger d'autres API pour travailler avec XML. Certaines sont plus faciles, performantes ou complètes que JAXP.

Mis à jour le 1er février 2005 Ioan

Voici les différents parseurs XML et processeurs XSLT utilisés par JAXP RI (Reference Implementation) versions 1.3, 1.2 et 1.1.

Outils/versions Parseur XML Processeur XSLT
JAXP RI 1.3 Xerces 2.6.2 XSLTC (basé sur Xalan 2.6.0)
JAXP RI 1.2 Xerces 2.3.0 XSLTC (basé sur Xalan 2.4.1)
JAXP RI 1.1 Crimson XSLTC

Vous pouvez changer ces outils, s'ils ne vous conviennent pas. Pour cela, vous pouvez regarder les liens ci-dessous.

Mis à jour le 1er février 2005 Ioan

Pour changer le parseur XML utilisé vous devez spécifier la variable d'environnement javax.xml.parsers.XXX, ou XXX détermine l'implémentation qui vous intéresse. Voici quelques exemples :

Code Java : Sélectionner tout
1
2
System.setProperty("javax.xml.parsers.DocumentBuilderFactory", "net.sf.saxon.om.DocumentBuilderFactoryImpl"); 
DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();
Ou alors :
Code Java : Sélectionner tout
System.setProperty("javax.xml.parsers.SAXParserFactory", "org.apache.crimson.jaxp.SAXParserFactoryImpl");
Vous pouvez aussi faire ces modifications en ligne de commande. Par exemple :
Code Java : Sélectionner tout
java -Djavax.xml.parsers.XXXFactory=nom.complet.de.l.implementation ...
Pour le processeur XSLT la démarche est la même, il suffit d'indiquer au système quelle implémentation du processeur XSLT il doit utiliser.

Naturellement, vous pouvez utiliser directement les implémentations (sans passer par les factory), mais cela vous fait perdre la « portabilité » de votre code. En effet, en cas de changement de parseur ou processeur, vous devrez changer de nombreuses parties de votre code. Le plus simple reste de spécifier l'implémentation à utiliser grâce aux propriétés système.

Mis à jour le 1er février 2005 Ioan

Cette solution utilise la spécification JAXP 1.2.

La DTD sera décrite ainsi dans le document XML :

Code xml : Sélectionner tout
<!DOCTYPE document SYSTEM "file:MaDtd.dtd" >
Ainsi, lors des tests, il sera aussi possible de placer le fichier MaDtd.dtd dans le répertoire ou l'application sera lancée.

Pour SAX :

Dans le DefaultHandler redéfinir la méthode resolveEntity comme suit :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
public InputSource resolveEntity(String publicId, String systemId) throws SAXException  
{  
	try  
	{  
		if (!systemId.startsWith("file:"))  
		{  
			return null;  
		}  
		String pathDtd = systemId.substring(5);  
  
		if (!pathDtd.startsWith("/"))  
		{  
			pathDtd = "/" + pathDtd;  
		}  
  
		InputStream is = getClass().getResourceAsStream(pathDtd);  
		if (null == is)  
		{  
			return null;  
		}  
  
		return new InputSource(is);  
	}  
	catch (Exception e)  
	{  
		return null;  
	}  
}
Lorsque cette méthode retourne null, le parser XML utilise sa méthode de recherche par défaut pour trouver la DTD. Ce qui fait que ce code n'empêche pas de trouver une DTD située ailleurs du moment que l'URL est correcte.

Pour dire au parser SAX d'utiliser cette methode resolveEntity :
Code Java : Sélectionner tout
1
2
SAXParser parser =...  
parser.getXMLReader().setEntityResolver(monHandler);
Pour DOM :

Pour DOM il faut qu'une classe implémente l'interface EntityResolver.

Le code de la méthode resolveEntity est exactement le même que pour SAX.

Pour spécifier au parser DOM, quelle méthode utiliser :
Code Java : Sélectionner tout
1
2
DocumentBuilder builder = ...  
builder.setEntityResolver(new MonEntityResolver());

Mis à jour le 19 juillet 2004 bulbo

Un fichier XSD est un fichier définissant la structure et le type de contenu d'un document XML. Il permet ainsi de vérifier la validité d'un fichier XML.

Il est possible de réaliser cette validation XSD en Java par l'intermédiaire du code ci-dessous :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
String language = XMLConstants.W3C_XML_SCHEMA_NS_URI; 
SchemaFactory factory = SchemaFactory.newInstance(language); 
  
factory.setErrorHandler(new MyErrorHandler());  
factory.setResourceResolver( new MyResourceResolver()); 
  
// Chargement du fichier XSD de validation 
StreamSource ss = new StreamSource(new File("schema.xsd"));  
Schema schema; 
try { 
    // Chargement du schéma     
    schema = factory.newSchema(ss);  
    Validator validator = schema.newValidator(); 
    validator.setErrorHandler( new MyErrorHandler()); 
  
    // Vérification du document 
    validator.validate(new StreamSource("document.xml")); 
} catch (SAXException e) {  
    e.printStackTrace(); 
} catch (IOException e) {  
    e.printStackTrace(); 
}

Mis à jour le 1er septembre 2014 Robin56

Si vous désirez plus d'informations sur le standard XML et ses applications, je vous invite à parcourir ces liens :

Mis à jour le 4 décembre 2004 Ioan

JAXP n'est pas la seule API Java dédiée à XML. On peut même dire qu'il y en a beaucoup. Certaines sont très spécialisées (sur la technologie J2EE par exemple), d'autres sont plus généralistes et reprennent/consolident/améliorent les composantes de JAXP. Je vous laisse les découvrir par vous-même :

  • JDOM : JDOM se veut une API légère, rapide et facile d'utilisation, pour travailler avec des documents XML. Son fonctionnement est « comparable » à DOM. Compatible avec SAX, DOM et JAXP ;
  • DOM4J : API Open Source qui permet le travail avec XML, XPath et XSLT. Compatible avec SAX, DOM et JAXP ;
  • StAX : Streaming API for XML ;
  • JAXB : Java Architecture for XML Binding ;
  • JAXR : Java API for XML Registries ;
  • JAX-RPC : Java API for XML-based RPC ;
  • SAAJ : SOAP with Attachments API for Java.

Pour l'utilisation des quatre dernières API, vous pouvez regarder le J2EE 1.4 Tutorial de Sun.

Mis à jour le 4 décembre 2004 Ioan

Proposer une nouvelle réponse sur la FAQ

Ce n'est pas l'endroit pour poser des questions, allez plutôt sur le forum de la rubrique pour ça


Réponse à la question

Liens sous la question
précédent sommaire suivant
 

Les sources présentées sur cette page sont libres de droits et vous pouvez les utiliser à votre convenance. Par contre, la page de présentation constitue une œuvre intellectuelle protégée par les droits d'auteur. Copyright © 2017 Developpez Developpez LLC. Tous droits réservés Developpez LLC. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez LLC. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

 
Responsables bénévoles de la rubrique Java : Mickael Baron - Robin56 -