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