FAQ Java XMLConsultez toutes les FAQ

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

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

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

1
2
Transformer transformeur = ...;  
transformeur.setErrorListener(new EcouteurDErreurs());

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

1
2
3
/** 
* Voir zip 
*/

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

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 
}

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

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

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

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