Come recuperare il valore dell’elemento di XML utilizzando Java?

Sono nuovo di XML. Voglio leggere il seguente XML sulla base del nome della richiesta. Per favore aiutami su come leggere il sotto XML in Java –

   emailrequest emailresponse   Cleanrequest Cleanresponse   

Se il tuo XML è una stringa, puoi fare quanto segue:

 String xml = ""; //Populated XML String.... DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance(); DocumentBuilder builder = factory.newDocumentBuilder(); Document document = builder.parse(new InputSource(new StringReader(xml))); Element rootElement = document.getDocumentElement(); 

Se il tuo XML è in un file, il Document document sarà istanziato come questo:

 Document document = builder.parse(new File("file.xml")); 

document.getDocumentElement() restituisce il nodo che è l’elemento del documento del documento (nel tuo caso ).

Una volta che hai un rootElement , puoi accedere all’attributo dell’elemento (chiamando il metodo rootElement.getAttribute() ), ecc. Per ulteriori metodi su org.w3c.dom.Element di java

Maggiori informazioni su java DocumentBuilder e DocumentBuilderFactory . Tenete a mente , l’esempio fornito crea un albero DOM XML, quindi se avete un enorme dato XML, l’albero può essere enorme.

  • Domanda correlata

Aggiorna Ecco un esempio per ottenere il “valore” dell’elemento

 protected String getString(String tagName, Element element) { NodeList list = element.getElementsByTagName(tagName); if (list != null && list.getLength() > 0) { NodeList subList = list.item(0).getChildNodes(); if (subList != null && subList.getLength() > 0) { return subList.item(0).getNodeValue(); } } return null; } 

Puoi chiamarlo efficacemente come,

 String requestQueueName = getString("requestqueue", element); 

Se stai cercando di ottenere un singolo valore dall’XML potresti voler usare la libreria XPath di Java. Per un esempio vedi la mia risposta a una domanda precedente:

  • Come utilizzare XPath su documenti xml con spazio dei nomi predefinito

Assomiglierebbe a qualcosa:

 import javax.xml.parsers.DocumentBuilder; import javax.xml.parsers.DocumentBuilderFactory; import javax.xml.xpath.XPath; import javax.xml.xpath.XPathConstants; import javax.xml.xpath.XPathFactory; import org.w3c.dom.Document; import org.w3c.dom.NodeList; public class Demo { public static void main(String[] args) { DocumentBuilderFactory domFactory = DocumentBuilderFactory.newInstance(); try { DocumentBuilder builder = domFactory.newDocumentBuilder(); Document dDoc = builder.parse("E:/test.xml"); XPath xPath = XPathFactory.newInstance().newXPath(); Node node = (Node) xPath.evaluate("/Request/@name", dDoc, XPathConstants.NODE); System.out.println(node.getNodeValue()); } catch (Exception e) { e.printStackTrace(); } } } 

Nel caso in cui hai solo bisogno di un (primo) valore da recuperare da xml:

 public static String getTagValue(String xml, String tagName){ return xml.split("< "+tagName+">")[1].split("")[0]; } 

Nel caso in cui si desideri analizzare l’intero documento xml, utilizzare JSoup:

 Document doc = Jsoup.parse(xml, "", Parser.xmlParser()); for (Element e : doc.select("Request")) { System.out.println(e); } 

Ci sono diversi modi per farlo. Potresti voler controllare XStream o JAXB . Ci sono tutorial e gli esempi.

Ci sono due modi generali per farlo. Creerai un modello a oggetti di dominio di quel file XML, dai un’occhiata a questo

e la seconda scelta consiste nell’utilizzare l’analisi guidata dagli eventi, che è un’alternativa alla rappresentazione DOM xml. Qui puoi trovare il miglior confronto generale tra queste due tecniche di base. Naturalmente ci sono molte altre informazioni sull’elaborazione di XML, ad esempio se viene fornita la definizione dello schema XML (XSD), è ansible utilizzare JAXB .

Sono disponibili varie API per leggere / scrivere file XML tramite Java. Mi riferirei usando Stax

Anche questo può essere utile – API Java XML

Puoi creare una class che estenda org.xml.sax.helpers.DefaultHandler e chiama

 start_(Attributes attrs); 

e

 end_(); 

Perché è:

 start_request_queue(attrs); 

eccetera.

E poi estende quella class e implementa i parser di file di configurazione xml che vuoi. Esempio:

   ...
   public void startElement (String uri, String name, String qname,
                            org.xml.sax.Attributes attrs) 
                   lancia org.xml.sax.SAXException {
     Classe [] args = new Class [2];
     args [0] = uri.getClass ();
     args [1] = org.xml.sax.Attributes.class;
     provare {
       String mname = name.replace ("-", " "); 
        java.lang.reflect.Method m =  
              getClass (). getDeclaredMethod ("start " + mname, args);
       m.invoke (this, new Object [] {uri, (org.xml.sax.Attributes) attrs}); 
     } 
catch (IllegalAccessException e) { lanciare la nuova RuntimeException (e); }
catch (NoSuchMethodException e) { lanciare la nuova RuntimeException (e); }
catch (java.lang.reflect.InvocationTargetException e) { org.xml.sax.SAXException se = nuovo org.xml.sax.SAXException (e.getTargetException ()); se.setStackTrace (e.getTargetException () getStackTrace ().); }

e in un particolare parser di configurazione:

    public void start_Request (String uri, org.xml.sax.Attributes attrs) {
      // assicurati di leggere gli attributi correttamente
      System.err.println ("Request, name =" + attrs.getValue (0);
    }

Dal momento che stai usando questo per la configurazione, la soluzione migliore è la configurazione di Apache Commons . Per i file semplici è molto più semplice da usare rispetto ai parser XML “grezzi”.

Guarda l’ how-to XML