Meilleure façon d'analyser une chaîne XML en Java?

Question

Je suis en train d'analyser une chaîne Java en utilisant javax.xml.parsers.DocumentBuilder. Cependant, il n'y a pas une fonction pour analyser une chaîne directement fait, donc je suis plutôt ceci:

public static Document parseText(String zText) { 
    try 
    { 
     DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance(); 
     DocumentBuilder dBuilder = dbFactory.newDocumentBuilder(); 
     Document doc = dBuilder.parse(new InputSource(new StringReader(zText))); 
     doc.getDocumentElement().normalize(); 
     return doc; 
    } 
    catch (Exception e) { 
      e.printStackTrace(); 
    } 
    return null; 
} 

Est-ce la meilleure façon de le faire? J'ai l'impression qu'il doit y avoir un moyen plus simple ... merci!

Answer 1

Pour répondre à votre question directement - à ma connaissance, il n'y a pas de meilleur moyen. La source d'entrée est utilisée parce qu'elle est plus universelle et peut gérer l'entrée d'un fichier, une chaîne ou à travers le fil est ma compréhension. Vous pouvez également utiliser l'analyseur syntaxique SAX Xml - il est un peu plus basique et utilise le modèle Visitor, mais il accomplit son travail et pour les ensembles de données plus petits et les schémas XML simples, il est assez facile à utiliser. SAX est également inclus avec le noyau JRE.

Answer 2

Je préfère personnellement dom4j. Découvrez leur démarrage rapide, c'est assez simple.

Answer 3

Je ne voudrais pas normaliser si je suis pressé ou si je m'en fous. Vous pourriez normaliser juste les noeuds quand vous avez besoin.

Answer 4

Je suis d'accord avec aperkins et voici mon aide javax:

/** 
* Returns a {@code Document} from the specified XML {@code String}. 
* 
* @param xmlDocumentString a well-formed XML {@code String} 
* @return a {@code org.w3c.dom.Document} 
*/ 
public static Document getDomDocument(String xmlDocumentString) 
{ 
    if(StringUtility.isNullOrEmpty(xmlDocumentString)) return null; 

    InputStream s = null; 

    try 
    { 
     s = new ByteArrayInputStream(xmlDocumentString.getBytes("UTF-8")); 
    } 
    catch(UnsupportedEncodingException e) 
    { 
     throw new RuntimeException("UnsupportedEncodingException: " + e.getMessage()); 
    } 

    return XmlDomUtility.getDomDocument(s); 
} 

Cette aide dépend autre:

/** 
* Returns a {@code Document} from the specified {@code InputStream}. 
* 
* @param input the {@code java.io.InputStream} 
* @return a {@code org.w3c.dom.Document} 
*/ 
public static Document getDomDocument(InputStream input) 
{ 
    Document document = null; 
    try 
    { 
     DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); 
     factory.setNamespaceAware(true); 
     DocumentBuilder builder = factory.newDocumentBuilder(); 
     document = builder.parse(input); 
    } 
    catch(ParserConfigurationException e) 
    { 
     throw new RuntimeException("ParserConfigurationException: " + e.getMessage()); 
    } 
    catch(SAXException e) 
    { 
     throw new RuntimeException("SAXException: " + e.getMessage()); 
    } 
    catch(IOException e) 
    { 
     throw new RuntimeException("IOException: " + e.getMessage()); 
    } 

    return document; 
} 

Mise à jour: ce sont mes importations:

import java.io.ByteArrayInputStream; 
import java.io.File; 
import java.io.IOException; 
import java.io.InputStream; 
import java.io.UnsupportedEncodingException; 

import javax.xml.parsers.DocumentBuilder; 
import javax.xml.parsers.DocumentBuilderFactory; 
import javax.xml.parsers.ParserConfigurationException; 

import org.w3c.dom.Document; 
import org.w3c.dom.Node; 
import org.xml.sax.SAXException; 

Answer 5

Une autre option que vous pourriez essayer est Castor, je pense que cela rend les choses tellement plus simple:

http://www.castor.org/