Discussion :

[hibatunis]

Bonjour,
je suis en train de créer un parser XML, j'ai utilisé le code ci-dessous qui ne fonctionne pas , en fait la méthode "matches" ne répond pas, bien que le code est correct (copié de ce site même) , voici mon code:

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
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
 
import java.io.*;
import org.jdom2.*;
import org.jdom2.input.*;
import org.jdom2.output.*;
import org.jdom2.filter.*;
 
import java.util.List;
import java.util.Iterator;
 
public class JDOM2
{
	static org.jdom2.Document document;
	static Element racine;
 
	   public static void main(String[] args)
	   {
	      //On crée une instance de SAXBuilder
	      SAXBuilder sxb = new SAXBuilder();
	      try
	      {
	         //On crée un nouveau document JDOM avec en argument le fichier XML
	         //Le parsing est terminé ;)
	         document = sxb.build(new File("Exercice2.xml"));
	      }
	      catch(Exception e){}
 
	      //On initialise un nouvel élément racine avec l'élément racine du document.
	      racine = document.getRootElement();
 
	      //Méthode définie dans la partie 3.2. de cet article
	      System.out.println("avant appel d'afficher filtre");
	      afficheFiltre();
	   }
   static void affiche()
   {
      try
      {
         //On utilise ici un affichage classique avec getPrettyFormat()
         XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
         sortie.output(document, System.out);
      }
      catch (java.io.IOException e){}
   }
 
   static void enregistre(String fichier)
   {
      try
      {
         //On utilise ici un affichage classique avec getPrettyFormat()
         XMLOutputter sortie = new XMLOutputter(Format.getPrettyFormat());
         //Remarquez qu'il suffit simplement de créer une instance de FileOutputStream
         //avec en argument le nom du fichier pour effectuer la sérialisation.
         sortie.output(document, new FileOutputStream(fichier));
      }
      catch (java.io.IOException e){}
   }
 
   static void afficheALL()
   {
      //On crée une List contenant tous les noeuds "etudiant" de l'Element racine
      List listEtudiants =  racine.getChildren("etudiant");
 
      //On crée un Iterator sur notre liste
      Iterator i = listEtudiants.iterator();
      while(i.hasNext())
      {
         //On recrée l'Element courant à chaque tour de boucle afin de
         //pouvoir utiliser les méthodes propres aux Element comme :
         //sélectionner un nœud fils, modifier du texte, etc...
         Element courant = (Element)i.next();
         //On affiche le nom de l’élément courant
         System.out.println(courant.getChild("nom").getText());
      }
   }
   static void afficheFiltre()
   {
      //On crée un nouveau filtre
	  // System.out.println("avant instanciation de Filter");
      Filter filtre = new Filter()
      {
         //On défini les propriétés du filtre à l'aide
         //de la méthode matches
 
 
         /**
                 * 
                 */
		private static final long serialVersionUID = 1L;
 
		public boolean matches(Object ob)
         {
            //1 ère vérification : on vérifie que les objets
            //qui seront filtrés sont bien des Elements
 
            if(!(ob instanceof Element)){   return false;}
 
            //On crée alors un Element sur lequel on va faire les
            //vérifications suivantes.
            Element element = (Element)ob;
 
            //On crée deux variables qui vont nous permettre de vérifier
            //les conditions de nom et de prenom
            int verifNom = 0;
            int verifPrenom = 0;
 
            //2 ème vérification: on vérifie que le nom est bien "CynO"
            if(element.getChild("nom").getTextTrim().equals("CynO"))
            {
            	System.out.println("getchild cyno est vérifié");
               verifNom = 1;
            }
            //3 ème vérification: on vérifie que CynO possède un prenom "Laurent"
            //On commence par vérifier que la personne possède un prenom,
            //en effet notre fichier XML possède des étudiants sans prénom !
            Element prenoms = element.getChild("prenoms");
            if(prenoms == null){return false;}
 
            //On constitue une list avec tous les prenom
            List listprenom = prenoms.getChildren("prenom");
 
            //On effectue la vérification en parcourant notre liste de prenom
            //(voir: 3.1. Parcourir une arborescence)
            Iterator i = listprenom.iterator();
            while(i.hasNext())
            {
               Element courant = (Element)i.next();
               if(courant.getText().equals("Laurent"))
               {
                  verifPrenom = 1;
               }
            }
 
            //Si nos conditions sont remplies on retourne true, false sinon
            if(verifNom == 1 && verifPrenom == 1)
            {
               return true;
            }
            return false;
         }
 
		@Override
		public Filter and(Filter arg0) {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public List filter(List arg0) {
			// TODO Auto-generated method stub
 
			return null;
		}
 
		@Override
		public Object filter(Object arg0) {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public Filter negate() {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public Filter or(Filter arg0) {
			// TODO Auto-generated method stub
			return null;
		}
 
		@Override
		public Filter refine(Filter arg0) {
			// TODO Auto-generated method stub
			return null;
		}
      };//Fin du filtre
 
      //getContent va utiliser notre filtre pour créer une liste d'étudiants répondant
      //à nos critères.
      List resultat = racine.getContent(filtre);
      //On affiche enfin l'attribut classe de tous les éléments de notre list
      Iterator i = resultat.iterator();
      while(i.hasNext())
      {
         Element courant = (Element)i.next();
         System.out.println(courant.getAttributeValue("classe"));
      }
   }
}

[thelvin]

En fait matches() n'est jamais appelée.

Le tutoriel que tu as trouvé date un peu, il est pour JDOM 1, et toi tu utilises JDOM 2. Notamment tu t'en rends compte du fait que tes imports ne sont pas les mêmes, et que le compilateur t'a demandé d'ajouter de nombreuses méthodes que le tutoriel n'avait pas besoin de mettre.

La version 2 ressemble beaucoup à la 1, mais faire ses propres Filter a beaucoup changé.

Voici comment on s'y prendrait aujourd'hui :

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
Filter<Element> filtre = new AbstractFilter<Element>() {
 
  private static final long serialVersionUID = 1L;
 
  //On définit les propriétés du filtre à l'aide
  //de la méthode filter
 
  @Override
  public Element filter(Object content) {
    //1 ère vérification : on vérifie que les objets
    //qui seront filtrés sont bien des Elements
 
    if(!(content instanceof Element)) {
      return null;
    }
 
    //On cast alors l'objet en Element sur lequel on va faire les
    //vérifications suivantes.
    Element element = (Element)content;
 
    //On crée deux variables qui vont nous permettre de vérifier
    //les conditions de nom et de prenom
    boolean nomVerifie = false;
    boolean prenomVerifie = false;
 
    //2 ème vérification: on vérifie que le nom est bien "CynO"
    if(element.getChild("nom").getTextTrim().equals("CynO")) {
      System.out.println("getchild cyno est vérifié");
      nomVerifie = true;
    }
    //3 ème vérification: on vérifie que CynO possède un prenom "Laurent"
    //On commence par vérifier que la personne possède un prenom,
    //en effet notre fichier XML possède des étudiants sans prénom !
    Element prenoms = element.getChild("prenoms");
    if(prenoms == null) {
      return null;
    }
 
    //On effectue la vérification en parcourant les enfants <prenom>
    for(Element prenom : prenoms.getChildren("prenom")) {
      if(prenom.getText().equals("Laurent")) {
        prenomVerifie = true;
        break;
      }
    }
 
    //Si nos conditions sont remplies on retourne l'élément filtré, sinon null
    if(nomVerifie && prenomVerifie) {
      return element;
    } else {
      return null;
    }
  }
 
};

[hibatunis]

Bonjour,
Merci infinement pour votre aide , je me suis aperçue que j’utilise jdom2 et non 1 , et que que c'est le filter qui n'est plus le même , mais j'ai pas réussi à tomber sur le bout de code correct sur le net . Vous me sauvez la vie là. Encore merci