¿Cómo recuperar el valor del elemento de XML utilizando Java?

Soy nuevo en XML. Quiero leer el siguiente XML en función del nombre de la solicitud. Por favor, ayúdenme sobre cómo leer el siguiente XML en Java –

   emailrequest emailresponse   Cleanrequest Cleanresponse   

Si su XML es una Cadena, entonces puede hacer lo siguiente:

 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(); 

Si su XML está en un archivo, el Document document creará una instancia como esta:

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

document.getDocumentElement() devuelve el nodo que es el elemento de documento del documento (en su caso, ).

Una vez que tiene un rootElement , puede acceder al atributo del elemento (llamando rootElement.getAttribute() método rootElement.getAttribute() ), etc. Para obtener más métodos en org.w3c.dom.Element de java

Más información sobre java DocumentBuilder & DocumentBuilderFactory . Tenga en cuenta que el ejemplo proporcionado crea un árbol DOM XML, por lo que si tiene una gran cantidad de datos XML, el árbol puede ser enorme.

  • Pregunta relacionada

Actualizar Aquí hay un ejemplo para obtener el “valor” del 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; } 

Puedes llamarlo efectivamente como,

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

Si solo busca obtener un valor único del XML, es posible que desee utilizar la biblioteca XPath de Java. Por ejemplo, ver mi respuesta a una pregunta anterior:

  • Cómo usar XPath en documentos xml con espacio de nombres predeterminado

Se vería algo así como:

 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(); } } } 

En caso de que solo necesite un (primer) valor para recuperar de xml:

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

En caso de que quiera analizar el documento xml completo, use JSoup:

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

Hay varias formas diferentes de hacer esto. Es posible que desee comprobar XStream o JAXB . Hay tutoriales y ejemplos.

Hay dos formas generales de hacerlo. Creará un Modelo de objetos de dominio de ese archivo XML, eche un vistazo a este

y la segunda opción es utilizar un análisis sintáctico basado en eventos, que es una alternativa a la representación DOM xml. Aquí puedes encontrar la mejor comparación general de estas dos técnicas básicas. Por supuesto, hay mucho más que aprender sobre el procesamiento de xml, por ejemplo, si se le da una definición de esquema XML (XSD), puede usar JAXB .

Hay varias API disponibles para leer / escribir archivos XML a través de Java. Me refiero usando StaX

También esto puede ser útil: API XML de Java

Puede crear una clase que extienda org.xml.sax.helpers.DefaultHandler y llame

 start_(Attributes attrs); 

y

 end_(); 

Para ello es:

 start_request_queue(attrs); 

etc.

Y luego amplía esa clase e implementa los analizadores de archivos de configuración xml que desee. Ejemplo:

   ...
   public void startElement (String uri, String name, String qname,
                            org.xml.sax.Attributes attrs) 
                   throws org.xml.sax.SAXException {
     Clase [] args = new Class [2];
     args [0] = uri.getClass ();
     args [1] = org.xml.sax.Attributes.class;
     tratar {
       String mname = name.replace ("-", " "); 
        java.lang.reflect.Method m =  
              getClass (). getDeclaredMethod ("start " + mname, args);
       m.invoke (este, nuevo Object [] {uri, (org.xml.sax.Attributes) attrs}); 
     } 
catch (IllegalAccessException e) { lanzar nueva RuntimeException (e); }
catch (NoSuchMethodException e) { lanzar nueva RuntimeException (e); }
catch (java.lang.reflect.InvocationTargetException e) { org.xml.sax.SAXException se = nueva org.xml.sax.SAXException (e.getTargetException ()); se.setStackTrace (e.getTargetException (). getStackTrace ()); }

y en un analizador de configuración particular:

    public void start_Request (String uri, org.xml.sax.Attributes attrs) {
      // asegúrese de leer los atributos correctamente
      System.err.println ("Solicitud, nombre =" + attrs.getValue (0);
    }

Como está utilizando esto para la configuración, su mejor opción es la configuración de Apache commons . Para archivos simples, es mucho más fácil de usar que los analizadores XML “en bruto”.

Vea el cómo hacer XML