Comment faire pour supprimer les lignes vides à partir du fichier XML?
En bref, j'ai beaucoup de lignes vides générés dans un fichier XML, et je suis à la recherche d'un moyen de les éliminer comme un moyen de se pencher le fichier. Comment puis-je le faire ?
Pour une explication détaillée; j'ai actuellement ce fichier XML :
<recent>
<paths>
<path>path1</path>
<path>path2</path>
<path>path3</path>
<path>path4</path>
</paths>
</recent>
Et j'utilise ce code Java pour supprimer toutes les balises, et en ajouter de nouveaux à la place :
public void savePaths( String recentFilePath ) {
ArrayList<String> newPaths = getNewRecentPaths();
Document recentDomObject = getXMLFile( recentFilePath ); //Get the <recent> element.
NodeList pathNodes = recentDomObject.getElementsByTagName( "path" ); //Get all <path> nodes.
//1. Remove all old path nodes :
for ( int i = pathNodes.getLength() - 1; i >= 0; i-- ) {
Element pathNode = (Element)pathNodes.item( i );
pathNode.getParentNode().removeChild( pathNode );
}
//2. Save all new paths :
Element pathsElement = (Element)recentDomObject.getElementsByTagName( "paths" ).item( 0 ); //Get the first <paths> node.
for( String newPath: newPaths ) {
Element newPathElement = recentDomObject.createElement( "path" );
newPathElement.setTextContent( newPath );
pathsElement.appendChild( newPathElement );
}
//3. Save the XML changes :
saveXMLFile( recentFilePath, recentDomObject );
}
Après l'exécution de cette méthode un certain nombre de fois, j'obtiens un fichier XML avec de bons résultats, mais avec de nombreuses lignes vides après les "chemins" de la balise et avant le premier "chemin" de la balise, comme ceci :
<recent>
<paths>
<path>path5</path>
<path>path6</path>
<path>path7</path>
</paths>
</recent>
Quelqu'un sait comment résoudre ce problème ?
------------------------------------------- Edit: Ajout de la getXMLFile(...), saveXMLFile(...) du code.
public Document getXMLFile( String filePath ) {
File xmlFile = new File( filePath );
try {
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
Document domObject = db.parse( xmlFile );
domObject.getDocumentElement().normalize();
return domObject;
} catch (Exception e) {
e.printStackTrace();
}
return null;
}
public void saveXMLFile( String filePath, Document domObject ) {
File xmlOutputFile = null;
FileOutputStream fos = null;
try {
xmlOutputFile = new File( filePath );
fos = new FileOutputStream( xmlOutputFile );
TransformerFactory transformerFactory = TransformerFactory.newInstance();
Transformer transformer = transformerFactory.newTransformer();
transformer.setOutputProperty( OutputKeys.INDENT, "yes" );
transformer.setOutputProperty( "{http://xml.apache.org/xslt}indent-amount", "2" );
DOMSource xmlSource = new DOMSource( domObject );
StreamResult xmlResult = new StreamResult( fos );
transformer.transform( xmlSource, xmlResult ); //Save the XML file.
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (TransformerConfigurationException e) {
e.printStackTrace();
} catch (TransformerException e) {
e.printStackTrace();
} finally {
if (fos != null)
try {
fos.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
Bien sûr, j'ai édité la question.
Vous pourriez avoir un coup d'oeil à la Suppression de Nœuds et les Lignes Vides dans XML à l'Aide de Java et stackoverflow.com/questions/7190639/...
OriginalL'auteur Brad | 2012-10-01
Vous devez vous connecter pour publier un commentaire.
D'abord, une explication de pourquoi cela se produit — ce qui pourrait être un peu hors sujet, puisque vous n'avez pas à inclure le code qui est utilisé pour charger le fichier XML dans un objet DOM.
Lorsque vous lisez un document XML à partir d'un fichier, les espaces entre les balises constituent en réalité valide les nœuds DOM, conformément à la spécification DOM. Par conséquent, l'analyseur XML traite chaque séquence d'espaces comme les nœuds DOM (de type
TEXT
);Pour se débarrasser d'elle, il y a trois approches que je peux penser:
Associer le XML avec un schéma, et ensuite utiliser
setValidating(true)
avecsetIgnoringElementContentWhitespace(true)
sur leDocumentBuilderFactory
.(Note:
setIgnoringElementContentWhitespace
ne fonctionnera que si l'analyseur est en mode de validation, qui est pourquoi vous devez utilisersetValidating(true)
)TEXT
nœuds.Utilisation de code Java pour ce faire: utiliser XPath pour trouver tous les espaces seule
TEXT
nœuds, parcourir et supprimer chacun de ses parents (à l'aide degetParentNode().removeChild()
). Quelque chose comme ceci ferait (doc
serait votre DOM document object):OK, je vais modifier ma réponse à inclure le code Java requis.
Une autre possibilité serait de définir un Schéma XML pour valider le document, puis utiliser DocumentBuilderFactory "setIgnoringElementContentWhitespace" en collaboration avec "setValidating". De nombreuses façons de la peau, ce chat.
Le code Java fonctionne parfaitement pour moi.
OriginalL'auteur Isaac
J'ai été en mesure de résoudre ce problème en utilisant ce code après la suppression de tous les anciens "chemin" nœuds :
Cela permettra d'éliminer tous les générées espaces vides dans le fichier XML.
Un merci spécial à MadProgrammer pour les commentaires avec le lien utile mentionnés ci-dessus.
Je suis d'accord avec vous, mais dans mon cas, je suis sûr qu'ils sont tous vides, parce que j'ai déjà supprimé moi-même. Au contraire, si il y a quelque chose qui manque et non supprimés, alors je veux l'enlever 🙂
veuillez vérifier ma réponse: goo.gl/06Qd9 , j'ai expliqué comment faire pour supprimer ces lignes vides sans aveugles enlever tous les nœuds enfants, et a écrit quelque chose sur la cause d'un tel comportement.
OriginalL'auteur Brad
Vous pourrait ressembler à quelque chose comme cette si vous avez seulement besoin de "nettoyer" votre xml rapidement.
Puis vous pourriez avoir une méthode comme:
Aussi, pour comparer anche vérifier les différences, si vous en avez besoin: XMLUnit
OriginalL'auteur mdm
J'ai été confrontée au même problème, et je n'avais aucune idée pour le temps, mais maintenant, après ce Brad et sa propre réponse à sa propre question, j'ai compris où est le problème.
J'ai ajouter ma propre réponse, parce que Brad n'est pas vraiment parfait, comment Isaac dit:
Donc, c'est mieux "solution" (cité car il est plus probable solution de contournement) est:
Cela supprime complètement inutile des lignes vides. Il est certainement mieux que l'élimination de tous les nœuds enfants. Brad, cela devrait fonctionner pour vous aussi.
Mais, c'est un effet, non une cause, et nous avons obtenu comment faire pour supprimer cet effet et non la cause.
Cause est: quand nous appelons
removeChild()
, il supprime cet enfant, mais il laisse tiret de l'enfant supprimé, et saut de ligne trop. Et ce indent_and_like_break est traité comme un texte de contenu.Donc, pour supprimer la cause, nous devrions comprendre comment faire pour supprimer à l'enfant et à son retrait. Bienvenue sur mon question à propos de cette.
OriginalL'auteur Dmitry Frank
Je suis à l'aide de code ci-dessous:
OriginalL'auteur Jlearner
Quelques remarques:
1) Lors de la manipulation de XML (suppression des éléments /ajout de nouveau) je conseil vivement de vous utiliser XSLT (et pas DOM)
2) Lorsque vous transformer un Document XML en XSLT (comme vous le faites dans votre méthode save), définissez la OutputKeys.TIRET à "no"
3) Pour une simple post-traitement de vos données xml (en supprimant les espaces blancs, les commentaires, etc.) vous pouvez utiliser un simple SAX2 filtre
OriginalL'auteur rmuller
OriginalL'auteur Tai Le
Il y a un moyen très simple de se débarrasser des lignes vides si à l'aide d'un DOM de la manipulation de l'API (par exemple DOM4J):
text
)node.setText("")
text
à l'aide denode.setText(text)
et le tour est joué! il n'y a plus des lignes vides. Les autres réponses délimiter très bien comment les extra lignes vides dans le fichier xml de sortie sont en fait des extra nœuds de type texte.
Cette technique peut être utilisée avec n'importe quel DOM l'analyse du système, tant que le nom de le texte est modifié pour l'adapter à celle de votre API, donc la façon de représenter un peu plus abstraite.
Espère que cela aide:)
OriginalL'auteur GMasucci