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.


SommaireXSLT (9)
précédent sommaire suivant
 

Architecture d'une application utilisant XSLT :



L'application commence par récupérer un transformeur (javax.xml.transform.Transformer) à partir d'une fabrique de transformeurs (javax.xml.transform.TransformerFactory).

C'est ce transformeur qui va être chargé de transformer une source (javax.xml.transform.Source) en résultat (javax.xml.transform.Resultat). Par défaut, si aucune véritable transformation n'est demandée, le transformeur va simplement copier la source dans le résultat.

La source et le résultat peuvent être respectivement un parseur SAX, un DOM, une InputSource et un ensemble d'évènements SAX, un DOM ou une OutputSource.

Pour une configuration pratique du transformeur, regardez : Comment créer et configurer un Transformer (pour SAX et DOM) ?

Pour des exemples, regardez : Comment créer ou modifier un fichier XML avec DOM et XSLT ? et Comment créer ou modifier un fichier XML avec SAX et XSLT ?

Mis à jour le 5 décembre 2004 Ioan

Voici un exemple de création et de configuration d'un Transformer :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// création de la fabrique 
TransformerFactory fabrique = TransformerFactory.newInstance(); 
  
// récupération du transformeur 
Transformer transformer = fabrique.newTransformer(); 
  
/** 
* pour définir une feuille de style, vous pouvez utiliser une Source comme paramètre 
* File stylesheet = new File("stylesheet.xsl"); 
* StreamSource stylesource = new StreamSource(stylesheet); 
* Transformer transformer = fabrique.newTransformer(stylesource);  
*/ 
  
// configuration du transformeur 
transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");
Pour configurer votre fabrique, regardez par exemple : Comment gérer les erreurs durant la transformation ?

Pour connaître toutes les clefs disponibles pour le Transformer, regardez la classe javax.xml.transform.OutputKeys.

Mis à jour le 5 décembre 2004 Ioan

Les fabriques de transformeurs (javax.xml.transform.TransformerFactory) peuvent construire deux types d'objets : les Transformer et les Templates.

Une Template est un « conteneur » de Transformer. De plus, contrairement à un simple Transformer, la Template est thread-safe (elle peut être utilisée par plusieurs Threads sans risque).

La création et configuration d'une Template se font de la même manière que pour un Transformer. Par exemple :

Code java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
// création de la fabrique 
TransformerFactory fabrique = TransformerFactory.newInstance(); 
  
// récupération de Templates 
Templates template = fabrique.newTemplates(); 
  
/** 
* pour définir une feuille de style, vous pouvez utiliser une Source comme paramètre 
* File stylesheet = new File("stylesheet.xsl"); 
* StreamSource stylesource = new StreamSource(stylesheet); 
* Templates template = fabrique.newTemplates(stylesource);  
*/ 
  
// configuration du transformeur 
Transformer transformer = template.getTransformer(); 
transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");

Mis à jour le 12 décembre 2004 Ioan

La gestion des erreurs se fait de la même manière que pour SAX/DOM et les ErrorHandler. On peut gérer les erreurs durant la transformation avec un ErrorListener (javax.xml.transform). Par exemple :

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
import javax.xml.transform.*;  
public class EcouteurDErreurs implements ErrorListener{ 
	public void warning(TransformerException exception) 
			throws TransformerException{ 
		printException(exception);       
	} 
	public void error(TransformerException exception) 
			throws TransformerException{ 
		printException(exception);     
	} 
	public void fatalError(TransformerException exception) 
			throws TransformerException{ 
		printException(exception); 
		throw exception; 
	} 
	private void printException(TransformerException exception){ 
		String message = exception.getMessageAndLocation() ; 
		System.out.println(message); 
	} 
}
Utilisation :

Code java : Sélectionner tout
1
2
Transformer transformeur = ...;  
transformeur.setErrorListener(new EcouteurDErreurs());

Mis à jour le 12 décembre 2004 Ioan

Voici une méthode permettant de créer un fichier XML à partir d'un DOM :

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
public static void transformerXml(Document document, String fichier) { 
	try { 
		// Création de la source DOM 
		Source source = new DOMSource(document); 
  
		// Création du fichier de sortie 
		FileOutputStream out = new File(fichier); 
		Result resultat = new StreamResult(out); 
  
		// Configuration du transformer 
		TransformerFactory fabrique = TransformerFactory.newInstance(); 
		Transformer transformer = fabrique.newTransformer(); 
		transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
		transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1"); 
  
		// Transformation 
		transformer.transform(source, resultat); 
  
                resultat.getOutputStream().close(); 
	}catch(Exception e){ 
		e.printStackTrace(); 
	} 
}
Vous pouvez télécharger les sources d'un exemple complet ci-dessous.

Mis à jour le 4 décembre 2004 Ioan

Pour créer un fichier XML avec SAX et XSLT, il nous faut créer une SAXSource. Nous allons prendre l'exemple de l'écriture dans un fichier d'un « annuaire » composé d'une List de JavaBean Personne. Voici les étapes nécessaires à la création de la source :

  • Création du bean : Personne définit un élément de l'annuaire ;
  • Création d'une InputSource :AnnuaireSource définit la List des personnes de l'annuaire ;
  • Création d'un XMLReader : AnnuaireReader est capable de « parser » la source pour lever des évènements SAX ;
  • Création de la SAXSource, à partir de l'InputSource et du Reader.

Après cela la transformation se fera comme pour un arbre DOM et un fichier : avec un Transformer et un StreamResult (pour le fichier de destination).

Code Java : Sélectionner tout
1
2
3
/** 
* Voir zip 
*/
Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
public class AnnuaireSource extends InputSource{ 
	private List<Personne> personnes; 
	public AnnuaireSource(List<Personne> personnes){ 
		super(); 
		this.personnes = personnes; 
	} 
	public List<Personne> getPersonnes(){ 
		return personnes; 
	} 
	// En fait, contrairement à cet exemple, de nombreuses méthodes d'InputSource travaillent avec des streams. 
	// Cela peut vous simplifier le travail sur des fichiers XML existants. 
}
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
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
public class AnnuaireReader implements XMLReader{ 
	private ContentHandler handler; 
	private AttributesImpl atts = new AttributesImpl(); 
	//méthode qui vont être utilisées par le transformer 
	public ContentHandler getContentHandler(){ 
		return handler; 
	} 
	public void setContentHandler(ContentHandler handler){ 
		this.handler = handler; 
	} 
	// parsing d'une liste de personnes 
	public void parse(InputSource input) throws IOException,SAXException{ 
		if(!(input instanceof AnnuaireSource)){ 
			String m = "Le seul argument possible pour parse est une AnnuaireSource"; 
			throw new SAXException(m); 
		} 
		if(handler == null){ 
			throw new SAXException("Pas de ContentHandler"); 
		} 
		AnnuaireSource source = (AnnuaireSource)input; 
		List<Personne> personnes = source.getPersonnes(); 
  
		handler.startDocument();  
		handler.startElement("", "annuaire", "annuaire", atts); 
		for(Personne p : personnes){ 
			atts.addAttribute("","id","id","",String.valueOf(p.getId())); 
			handler.startElement("", "personne", "personne", atts); 
			atts.clear(); 
  
			handler.startElement("", "nom", "nom", atts); 
			char[] nom = p.getNom().toCharArray(); 
			handler.characters(nom,0,nom.length); 
			handler.endElement("", "nom", "nom"); 
  
			handler.startElement("", "prenom", "prenom", atts); 
			char[] prenom = p.getPrenom().toCharArray(); 
			handler.characters(prenom,0,prenom.length); 
			handler.endElement("", "prenom", "prenom"); 
  
			handler.startElement("", "adresse", "adresse", atts); 
			char[] adresse = p.getAdresse().toCharArray() ; 
			handler.characters(adresse,0,adresse.length); 
			handler.endElement("", "adresse", "adresse"); 
  
			handler.endElement("", "personne", "personne"); 
		} 
		handler.endElement("", "annuaire", "annuaire"); 
		handler.endDocument(); 
	} 
	public void parse(String systemId) throws IOException,SAXException{ 
		String m = "Le seul argument possible pour parse est une AnnuaireSource"; 
		throw new SAXException(m); 
	} 
	// autres méthodes à implémenter 
}
Exemple d'utilisation :

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
// Création de l'annuaire 
List<Personne> annuaire = new ArrayList<Personne>(); 
// ... 
//remplissage de l'annuaire 
  
// Création de la source DOM 
XMLReader annuaireReader = new AnnuaireReader(); 
InputSource annuaireSource = new AnnuaireSource(annuaire);  
Source source = new SAXSource(annuaireReader, annuaireSource); 
  
// Création du fichier de sortie 
File file = new File("CreationSAX.xml"); 
Result resultat = new StreamResult(file); 
  
// Configuration du transformer 
TransformerFactory fabrique = TransformerFactory.newInstance(); 
Transformer transformer = fabrique.newTransformer(); 
transformer.setOutputProperty(OutputKeys.INDENT, "yes"); 
transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1"); 
  
// Transformation 
transformer.transform(source, resultat);
Téléchargez le code source complet ci-dessous.

Mis à jour le 4 décembre 2004 Ioan

La création d'un document HTML avec XSLT passe par l'utilisation d'une feuille de style (XSL). Voici le code à utiliser :

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
public static void creerHTML(String xml, String xsl, String html) throws Exception{ 
	// Création de la source DOM 
	DocumentBuilderFactory fabriqueD = DocumentBuilderFactory.newInstance(); 
	DocumentBuilder constructeur = fabriqueD.newDocumentBuilder(); 
	File fileXml = new File(xml); 
	Document document = constructeur.parse(fileXml); 
	Source source = new DOMSource(document); 
  
	// Création du fichier de sortie 
	File fileHtml = new File(html); 
	Result resultat = new StreamResult(fileHtml); 
  
	// Configuration du transformer 
	TransformerFactory fabriqueT = TransformerFactory.newInstance(); 
	StreamSource stylesource = new StreamSource(xsl); 
	Transformer transformer = fabriqueT.newTransformer(stylesource); 
	transformer.setOutputProperty(OutputKeys.METHOD, "html"); 
  
	// Transformation 
	transformer.transform(source, resultat); 
}
Vous pouvez télécharger ci-dessous un exemple simple avec xml, xsl et classe de test.

Mis à jour le 4 décembre 2004 Ioan

L'API standard ne fournit pas de mécanisme pour transformer un XML en PDF. Par contre, une très bonne librairie existe pour ça : FOP (Formatting Object Processor) . Voici un exemple d'utilisation de FOP :

Code Java : Sélectionner tout
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public static void creerPDF(String xml, String xsl, String pdf) throws Exception{ 
	// création du résultat (pdf) 
	Driver driver = new Driver(); 
	driver.setRenderer(Driver.RENDER_PDF); 
	driver.setOutputStream(new java.io.FileOutputStream(pdf)); 
	Result resultat = new SAXResult(driver.getContentHandler()); 
  
	// récupération de la source xml 
	Source source = new StreamSource(xml); 
  
	// création du transformer en fonction du xsl 
	Source style = new StreamSource(xsl); 
	TransformerFactory transformerFactory = TransformerFactory.newInstance(); 
	Transformer transformer = transformerFactory.newTransformer(style); 
  
	// transformation 
	transformer.transform(source, resultat); 
}
Vous pouvez télécharger un exemple complet avec xml et xsl ci dessous. Vérifiez bien que la librairie FOP (et ses dépendances) se trouve dans votre classpath avant de compiler/exécuter l'exemple.

Mis à jour le 4 décembre 2004 Ioan

Vous pouvez très bien vouloir enchaîner les transformations XSLT. Par enchaîner, on entend appliquer plusieurs transformations successives à un document XML. Chaque résultat de transformation devenant ainsi la source de la prochaine. Pour vous aider à faire ceci, le package org.xml.sax vous propose la classe XMLFilter. Voici le principe :



Voici une méthode prenant en arguments un fichier XML, deux feuilles de style xsl (les transformations à enchaîner) et un fichier html de sortie.

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
public static void transformer(File xml, File xsl1, File xsl2, File html) throws Exception{ 
	// Création du reader initial 
	SAXParserFactory spf = SAXParserFactory.newInstance(); 
	spf.setNamespaceAware(true); 
	XMLReader reader = spf.newSAXParser().getXMLReader(); 
  
	// Création des filtres à appliquer au reader 
	SAXTransformerFactory stf = (SAXTransformerFactory)TransformerFactory.newInstance(); 
	XMLFilter filtre1 = stf.newXMLFilter(new StreamSource(xsl1)); 
	XMLFilter filtre2 = stf.newXMLFilter(new StreamSource(xsl2)); 
  
	// On "lie" le reader aux filtres 
	filtre1.setParent(reader); 
	filtre2.setParent(filtre1); 
  
	// Création de la source : c'est le dernier filtre de la chaîne 
	// C'est lui qui indiquera au transformer quelles transformations à faire "avant" 
	// Le résultat est le fichier HTML 
	SAXSource source = new SAXSource(filtre2, new InputSource(new FileInputStream(xml))); 
	StreamResult resultat = new StreamResult(new FileOutputStream(html)); 
  
	//Transformation en chaîne 
	Transformer transformer = stf.newTransformer(); 
	transformer.transform(source, resultat); 
}
Vous pouvez télécharger un exemple complet d'utilisation ci-dessous.

Mis à jour le 1er février 2005 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 -