Stratégie DOM ou SAX pour xml ?

je désire créer des fichier XML à la volée avec jaxp, et j'ai cru comprendre qu'on pouvait faire ça avec seulement avec DOM, et que SAX est prévu pour le traitement sur des fichier XML existant, et qu'il ne permetait pas la construction de la strucute du fichier xml dans la mémoire.
[ Modéré par vedaer ]
-> Ajout du tag dans le titre
[ Merci de respecter les Règles du Forum ]

déjà, pour faire du xml simplement en java, je te conseille l'api jdom.

si tu veux créer des fichiers xml sans avoir à faire de traitement dessus, un OutputStream suffit.

créer des docs xml avec sax ne me parait pas possible.
la diff entre sax et dom est que dom charge tout le doc en mémoire pour créer un abre sur lequel on peut travailler.
sax lui est utile pour parser de très grand volume de fichiers xml à l'arborescence faible et dont on "connait l'architecture" : il ne charge rien en mémoire, ne construit pas d'arbre, et est extrèmement rapide.

Effectivement, si tu dois créer à la volée ET que tu ne dois JAMAIS les lire, tu n'as besoin ni de SAX ni de DOM. Tu les écris comme du texte et ça roule. Passer par du DOM sera inutilement coûteux.

jdom est bien dans son utilisation d'après ce que j'ai lu, mais l'inconvenient est qu'il faut l'installer dans les machine ou mon app est sensé tourner.

j'ai pensé à m'en passer du tech DOM et SAX pour la génération du fichier XML, mais je crois que j'aurai à modifier la structure du fichier après...

Bah remarque ... il sera toujours temps APRES de faire du DOM.
En gros pour générer un fichier XML il suffit de faire ça :
Code:

1 2 3 4 5 6 7 8 9 System.out.println("<xml..."); System.out.println("<Balise1>"); System.out.println(" <Balise2>"); System.out.print(" <Balise3>"); System.out.print(monObjet.getValeurEnString()); System.out.println(" </Balise3>"); System.out.println(" </Balise2>"); System.out.println("</Balise1>");
Donc passer par une API ne te servira qu'à ne pas oublier de balise, à ne pas faire d'erreur, mais bon ça t'apportera pas de VRAIES plus-value (à part peut-être une gestion correcte des formats d'encodage.

Même pour les problèmes d'encodage, depuis le JDK 1.4 on encode les fichiers écrits dans le format que l'on veut.

Comme nuke_y je te conseille de ne pas passer par une API XML pour écrire du XML.

je serais obligé d'utiliser les api XML pour lire les fichiers XML, donc, mieux commencer dès maintenant et les assimiler, et non reporter ça après.

selon vous, dois-je utiliser jdom, et est-ce possible d'inclure cette api dans mon projet, et faciliter grandement l'installation de mon application et son utilisation, sans amener l'user à installer l'api pour pouvoir travailler avec mon appli.

API perso

Bonjour,

J'ai créé une classe perso qui me permet de créer, lire et modifier des fichiers XML.

Je ne connais pas les performances (pour les fichiers que j'ai à modifier, ca ne m'est pas très utile), mais ca pourrait être judicieux de les faire si tu as des gros fichiers à manipuler.

J'utilise DOM et SAX (certaines parties de code viennent d'internet).

Voici le 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
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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
/*
 * Created on 21 mars 2005
 *
 */
package com.ben.fichiers.xml;
 
import java.io.File;
import java.io.IOException;
 
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.transform.OutputKeys;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
 
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.w3c.dom.Text;
import org.xml.sax.ErrorHandler;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;
 
/**
 * @author AntAreS Classe permettant la gestion des fichiers XML : Lecture des
 * éléments, écriture de nouveaux éléments, écriture de nouveaux fichiers XML.
 */
public class ManipulateurFichierXML {
	/** représentation java du document XML */
	private Document iDocumentXML = null;
 
	/** nom du fichier XML */
	private String iNomFichierXML = null;
 
	/** nom de la dtd */
	private String iNomFichierDTD = null;
 
	/** validation de la DTD */
	private boolean iDoitRespecterDTD = false;
 
	/** Noeud Racine du fichier XML */
	private Noeud iRoot = null;
 
	/**
         * Constructeur ManipulateurFichierXML. <br>
         * Nécessite le nom du fichier à manipuler. <br>
         * Ne vérifiera pas la DTD. <br>
         * 
         * @param String pNomFichierXML
         */
	public ManipulateurFichierXML(String pNomFichierXML) {
		super();
		iNomFichierXML = pNomFichierXML;
		iNomFichierDTD = null;
		iDoitRespecterDTD = false;
		lireFichierXML();
		creerArbre();
	}
 
	/**
         * Constructeur ManipulateurFichierXML. <br>
         * Nécessite le nom du fichier à manipuler, le nom de la DTD et doit savoir
         * s'il faut contrôler la DTD. <br>
         * Le nom de la DTD permet, lors de l'écriture du fichier XML, d'insérer la
         * ligne XML de référence à cette DTD. <br>
         * 
         * @param String pNomFichierXML
         * @param String pNomFichierDTD
         * @param boolean pDoitVerifierDTD
         */
	public ManipulateurFichierXML(String pNomFichierXML, String pNomFichierDTD, boolean pDoitVerifierDTD) {
		super();
		iNomFichierXML = pNomFichierXML;
		iNomFichierDTD = pNomFichierDTD;
		iDoitRespecterDTD = pDoitVerifierDTD;
		lireFichierXML();
		creerArbre();
	}
 
	/**
         * Constructeur ManipulateurFichierXML. <br>
         * Nécessite le nom du fichier à manipuler. <br>
         * Vérifier la DTD sur demande. <br>
         * 
         * @param String pNomFichierXML
         * @param boolean pDoitVerifierDTD
         */
	public ManipulateurFichierXML(String pNomFichierXML, boolean pDoitVerifierDTD) {
		super();
		iNomFichierXML = pNomFichierXML;
		iNomFichierDTD = null;
		iDoitRespecterDTD = pDoitVerifierDTD;
		lireFichierXML();
		creerArbre();
	}
 
	/**
         * Accesseur. <br>
         */
	private void lireFichierXML() {
		//parser XML
		try {
			DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
			docBuilderFactory.setValidating(iDoitRespecterDTD); //contrôle DTD sur
			// demande
			DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
			docBuilder.setErrorHandler(new ErrorHandler() {
				public void error(SAXParseException arg0) throws SAXException {
					System.err.println("Erreur - Fichier :<" + arg0.getSystemId() + ">");
					System.err.println("\t -> Ligne " + arg0.getLineNumber());
					System.err.println("\t -> Erreur : " + arg0.getMessage());
				}
 
				public void fatalError(SAXParseException arg0) throws SAXException {
					System.err.println("Erreur - Fichier :<" + arg0.getSystemId() + ">");
					System.err.println("\t -> Ligne " + arg0.getLineNumber());
					System.err.println("\t -> Erreur : " + arg0.getMessage());
				}
 
				public void warning(SAXParseException arg0) throws SAXException {
					System.out.println("warning - Fichier :<" + arg0.getSystemId() + ">");
					System.out.println("\t -> Ligne " + arg0.getLineNumber());
					System.out.println("\t -> Erreur : " + arg0.getMessage());
				}
			});
			iDocumentXML = docBuilder.parse(new File(iNomFichierXML).toURL().toString());
		} catch (SAXException erreurSAX) {
			System.err.println("");
			erreurSAX.printStackTrace();
		} catch (ParserConfigurationException erreurParser) {
			erreurParser.printStackTrace();
		} catch (IOException erreurIO) {
			System.err.println("Impossible d'ouvir le fichier <" + iNomFichierXML + ">");
			erreurIO.printStackTrace();
		}
	}
 
	/**
         * Créé l'arbre se basant sur le fichier XML. <br>
         * La racine sera le permier noeud du fichier XML.
         */
	private void creerArbre() {
		Node first = iDocumentXML.getFirstChild();
		while (first.getNodeType() != 1) {
			first = first.getNextSibling();
		}
		Noeud root = new Noeud(first.getNodeName());
		traiterFils(first, root);
		iRoot = root;
	}
 
	/**
         * Ajoute tous les fils d'un <code>org.w3c.dom.Node</code> à un
         * <code>Noeud</code>.<br>
         * Travail récursivement.
         * 
         * @param org.w3c.dom.Node pNoeudPere
         * @param com.ben.fichiers.xml.Noeud pNoeudSortie
         */
	private void traiterFils(Node pNoeudPere, Noeud pNoeudSortie) {
		if (pNoeudPere.hasChildNodes()) {
			NodeList listeNodes = pNoeudPere.getChildNodes();
			boolean flagFils = false;
			for (int i = 0; i < listeNodes.getLength(); i++) {
				Node fils = listeNodes.item(i);
				// Type = 1 -> Element Node
				if (fils.getNodeType() == 1) {
					flagFils = true;
					pNoeudSortie.addElement(createNode(fils));
				}
			}
			//////////////////////////
			// traitement de la valeur
			if (!flagFils) {
				if (pNoeudPere.hasChildNodes()) {
					for (int i = 0; i < listeNodes.getLength(); i++) {
						Node fils = listeNodes.item(i);
						// Type = 3 -> Text Node
						if (fils.getNodeType() == 3) {
							pNoeudSortie.setValeur(fils.getNodeValue());
						}
					}
				}
			}
		}
	}
 
	/**
         * Transforme un noeud de type <code>org.w3c.dom.Node</code> en
         * <code>com.ben.fichiers.xml.Noeud</code>.<br>
         * Traite les fils pouvant exister. <br>
         * 
         * @param <code>org.w3c.dom.Node</code> pNoeud
         * @return <code>com.ben.fichiers.xml.Noeud</code>
         */
	private Noeud createNode(Node pNoeud) {
		Noeud noeud = new Noeud(pNoeud.getNodeName());
		////////////////////////////
		// traitement des attributs
		NamedNodeMap attributs = pNoeud.getAttributes();
		for (int i = 0; i < attributs.getLength(); i++) {
			Node noeudAttribut = attributs.item(i);
			// type = 2 -> Noeud Attribut
			if (noeudAttribut.getNodeType() == 2) {
				String nomAttribut = noeudAttribut.getNodeName();
				String valeurAttribut = noeudAttribut.getNodeValue();
				noeud.setAttribut(nomAttribut, valeurAttribut);
			}
		}
 
		//////////////////////
		// traitement des fils
		if (pNoeud.hasChildNodes()) {
			traiterFils(pNoeud, noeud);
		}
		return noeud;
	}
 
	/**
         * Retourne la racine de l'arbre construit à partir du fichier XML.
         * @return Noeud Racine de l'arbre
         */
	public Noeud getTree() {
		return iRoot;
	}
 
	/**
         * Créé le fichier XML à partir du noeud racine pRoot. <br>
         * Le nom du fichier de sortie doit être absolue. <br>
         * Le nom du fichier de DTD peut être null. Dans ce cas, il n'y aura pas de
         * contrôle de DTD.
         * 
         * @param pNomFichier Nom du fichier XML de sortie
         * @param pRoot Noeud racine à construire
         * @param pNomDTD Nom du fichier de DTD. Peut être null.
         */
	public static void ecrireFichierXML(String pNomFichier, Noeud pRoot, String pNomDTD) {
		if (pNomFichier != null && pNomFichier.length() > 0) {
			if (pNomFichier.toLowerCase().endsWith(".xml")) {
				try {
					// création Fichier de sortie
					StreamResult out = new StreamResult(pNomFichier);
 
					// Init XML
					// JAXP + DOM
					DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
					DocumentBuilder builder = factory.newDocumentBuilder();
					DOMImplementation impl = builder.getDOMImplementation();
 
					// Création du noeud Root.
					if (pRoot != null) {
						Document xmldoc = impl.createDocument(null, pRoot.getName(), null);
						Element root = xmldoc.getDocumentElement();
 
						// convertion Noeud -> XML
						convertirNoeud(root, pRoot, xmldoc);
 
						// Ecrire le fichier XML
						DOMSource domSource = new DOMSource(xmldoc);
						TransformerFactory tf = TransformerFactory.newInstance();
						Transformer transformer = tf.newTransformer();
						transformer.setOutputProperty(OutputKeys.METHOD, "xml");
						// Si un fichier DTD est défini, on ajoute ce fichier dans 
						// la définition du fichier XML
						if (pNomDTD != null) {
							transformer.setOutputProperty(OutputKeys.DOCTYPE_SYSTEM, pNomDTD);
						}
						transformer.setOutputProperty(OutputKeys.ENCODING, "ISO-8859-1");
						// Permet de mettre en forme le fichier XML
						transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "4");
						transformer.setOutputProperty(OutputKeys.INDENT, "yes");
						// Ecrit le fichier XML
						transformer.transform(domSource, out);
					} else {
						System.err.println("Le noeud racine ne peut être null");
					}
				} catch (Exception e) {
					e.printStackTrace();
				}
			} else {
				System.err.println("Le nom du fichier doit se terminer par .xml");
			}
		} else {
			System.err.println("Le nom du fichier de sortie ne peut pas être null ou vide");
		}
	}
 
	/**
         * Permet de convertir un <code>Noeud</code> en <code>Node</code>.<br>
         * Les fils du <code>Noeud</code> seront aussi traités.<br>
         * Le <code>Document</code> est essentiel pour créer de nouveaux noeuds.
         * @param pNoeudSortie <code>Node</code> de sortie (le convertit)
         * @param pNoeudEntree <code>Noeud</code> d'entrée (celui à convertir)
         * @param pDoc <code>Document</code> servant à créer les nouveaux <code>Node</code>
         */
	private static void convertirNoeud(Node pNoeudSortie, Noeud pNoeudEntree, Document pDoc) {
		if (pNoeudEntree != null && pNoeudSortie != null) {
			// Attributs
			String[] listeAttribut = pNoeudEntree.getListAttributs();
			if (listeAttribut != null) {
				for (int i = 0; i < listeAttribut.length; i++) {
					String attr = listeAttribut[i];
					String valeur = pNoeudEntree.getAttribut(attr);
					if (pNoeudSortie instanceof Element) {
						((Element) pNoeudSortie).setAttribute(attr, valeur);
					} else {
						System.err.println("Impossible de déterminer le type du noeud de sortie");
					}
				}
			}			
			// valeur
			if(pNoeudEntree.getValeur() != null){
				Text t = pDoc.createTextNode(pNoeudEntree.getValeur());
				pNoeudSortie.appendChild(t);
			}
 
			// Fils
			Noeud[] listeFils = pNoeudEntree.getAllElements();
			if(listeFils != null){
				for (int i = 0; i < listeFils.length; i++) {
					Noeud noeud = listeFils[i];
					// On crée le nouveau noeud
					Element e = pDoc.createElement(noeud.getName());
					// On convertit ce nouveau noeud
					convertirNoeud(e,noeud,pDoc);
					// Une fois convertit, on l'ajoute au père.
					pNoeudSortie.appendChild(e);
				}
			}
		} else {
			System.err.println("Impossible de convertir les noeuds fils, le noeud d'entrée ou de sortie est null");
		}
	}
}

Et la classe Noeud qui permet de mieux représenter 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
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
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
/*
 * Created on 20 mars 2005
 *
 */
package com.ben.fichiers.xml;
 
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
 
/**
 * @author AntAreS
 * Noeud représentant un noeud dans une structure XML.
 */
public class Noeud {
	/** Map contenant des String*/
	private Map iMapAttributs = null;
	/** ArrayList contenant des Node */
	private ArrayList iListElements = null;
	/** Le nom du noeud (ei. &lt;<code>NomNoeud</code> ...> ... &lt;/<code>NomNoeud</code>>)*/
	private String iNom = null;
	/** Valeur du noeud. Peut être <code>NULL</code> si le noeud est une liste. */
	private String iValeur = null; 
 
	/**
         * Constructeur contenant le nom du noeud. <br>
         * Créer une nouvelle Map pour les attributs et un nouveau ArrayList 
         * pour les sous-éléments.
         * @param pNom
         */
	public Noeud(String pNom){
		iNom = pNom;
		iMapAttributs = new HashMap();
		iListElements = new ArrayList();	
	}
 
	/**
         * Constructeur avec un nom de noeud et des sous-éléments déjà existant.<br>
         * Créer une nouvelle Map pour les attributs.<br>
         * Si la liste des éléments est null, une nouvelle liste sera créée.
         * @param pListeElements
         */
	public Noeud(String pNom, Noeud[] pListeElements){
		if(pListeElements != null){
			ArrayList liste = new ArrayList();
			for(int i = 0;i<pListeElements.length;i++){
				liste.add(pListeElements[i]);
			}
			iListElements = liste; 
		}else{
			iListElements = new ArrayList();
		}
		iNom = pNom;
		iMapAttributs = new HashMap();
	}
 
	/**
         * Constructeur avec des sous-éléments déjà existant.<br>
         * Créer une nouvelle Map pour les attributs.<br>
         * Si la liste des éléments est null, une nouvelle liste sera créée.
         * @param pListeElements
         */
	public Noeud(Noeud[] pListeElements){
		if(pListeElements != null){
			ArrayList liste = new ArrayList();
			for(int i = 0;i<pListeElements.length;i++){
				liste.add(pListeElements[i]);
			}
			iListElements = liste; 
		}else{
			iListElements = new ArrayList();
		}
		iMapAttributs = new HashMap();
	}
 
	/**
         * Constructeur avec un nom de noeud et des attributs déjà existant.<br>
         * Créer un nouveau ArrayList pour les sous-éléments.<br>
         * Si la Map des attributs est null, une nouvelle Map sera créée.
         * @param pMapAttributs
         */
	public Noeud(String pNom, Map pMapAttributs){
		if(pMapAttributs != null){
			iMapAttributs = pMapAttributs;
		}else{
			iMapAttributs = new HashMap();
		}
		iNom = pNom;
		iListElements = new ArrayList();
	}
 
	/**
         * Constructeur avec des attributs déjà existant.<br>
         * Créer un nouveau ArrayList pour les sous-éléments.<br>
         * Si la Map des attributs est null, une nouvelle Map sera créée.
         * @param pMapAttributs
         */
	public Noeud(Map pMapAttributs){
		if(pMapAttributs != null){
			iMapAttributs = pMapAttributs;
		}else{
			iMapAttributs = new HashMap();
		}
		iListElements = new ArrayList();
	}
 
	/**
         * Constructeur avec un nom de noeud et tout déjà créé.<br>
         * Si la Map des attributs est null, une nouvelle Map sera créée.<br>
         * Si la liste des éléments est null, une nouvelle liste sera créée.<br>
         * @param pMapAttributs
         * @param pListeElements
         */
	public Noeud(String pNom, Map pMapAttributs, Noeud[] pListeElements){
		if(pListeElements != null){
			ArrayList liste = new ArrayList();
			for(int i = 0;i<pListeElements.length;i++){
				liste.add(pListeElements[i]);
			}
			iListElements = liste; 
		}else{
			iListElements = new ArrayList();
		}
		if(pMapAttributs != null){
			iMapAttributs = pMapAttributs;
		}else{
			iMapAttributs = new HashMap();
		}
		iNom = pNom;
	}
 
	/**
         * Constructeur avec tout déjà créé.<br>
         * Si la Map des attributs est null, une nouvelle Map sera créée.<br>
         * Si la liste des éléments est null, une nouvelle liste sera créée.<br>
         * @param pMapAttributs
         * @param pListeElements
         */
	public Noeud(Map pMapAttributs, Noeud[] pListeElements){
		if(pListeElements != null){
			ArrayList liste = new ArrayList();
			for(int i = 0;i<pListeElements.length;i++){
				liste.add(pListeElements[i]);
			}
			iListElements = liste; 
		}else{
			iListElements = new ArrayList();
		}
		if(pMapAttributs != null){
			iMapAttributs = pMapAttributs;
		}else{
			iMapAttributs = new HashMap();
		}
	}
 
	/**
         * Retourne le nom du noeud.
         * @return le nom du Noeud.
         */
	public String getName(){
		return iNom;
	}
 
	/**
         * Défini le nom du noeud.
         * @param pNom
         */
	public void setName(String pNom){
		iNom = pNom;
	}
 
	/**
         * Récupère la valeur de l'attribut s'il existe.<br>
         * Retourne <code>NULL</code> sinon.
         * @param pNomAttribut
         * @return La valeur de la l'attribut. Null s'il n'existe pas.
         */
	public String getAttribut(String pNomAttribut){
		if(iMapAttributs.containsKey(pNomAttribut)){
			return (String)iMapAttributs.get(pNomAttribut);
		}else{
			return null;
		}
	}
 
	/**
         * Permet de redéfinir ou d'ajouter un attribut dans la liste.<br>
         * Si un attribut existait déjà, la valeur de cet attribut sera retournée.
         * @param pNomAttribut
         * @param pValeurAttribut
         * @return La valeur de l'ancien attribut, <code>NULL</code> s'il n'y en avait pas
         */
	public String setAttribut(String pNomAttribut, String pValeurAttribut){
		return (String)iMapAttributs.put(pNomAttribut,pValeurAttribut);		
	}
 
	/**
         * Retourne le premier noeud correspondant au nom de l'élément.<br>
         * Retourne <code>NULL</code> si l'élément n'existe pas.
         * @param pNomElement
         * @return
         */
	public Noeud getElement(String pNomElement){
		if(pNomElement!= null && pNomElement.length()>0){
			for(Iterator it = iListElements.iterator();it.hasNext();){
				Noeud sousNoeud = (Noeud)it.next();
				if(pNomElement.equals(sousNoeud.getName())){
					return sousNoeud;
				}
			}
		}
		return null;
	}
 
	/**
         * Vérifie si l'élément est déjà dans la liste.<br> 
         * @param pNomElement
         * @return <code>true</code> si l'élément est dans la liste, <code>false</code> sinon.
         */
	public boolean hasElement(String pNomElement){
		if(pNomElement!= null && pNomElement.length()>0){
			for(Iterator it = iListElements.iterator();it.hasNext();){
				Noeud sousNoeud = (Noeud)it.next();
				if(pNomElement.equals(sousNoeud.getName())){
					return true;
				}
			}
		}
		return false;
	}
 
	/**
         * Ajoute un noeud dans la liste des sous noeuds.<br>
         * @param pElement
         * @return <code>true</code> si l'ajout a pû se faire, <code>false</code> sinon.
         */
	public boolean addElement(Noeud pElement){
		return iListElements.add(pElement);		
	}
 
	/**
         * Retourne un tableau de <code>Node</code>.<br>
         * @param pNomElement
         * @return Node[] 
         */
	public Noeud[] getElements(String pNomElement){
		ArrayList liste = new ArrayList();
		if(pNomElement!= null && pNomElement.length()>0){
			for(Iterator it = iListElements.iterator();it.hasNext();){
				Noeud sousNoeud = (Noeud)it.next();
				if(pNomElement.equals(sousNoeud.getName())){
					liste.add(sousNoeud);
				}
			}
		}
		return (Noeud[])liste.toArray();
	}
 
	/**
         * Retourne l'ensemble des éléments.
         * @return Noeud[] 
         */
	public Noeud[] getAllElements(){
		Noeud[] liste = new Noeud[getNumberOfChildren()];
		for (int i = 0; i < liste.length; i++) {
			liste[i] =  (Noeud)iListElements.get(i);
		}
		return liste;
	}
 
	/**
         * Accesseur.
         * @return La valeur du noeud.
         */
	public String getValeur(){
		return iValeur;
	}
 
	/**
         * Accesseur.
         * @param pValeur
         */
	public void setValeur(String pValeur){
		if(pValeur != null)
			iValeur = pValeur;
	}
 
	/**
         * Retourne le nombre d'élément enfant du noeud.
         * @return 
         */
	public int getNumberOfChildren(){
		if(iListElements!=null){
			return iListElements.size();
		}else{
			return -1;
		}
	}
 
	/**
         * Retourne le nombre d'attributs du noeud.
         * @return 
         */
	public int getNumberOfAttributes(){
		if(iMapAttributs!=null){
			return iMapAttributs.size();
		}else{
			return -1;
		}
	}
	/*
	 *  (non-Javadoc)
	 * @see java.lang.Object#toString()
	 */
	public String toString(){
		StringBuffer temp = new StringBuffer();
		temp = temp.append(iNom);
		if(getNumberOfAttributes()>0){
			temp = temp.append(" - "+getNumberOfAttributes()+" attributs");
		}
		if(getNumberOfChildren()>0){
			temp = temp.append(" - "+getNumberOfChildren()+" fils");
		}
		if(iValeur != null && iValeur.length()>0){
			temp = temp.append(" - Valeur : "+ (iValeur.length()>6?iValeur.substring(0,6):iValeur));
 
		}
		return temp.toString();
	}
 
	/**
         * Retourne la liste des attributs.<br>
         * Il est nécessaire de récupérer les valeurs de ces attributs par la suite.
         * @return String[]
         */
	public String[] getListAttributs(){
		Set set = iMapAttributs.keySet();
		String[] liste = new String[set.size()];
		Iterator it = set.iterator();
		for (int i = 0; it.hasNext();i++) {
			String key = (String) it.next();
			liste[i] = key;
		}
		return liste;
	}
}

Si vous voyez des gros problèmes ou des fautes d'écriture (même d'orthograhe) dans les classes, n'hésitez pas à m'écrire.

L'intérêt de ces classes est surtout d'entrevoir les possibilités de Java pour le XML.

J'espère que ca peut t'aider.

ben

PS: je viens de me rendre compte que le nom du noeud ne peut pas contenir de caractères particuliers ( espace, \, /, ....).

utilisation

Son utilisation est ensuite assez simple:

Pour créer un nouveau fichier XML :

Code:

1
2
3
4
5
6
Noeud root = new Noeud("Nom_Du_Noeud_Racine");
Noeud fils = new Noeud("fils");
fils.setAttribut("nom","le nom que je veux");
root.addElement(fils);
 
ManipulateurFichierXML.ecrireFichierXML("C:\\liste.xml",root,null);

Fichier de sortie liste.xml et pas de DTD:

Code:

1
2
3
4
<?xml version="1.0" encoding="ISO-8859-1"?>
<Nom_Du_Noeud_Racine>
    <fils nom="le nom que je veux"/>
</Nom_Du_Noeud_Racine>

Voilà

Bonjour,

il y a quand même un gros avantage supplémentaire à utiliser une API spécialisée plutôt que l'enregistrement d'un simple flux texte : tu diminues le risque de générer du XML mal formé. Ca peut t'épargner bien des problèmes lorsque le fichier sera parsé ultérieurement...