Discussion :

[domiq44]

Bonjour,

Je dois transformer des fichiers XML à l'aide de feuilles XSLT de tranformation.

J'aurai à réaliser ceci pour une nombre très grand de fichiers XML.
Chaque fichier XML sera transformé par un ou plusieurs feuilles XSL.
Je ne connais pas à l'avance quelles seront les feuilles XSL à utiliser.
Tout ceci : ça va.

Pour l'instant j'utilise la méthode présentée ci-dessous.

Mon problème est de trouver la méthode qui me donnera les meilleurs performances.

Est-ce que cette méthode est la plus performante?
Merci de votre retour.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
56
57
58
59
60
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
 
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;
 
public class TestXslt {
 
  public static void main(String[] args) {
 
    String xmlFilePath = "test.xml";
    String xslFilePath = "test.xsl";
    String outFilePath = "resultat";
 
    // On définit un transformer avec la source XSL qui va permettre la
    // transformation.
    TransformerFactory factory = TransformerFactory.newInstance();
    Transformer transformer = null;
    try {
      transformer = factory.newTransformer(new StreamSource(xslFilePath));
    } catch (TransformerConfigurationException e) {
      System.err.println("Impossible de créer un transformateur XML." + e);
      System.exit(1);
    }
 
    // Get informations
    String outputMethod = transformer.getOutputProperty("method");
    System.out.println("method : " + outputMethod);
    String outputEncoding = transformer.getOutputProperty("encoding");
    System.out.println("encoding : " + outputEncoding);
 
    // Création d'un fichier pour enregister le résultat de la génération.
    File outFile = new File(outFilePath + "." + outputMethod);
    System.out.println("Nom du fichier généré : " + outFile.getName());
 
    FileOutputStream out = null;
    try {
      out = new FileOutputStream(outFile);
    } catch (FileNotFoundException e) {
      System.err.println("Impossible de créer le fichier résultat." + e);
      System.exit(1);
    }
 
    // Transform
    try {
      transformer.transform(new StreamSource(new File(xmlFilePath)), new StreamResult(out));
    } catch (TransformerException e) {
      System.err.println("La transformation a échouée." + e);
      System.exit(1);
    }
 
    System.out.println("Fichier généré avec succés.");
    System.exit(0);
  }
}

Exemple: Un petit fichier XML de test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
<?xml version="1.0"?>
<pipo>toto</pipo>

Et une petite feuille XSLT de test:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
<xsl:stylesheet xmlns:xsl = "http://www.w3.org/1999/XSL/Transform" version = "1.0">
    <xsl:output method = "text"/>
    <xsl:template match = "/">
        <xsl:text>Version :  </xsl:text>
        <xsl:value-of select = "system-property('xsl:version')"/>
        <xsl:text>
Vendor :  </xsl:text>
        <xsl:value-of select = "system-property('xsl:vendor')"/>
        <xsl:text>
URL :  </xsl:text>
        <xsl:value-of select = "system-property('xsl:vendor-url')"/>
    </xsl:template>
</xsl:stylesheet>

[tchize_]

etant donné que chaque XSL a besoin de relire entièrement le xml, rien à gagner en gardant le xml en mémoire. Par contre, il pourrait être judicieux de charger une fois la XSL et de la nourrir après plusieurs fois avec plusieurs fichiers xml différent. Ca éviterais de recharger le XSL à chaque fois.

[domiq44]

Merci tchize_

En effet, je pense que de garder les feuilles XSL en mémoire peut être judicieux

Probablement utiliser un map liant le nom de la feuille à la variable transformer, je ne sais pas encore

Sinon, concernant les méthodes utilisées, y en a-t-il de plus rapide?
Le fait d'utiliser des Stream?
Bref, je ne connais que ces méthodes là, il y en a peut être de plus performantes???

[tchize_]

Le performances vont surtout se jouer sur le moeur XSL que tu utilisera et le parseur xml

[thelvin]

Sinon, concernant les méthodes utilisées, y en a-t-il de plus rapide?
Le fait d'utiliser des Stream?
Bref, je ne connais que ces méthodes là, il y en a peut être de plus performantes???

En principe, difficile de faire mieux que ça. Grosso-modo pour chaque XML, le transformeur va le charger en mémoire à partir de son Stream, puis appliquer dessus les templates XSLT en envoyant le résultat sur la Stream de sortie.

Il pourrait être dangereux, par exemple, de pré-charger soi-même les fichiers, au cas où le transformeur le refasse lui-même à sa sauce.

Mais en l'état, l'algo me semble aussi efficace que faire se peut. Pour améliorer, il faudrait regarder s'il n'y a pas moyen d'utiliser autre chose, quelque chose de prévu pour la vitesse, que XML/XSLT.

[domiq44]

Merci tchize_ et thelvin pour vos retours

A propos du processeur XSLT (le moteur), comment définir celui que l'on va utiliser?

Parmis les processeur XSLT existant, lequel est le plus performant?

[tchize_]

saxon a bonne réputation.

Pour le choisir, soit tu instancie directement sa classe (cf la doc du parseur) soit tu laisse java le prendre automatiquement (si c'est le seul disponible dans la jvm).

[polymorphisme]

Bonjour,

Pour améliorer, il faudrait regarder s'il n'y a pas moyen d'utiliser autre chose, quelque chose de prévu pour la vitesse, que XML/XSLT.

Dans tout ce que j'ai pu lire, il semblerais que XSLT soit le langage le plus rapide pour effectuer des transformations XML.

Côté performances, il est clair que le processeur XSLT tient une place importante, mais on ne peut négliger la JVM et le code XSLT.