FAQ Java XMLConsultez toutes les FAQ

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.
  

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).
  

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.
  

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 :

• SAX 2.0.2 : http://www.saxproject.org/
• XML 1.1 : http://www.w3.org/TR/xml11/
• XML 1.0 : http://www.w3.org/TR/REC-xml
• XInclude : http://www.w3.org/TR/xinclude/
• DOM Level 3 Core : http://www.w3.org/TR/2004/REC-DOM-Level-3-Core-20040407
• DOM Level 3 Load and Save : http://www.w3.org/TR/2004/REC-DOM-Level-3-LS-20040407
• W3C XML Schema : http://www.w3.org/TR/xmlschema-1/
• XSLT 1.0 : http://www.w3.org/TR/1999/REC-xslt-19991116
• XPath 1.0 : http://www.w3.org/TR/xpath
  

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

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.

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

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 :

1
2
System.setProperty("javax.xml.parsers.DocumentBuilderFactory", "net.sf.saxon.om.DocumentBuilderFactoryImpl"); 
DocumentBuilderFactory dfactory = DocumentBuilderFactory.newInstance();

System.setProperty("javax.xml.parsers.SAXParserFactory", "org.apache.crimson.jaxp.SAXParserFactoryImpl");

java -Djavax.xml.parsers.XXXFactory=nom.complet.de.l.implementation ...

Cette solution utilise la spécification JAXP 1.2.

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

<!DOCTYPE document SYSTEM "file:MaDtd.dtd" >

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

1
2
SAXParser parser =...  
parser.getXMLReader().setEntityResolver(monHandler);

1
2
DocumentBuilder builder = ...  
builder.setEntityResolver(new MonEntityResolver());

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 :

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

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

• Cours et tutoriels XML
• Forum d'entraide XML
• Les meilleurs livres sur XML
• Site officiel du W3C
  

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.