Java Supprimer vide balises XML

Je suis à la recherche d'un simple fragment de code Java pour supprimer les balises vides à partir d'une (de toute) la structure XML

<xml>
    <field1>bla</field1>
    <field2></field2>
    <field3/>
    <structure1>
       <field4>bla</field4>
       <field5></field5>
    </structure1>
</xml>

doit se transformer en;

<xml>
    <field1>bla</field1>
    <structure1>
       <field4>bla</field4>
    </structure1>
</xml>

Êtes-vous actuellement de l'analyse du XML dans des structures de données particulières (JDOM, etc)? Ou êtes-vous commencer à partir de zéro?
Faute de frappe dans l'exemple XML: structure1 n'est pas correctement fermé

InformationsquelleAutor Raymond | 2009-11-06

Je me demandais si il serait facile de le faire avec le XOM bibliothèque et donné un essai.

Il s'est avéré pour être assez facile:

import nu.xom.*;

import java.io.File;
import java.io.IOException;

public class RemoveEmptyTags {

    public static void main(String[] args) throws IOException, ParsingException {
        Document document = new Builder().build(new File("original.xml"));
        handleNode(document.getRootElement());
        System.out.println(document.toXML()); //empty elements now removed
    }

    private static void handleNode(Node node) {
        if (node.getChildCount() == 0 && "".equals(node.getValue())) {
            node.getParent().removeChild(node);
            return;
        }
        //recurse the children
        for (int i = 0; i < node.getChildCount(); i++) { 
            handleNode(node.getChild(i));
        }
    }
}

Ce ne sera probablement pas gérer tous les cas de coin correctement, comme un tout document vide. Et que faire au sujet des éléments qui sont vides, mais avoir des attributs?

Si vous souhaitez enregistrer les balises XML avec des attributs, nous pouvons ajouter dans la méthode 'handleNode' à cocher suivantes:

... && ((Element) node).getAttributeCount() == 0) )

Aussi, si le document xml possède deux ou plusieurs balises vides, l'un après l'autre; cette méthode récursive permet de ne pas supprimer toutes les balises vides!

(Cette réponse est une partie de mon évaluation de XOM comme un potentiel remplacement de dom4j.)

Merci, je vais utiliser cette

InformationsquelleAutor Jonik

8

Cette feuille de style XSLT devriez faire ce que vous êtes à la recherche pour:
```
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:template match="@*|node()">
    <xsl:if test=". != '' or ./@* != ''">
      <xsl:copy>
        <xsl:apply-templates select="@*|node()"/>
      </xsl:copy>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>
```
Il devrait aussi préserver les éléments qui sont vides, mais ont des attributs qui ne le sont pas. Si vous ne voulez pas ce comportement, puis changement:

<xsl:if test=". != '' or ./@* != ''">

À: <xsl:if test=". != ''">

Si vous souhaitez savoir comment l'utiliser XSLT en Java, il devrait y avoir beaucoup de tutoriels sur les Interwebs. Bonne chance!
- +1 pour XSLT solution
InformationsquelleAutor Chris R
3

Comme une note de côté: Les différents états d'une balise en fait ont un sens:
- Ouvert-Fermé Tag: L'élément existe et que sa valeur est une chaîne vide
- Une seule Balise: L'élément existe, mais la valeur est null ou nil
- Manquant Tag: L'élément n'existe pas
Donc, par la suppression des vide Ouvert-Fermé les balises et Unique Balises, vous êtes à la fusion avec le groupe de balises manquantes et donc de perdre de l'information.
- Très bon point - il y a des moments où il est utile pour enlever les balises dont la valeur est vide ou nulle, mais il y a aussi des moments où cela pourrait potentiellement nuire à l'application.
- Pour mon but, c'est sans importance
InformationsquelleAutor mhaller

J'ai testé Jonik et Marco exemples de codes. Mais ceux qui ne sont pas exactement ce que je veux. J'ai donc modifié leur source et de code ci-dessous fonctionne bien pour moi. J'ai déjà régler ce code dans mon projet. merci de le tester, si vous le souhaitez.

public String removeEmptyNode(String xml){
    String cleanedXml = null;
    try{
        xml = "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\r\n" + xml;
        InputStream input = new ByteArrayInputStream(xml.getBytes("UTF-8"));
        Document document = new Builder().build(input);
        removeEmptyNode(document.getRootElement());
        cleanedXml = document.toXML();
    }catch(Exception e){
        e.printStackTrace();
    }
    return cleanedXml;
}

private static void removeEmptyNode(Node node) {
    if(node.getChildCount()!=0){
        int count = node.getChildCount();
        for (int i = count-1; i >= 0 ; i--) { 
            removeEmptyNode(node.getChild(i));
        }
    }

    doCheck(node);
}

private static void doCheck(Node node){
    if(node.getChildCount() == 0 && "".equals(node.getValue().trim())) {
        try{node.getParent().removeChild(node);}catch(Exception e){}
    }       
}

InformationsquelleAutor Sam

1

Si le xml est l'aliment sous forme de Chaîne; regex peut être utilisé pour filtrer les éléments vides:
```
<(\\w+)></\>|<\\w+/>
```
Cela permettra de trouver des éléments vides.
```
data.replaceAll(re, "")
```
de données dans ce cas, une variable contenant votre chaîne xml.

Ne pas dire ce qui serait la meilleure des solutions, mais c'est possible...

InformationsquelleAutor Kennet

J'ai besoin d'ajouter de strip-l'espace et le tiret éléments de Chris R de réponse, sinon renfermant des blocs, nouvellement vide, ne sont pas supprimés:

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
  <xsl:strip-space elements="*"/>
  <xsl:output indent="yes" />
  <xsl:template match="@*|node()">
    <xsl:if test=". != '' or ./@* != ''">
      <xsl:copy>
        <xsl:apply-templates  select="@*|node()"/>
      </xsl:copy>
    </xsl:if>
  </xsl:template>
</xsl:stylesheet>

InformationsquelleAutor TimP

0

Avec XSLT vous pourriez transformer votre XML à ignorer les balises vides et ré-écrire le document.

InformationsquelleAutor Alex

Pour supprimer toutes les balises vides, même si elles sont l'un après l'autre, une solution possible est:

 private void removeEmptyTags(Document document) {
    List<Node> listNode = new ArrayList<Node>();
    findListEmptyTags(document.getRootElement(), listNode);
    if (listNode.size() == 0)
        return;

    for (Node node : listNode) {
        node.getParent().removeChild(node);
    }
    removeEmptyTags(document);
}

private void findListEmptyTags(Node node, List<Node> listNode) {

    if (node != null && node.getChildCount() == 0 && "".equals(node.getValue()) && ((Element) node).getAttributeCount() == 0) {
        listNode.add(node);
        return;
    }
    //recurse the children
    for (int i = 0; i < node.getChildCount(); i++) {
        findListEmptyTags(node.getChild(i), listNode);
    }
}

InformationsquelleAutor Luigi

public static void main(String[] args) {

    final String regex1 = "<([a-zA-Z0-9-\\_]*)[^>]*/>";
    final String regex2 = "<([a-zA-Z0-9-\\_]*)[^>]*>\\s*</\>";

    String xmlString = "<xml><field1>bla</field1><field2></field2><field3/><structure1><field4><field50><field50/></field50></field4><field5></field5></structure1></xml>";
    System.out.println(xmlString);

    final Pattern pattern1 = Pattern.compile(regex1);
    final Pattern pattern2 = Pattern.compile(regex2);

    Matcher matcher1;
    Matcher matcher2;
    do { 
        xmlString = xmlString.replaceAll(regex1, "").replaceAll(regex2, "");
        matcher1 = pattern1.matcher(xmlString);
        matcher2 = pattern2.matcher(xmlString);
    } while (matcher1.find() || matcher2.find());

    System.out.println(xmlString);
}

Console:

<xml>
    <field1>bla</field1>
    <field2></field2>
    <field3/>
    <structure1>
        <field4>
            <field50>
                <field60/>
            </field50>
        </field4>
        <field5></field5>
    </structure1>
</xml>

<xml>
    <field1>bla</field1>
</xml>

Démo en ligne ici

InformationsquelleAutor sgrillon

Vous devez vous connecter pour publier un commentaire.