Lecture de fichier XML avec java, mon code Java n'arrive pas à lire les informations se trouvant dans les neud

Version imprimable

Bonjour,
j'ai un souci avec mon code Java qui n'arrive pas à lire mon fichier xml comme je veux. J'ai un problème avec la lecture au niveau des noeuds, le code n'affiche pas les informations des noeuds imbriqués.
J'ai passé par plusieurs moyens mais impossible. Voici mon code :

Code:

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
package LireXML;
 
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;
 
public class ReadFileConfigXML2 {
 
  public static void main(String argv[]) {
 
    try {
 
	File File = new File("fichier.xml");
	DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
	DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
	Document doc = dBuilder.parse(File);
 
	System.out.println("Root element :" + doc.getDocumentElement().getNodeName());
 
	NodeList nList = doc.getElementsByTagName("fichier");
 
	System.out.println("----------------------------");
 
	for (int temp = 0; temp < nList.getLength(); temp++) {
 
		Node nNode = nList.item(temp);
 
		System.out.println("\nCurrent Element :" + nNode.getNodeName());
 
		if (nNode.getNodeType() == Node.ELEMENT_NODE) {
 
			for(int k=0;k<nList.getLength(); k++) {
 
			Element eElement = (Element) nNode;
 
			System.out.println("machine type : " + eElement.getAttribute("type"));
			System.out.println("image type : " + eElement.getAttribute("type")+" path: "+eElement.getAttribute("path"));
			System.out.println("image type : " + eElement.getAttribute("type")+" path: "+eElement.getAttribute("path"));
			System.out.println("image type : " + eElement.getAttribute("type")+" path: "+eElement.getAttribute("path"));
			System.out.println("image type : " + eElement.getAttribute("type")+" path: "+eElement.getAttribute("path"));
			System.out.println("sortie type : " + eElement.getAttribute("type"));
			System.out.println("temp-fabrication : " + eElement.getElementsByTagName("temp-fabrication").item(temp).getTextContent());
 
 
			}
			}
	}
    } catch (Exception e) {
	e.printStackTrace();
    }
  }
 
}

Fichier xml

Code:

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
<?xml version="1.0" encoding="UTF-8"?>
<fichier>
	<donnees>
		<fabricant type="machineA">
			<symboles>
				<image type="0" path="src/ressources/img1.png"/>
				<image type="1/3" path="src/ressources/img2.png"/>
				<image type="1/2-tiers" path="src/ressources/img3.png"/>
				<image type="2/2" path="src/ressources/img4.png"/>
			</symbole>
			<fabrique type = "alumette"/>
			<temp-fabrication>5</temp-fabrication>
		</fabricant>
 
		<machine type="machineC">
			<symbole>
				<image type="0" path="src/ressources/img1.png"/>
				<image type="1/3" path="src/ressources/img2.png"/>
				<image type="1/2-tiers" path="src/ressources/img3.png"/>
				<image type="2/2" path="src/ressources/img4.png"/>
			</symble>
			<entree type="metal" quantite="2"/>
			<fabrique type="carton"/>
			<temp-fabrication>15</temp-fabrication>
		</machine>
 
	</donnees>
 
	<test>
		<machine type="machineA" id="21" x="23" y="25"/>
		<machine type="machineC" id="21" x="230" y="320"/>
 
		<arret>
			<chemin de="88" vers="52" />
			<chemin de="55" vers="37" />
 
		</arret>
	</test>
</fichier>

Je n'arrive pas du tout à lire les informations qui se trouvent dans les balises image.
Merci d'avance.

22/01/2018, 13h06
Pill_S
Code:

1 2 NodeList nList = doc.getElementsByTagName("fichier");
ça, ça va te donner le noeud fichier racine (c'est équivalent à doc.getDocumentElement()) et ça ne contiendra qu'un seul noeud.

Essaie plutôt avec
Code:

1 2 NodeList nList = doc.getElementsByTagName("image");
ça te listera toutes les images.
22/01/2018, 13h13
thelvin

Hello,

j'ajoute que si on a pas déjà du code existant qui fonctionne à base de l'API org.w3c.dom.*, il vaut infiniment mieux utiliser la bibliothèque tierce JDOM2.
L'API en org.w3c.dom.* n'est vraiment pas pratique et n'a pas d'intérêt particulier à part le fait d'être livré avec Java.
22/01/2018, 13h27
Pill_S

Disons que la base suit l'API telle que définie par le w3c... elle est la même, et moche, dans tous les languages ^^

Les surcouches (dom4j, jdom, etc.) peuvent effectivement remplir les trous que le w3c ont laissés. Mais mieux vaut avoir utilisé la base quelques temps afin de vraiment comprendre l'intérêt des autres.

Si on voulait vraiment une solution niveau pro (en terme de lisibilité et de maintenance), je redirigerais plutôt sur du jaxb et marshalling d'objets, qui est quand même un cran au-dessus.

;)
22/01/2018, 15h16
thelvin

Citation:

Envoyé par Pill_S

Disons que la base suit l'API telle que définie par le w3c... elle est la même, et moche, dans tous les languages ^^

Oui, c'est vrai, mais ça ne vaut quand même rien face à JDOM. (Qui d'ailleurs n'est pas une surcouche de org.w3c.dom et est également plus efficace en mémoire, CPU, quantité d'objets et de classes. Pas que ça fasse une différence, mais disons que c'est souvent un reproche fait aux surcouches.)

Si l'API du W3C est plutôt appréciée dans certains langages, et à raison, c'est parce que ces langages sont à typage dynamique et disposent aussi de nombreuses syntaxes pour raccourcir les contraintes de cette API. Dans un langage à typage statique, et en plus en Java qui ne propose pas de syntaxe simplificatrice, et en plus avec les NodeList qui n'ont ni été rendues génériques, ni faites sous-type de List, eh bien ça ne fonctionne tout simplement pas. C'est une syntaxe lourde sans intérêt.

Citation:

Envoyé par Pill_S

Mais mieux vaut avoir utilisé la base quelques temps afin de vraiment comprendre l'intérêt des autres.

Bof, je ne vois pas pourquoi. Etudier "comment c'est sinon" ça va bien quand il s'agit de comprendre la technologie à son niveau plus fondamental et l'histoire de son évolution pour comprendre que les bibliothèques plus haut niveau ne représentent pas toutes les possibilités mais cherchent seulement se rendre utiles en simplifiant un ensemble complexe.

Là ce n'est pas le cas, l'API est juste infiniment moins bonne qu'elle aurait pu l'être. Ce n'est pas un fondamental, c'est une mauvaise conception.

Citation:

Envoyé par Pill_S

Si on voulait vraiment une solution niveau pro (en terme de lisibilité et de maintenance), je redirigerais plutôt sur du jaxb et marshalling d'objets, qui est quand même un cran au-dessus.

C'est juste bon à perdre du temps et ne rien gagner en échange. Ce n'est ni plus lisible ni plus maintenable, ça l'est moins.
L'intérêt de JAXB se retrouve lorsqu'on doit gérer des centaines de formats XML différents dans une application. Cas typique : un webservice XML.
Autre cas assez typique : un framework de configuration en XML.

Là on est pas dans un cas comme ça. JAXB n'apporte rien et fait perdre beaucoup.
22/01/2018, 15h36
Pill_S

Autant je suis souvent d'accord avec toi, autant là bin pas trop...

Etudier les fondamentaux, c'est utile, surtout quand on les retrouve dans toutes les technos orientées web, et qu'il s'agit d'une API standardisée de facto et à forte pénétration. Ok faut se battre avec NodeList mais c'est quand même pas la fin du monde... si vraiment ça te tire les yeux tu code ton petit adapteur autour, en moins de 20 lignes tu peux exploiter un NodeList comme une List. Bon bref je vais pas m'étaler, c'est pas le sujet, c'est même un détail.

Le sujet avec lequel je suis vraiment pas d'accord, c'est jaxb: comment peux-tu défendre le fait que cela soit moins lisible?! alors que (-passons sur la learning curve qui n'est pas très bonne au départ, surtout dans la mise en place des tools-) gérer des listes de beans typés domaine est 1000x plus simple et plus testable que l'immonde plâtrée de spaghetti habituelle? quand tu changes une ligne dans ta xsd, paf tes beans sont mis à jour (merci maven)? tous les mappings sont ~~compilés~~ résolus à la compilation et plus interprétés? etc...

Vraiment là, difficile d'être d'accord avec toi...

PS: Khalfe désolé de troller ton post ^^

Merci pour vos réponses, si j'ai bien compris pour récupérer toutes les informations, à chaque noeud je dois avoir une boucle for pour parcourir le noeud avec une déclaration comme

Code:

NodeList nList = doc.getElementsByTagName("noeud");

Si c'est le cas je trouve ça vraiment lourd et en plus, j'ai besoin de ses données, je dois les utiliser pour une autre class, surtout les liens dans le noeud image <image type="0" path="src/ressources/img1.png"/>.
Dans ce cas j'aurais des boucles for imbriqués comme les noeuds?
Dans une de mes classe je tenter ça pour tester mais ça n'a rien données, j'ai tout simplement le noeud principale qui s'affiche. J'ai l'impression que je suis entrain de me mélanger avec les noeuds.

Code:

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
package LireXML;
 
import java.io.File;
import java.io.IOException;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
 
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.SAXException;
 
public class afficheNoeudXML {
    public static void main(final String[] args) {
        /*
         * Etape 1 : récupération d'une instance de la classe "DocumentBuilderFactory"
         */
        final DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
 
        try {
            /*
             * Etape 2 : création d'un parseur
             */
            final DocumentBuilder builder = factory.newDocumentBuilder();
 
	    /*
	     * Etape 3 : création d'un Document
	     */
	    final Document document= builder.parse(new File("fichier.xml"));			
	    final Element racine = document.getDocumentElement();
 
	    //Affichage de l'élément racine
	    System.out.println("\n*************RACINE************");
	    System.out.println(racine.getNodeName());
 
	    final NodeList racineNoeuds = racine.getChildNodes();
	    final int nbRacineNoeuds = racineNoeuds.getLength();
 
	    for (int i = 0; i<nbRacineNoeuds; i++) {
	        if(racineNoeuds.item(i).getNodeType() == Node.ELEMENT_NODE) {
	            final Element donnees = (Element) racineNoeuds.item(i);
 
 
	            final NodeList fabricant= donnees .getElementsByTagName("machines");
			    final int nbMachineElements = fabricant.getLength();
 
			    for(int j = 0; j<nbMachineElements ; j++) {
			    	if(machines.item(j).getNodeType() == Node.ELEMENT_NODE) {
			    	final Element machine= (Element) machines.item(j);
			    	System.out.println("Machine:"+machine.getAttribute("type") + " : " + machine.getTextContent());
 
			    	 final NodeList images= machine.getElementsByTagName("machine");
					    final int nbimagesElements = images.getLength();
					    for(int k = 0; k<nbimagesElements ; k++) {
					    	if(images.item(k).getNodeType() == Node.ELEMENT_NODE) {
					    	final Element image= (Element) images.item(j);
					    	System.out.println("Image:"+image.getAttribute("type") + " : " + image.getTextContent()+", "+image.getAttribute("path"));
			    }
			   }
                         }
                    }
             }
}
   }catch (final ParserConfigurationException e) {
            e.printStackTrace();
        }
        catch (final SAXException e) {
            e.printStackTrace();
        }
        catch (final IOException e) {
            e.printStackTrace();
        }		
    }
}

22/01/2018, 16h59
Pill_S

En général, tu as une boucle par niveau d'imbrication à exploiter (voir moins, tu peux aussi exploiter getParentNode pour réduire les niveaux d'imbrication). Tout dépend de ce que tu veux faire, ça, c'est du parsing basique. Si tu veux faire nettement plus puissant, tu peux utiliser xpath qui permet d'exprimer des prédicats un peu "à la sql".

A noter que getElementsByTagName cherche dans tout l'arbre, et pas seulement au niveau suivant (souvent on passe par getChildNodes pour descendre d'un seul niveau dans l'arbre. Mais avec getChildNodes il faut encore faire attention au NodeType des éléments qu'on récupère - on récupère tout, les commentaires, les espaces blancs, etc...)