Cómo leer XML usando XPath en Java

Quiero leer datos XML usando XPath en Java, por lo que la información que he recogido yo no soy capaz de analizar XML de acuerdo a mi necesidad.

aquí es lo que quiero hacer:

Recibir un archivo XML de en línea a través de su URL, a continuación, utilizar XPath para analizarlo, quiero crear dos métodos en ella. Uno es en el que entro en un nodo determinado atributo id, y tengo todos los nodos secundarios como resultado, y en segundo lugar, supongamos que yo quiero a un niño específico valor del nodo sólo

<?xml version="1.0"?>
<howto>
  <topic name="Java">
      <url>http://www.rgagnonjavahowto.htm</url>
  <car>taxi</car>
  </topic>
  <topic name="PowerBuilder">
       <url>http://www.rgagnon/pbhowto.htm</url>
       <url>http://www.rgagnon/pbhowtonew.htm</url>
  </topic>
  <topic name="Javascript">
        <url>http://www.rgagnon/jshowto.htm</url>
  </topic>
 <topic name="VBScript">
       <url>http://www.rgagnon/vbshowto.htm</url>
 </topic>
 </howto>

En el ejemplo de arriba quiero leer todos los elementos si puedo buscar a través de @nombre y también una función en la que sólo quiero la url de @nombre de ‘Javascript’ sólo devolver un nodo elemento.

  • Este enlace se da una clara demostración de leer xml con xpath
InformationsquelleAutor kaibuki | 2010-05-11

8 Kommentare

  1. 386

    Necesita algo a lo largo de las líneas de este:

    DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
    DocumentBuilder builder = factory.newDocumentBuilder();
    Document doc = builder.parse(<uri_as_string>);
    XPathFactory xPathfactory = XPathFactory.newInstance();
    XPath xpath = xPathfactory.newXPath();
    XPathExpression expr = xpath.compile(<xpath_expression>);

    A continuación, llamar expr.evaluate() pasando en el documento se define en el código y el tipo de retorno que esperan, y arrojó el resultado para el tipo de objeto del resultado.

    Si usted necesita ayuda con un expresiones XPath, usted probablemente debería pedir como cuestiones separadas (a menos que esa era tu pregunta, en primer lugar, aquí – entendí su pregunta es que cómo utilizar la API de Java).

    Edición: (Respuesta al comentario): Esta expresión XPath conseguirá que el texto de la primera dirección URL del elemento bajo PowerBuilder:

    /howto/topic[@name='PowerBuilder']/url/text()

    De esta manera se consigue que el segundo:

    /howto/topic[@name='PowerBuilder']/url[2]/text()

    Consigue que con este código:

    expr.evaluate(doc, XPathConstants.STRING);

    Si usted no sabe cómo muchas direcciones Url están en un nodo dado, entonces usted debe más bien a hacer algo como esto:

    XPathExpression expr = xpath.compile("/howto/topic[@name='PowerBuilder']/url");
    NodeList nl = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);

    Y, a continuación, recorrer la lista de nodos.

    • Gracias Yishai, tengo clara mi pregunta, si quiero llegar a un valor determinado de nodos hijos de un nodo padre. la forma en que se puede hacer? gracias
    • es posible conseguir todos los temas, independientemente del nombre. Quiero saber si es posible utilizar un comodín o similares para el @nombre y, a continuación, recorrer todos los nodos de comparar el nombre con un valor real
    • suena como que usted está pasado el uso de XPath y la necesidad de utilizar un paseo a través del analizador de XML como Nodos y Elementos, pero te sugiero que puedes elaborar en una nueva pregunta.
    • más de la fábrica generador de compuestos plz.
    • Sí nt trabajar con xpath que es tener prefijos de espacio de nombres.
    • Las fábricas, y los constructores, y el generador de fábricas, oh mi!

  2. 30

    Que usted puede probar esto.

    Documento XML

    Guardar como employees.xml.

    <?xml version="1.0" encoding="UTF-8"?>
    <Employees>
        <Employee id="1">
            <age>29</age>
            <name>Pankaj</name>
            <gender>Male</gender>
            <role>Java Developer</role>
        </Employee>
        <Employee id="2">
            <age>35</age>
            <name>Lisa</name>
            <gender>Female</gender>
            <role>CEO</role>
        </Employee>
        <Employee id="3">
            <age>40</age>
            <name>Tom</name>
            <gender>Male</gender>
            <role>Manager</role>
        </Employee>
        <Employee id="4">
            <age>25</age>
            <name>Meghan</name>
            <gender>Female</gender>
            <role>Manager</role>
        </Employee>
    </Employees>

    Analizador de clase

    La clase tiene los siguientes métodos

    • Elemento de la lista
    • Un Método que devolverá el Nombre del Empleado para el ID de entrada.
    • Un Método que devolverá la lista de los Empleados de Nombre con la edad mayor que la de entrada edad.
    • Un Método que devolverá la lista de las trabajadoras Nombre.

    Código Fuente

    import java.io.IOException;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    import javax.xml.parsers.ParserConfigurationException;
    import javax.xml.xpath.XPath;
    import javax.xml.xpath.XPathConstants;
    import javax.xml.xpath.XPathExpression;
    import javax.xml.xpath.XPathExpressionException;
    import javax.xml.xpath.XPathFactory;
    
    import org.w3c.dom.Document;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    
    
    public class Parser {
    
        public static void main(String[] args) {
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            factory.setNamespaceAware(true);
            DocumentBuilder builder;
            Document doc = null;
            try {
                builder = factory.newDocumentBuilder();
                doc = builder.parse("employees.xml");
    
                //Create XPathFactory object
                XPathFactory xpathFactory = XPathFactory.newInstance();
    
                //Create XPath object
                XPath xpath = xpathFactory.newXPath();
    
                String name = getEmployeeNameById(doc, xpath, 4);
                System.out.println("Employee Name with ID 4: " + name);
    
                List<String> names = getEmployeeNameWithAge(doc, xpath, 30);
                System.out.println("Employees with 'age>30' are:" + Arrays.toString(names.toArray()));
    
                List<String> femaleEmps = getFemaleEmployeesName(doc, xpath);
                System.out.println("Female Employees names are:" +
                        Arrays.toString(femaleEmps.toArray()));
    
            } catch (ParserConfigurationException | SAXException | IOException e) {
                e.printStackTrace();
            }
    
        }
    
    
        private static List<String> getFemaleEmployeesName(Document doc, XPath xpath) {
            List<String> list = new ArrayList<>();
            try {
                //create XPathExpression object
                XPathExpression expr =
                    xpath.compile("/Employees/Employee[gender='Female']/name/text()");
                //evaluate expression result on XML document
                NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
                for (int i = 0; i < nodes.getLength(); i++)
                    list.add(nodes.item(i).getNodeValue());
            } catch (XPathExpressionException e) {
                e.printStackTrace();
            }
            return list;
        }
    
    
        private static List<String> getEmployeeNameWithAge(Document doc, XPath xpath, int age) {
            List<String> list = new ArrayList<>();
            try {
                XPathExpression expr =
                    xpath.compile("/Employees/Employee[age>" + age + "]/name/text()");
                NodeList nodes = (NodeList) expr.evaluate(doc, XPathConstants.NODESET);
                for (int i = 0; i < nodes.getLength(); i++)
                    list.add(nodes.item(i).getNodeValue());
            } catch (XPathExpressionException e) {
                e.printStackTrace();
            }
            return list;
        }
    
    
        private static String getEmployeeNameById(Document doc, XPath xpath, int id) {
            String name = null;
            try {
                XPathExpression expr =
                    xpath.compile("/Employees/Employee[@id='" + id + "']/name/text()");
                name = (String) expr.evaluate(doc, XPathConstants.STRING);
            } catch (XPathExpressionException e) {
                e.printStackTrace();
            }
    
            return name;
        }
    
    }
    • +1, pero veo algo de redundancia en su get métodos. Sólo el XPath de la cadena de los cambios y la mayor parte de el resto de el código sigue siendo el mismo. Tal vez, una sola getValuesForXpath() el método es suficiente.
  3. 21

    Introducción ejemplo:

    archivo xml:

    <inventory>
        <book year="2000">
            <title>Snow Crash</title>
            <author>Neal Stephenson</author>
            <publisher>Spectra</publisher>
            <isbn>0553380958</isbn>
            <price>14.95</price>
        </book>
    
        <book year="2005">
            <title>Burning Tower</title>
            <author>Larry Niven</author>
            <author>Jerry Pournelle</author>
            <publisher>Pocket</publisher>
            <isbn>0743416910</isbn>
            <price>5.99</price>
        </book>
    
        <book year="1995">
            <title>Zodiac</title>
            <author>Neal Stephenson</author>
            <publisher>Spectra</publisher>
            <isbn>0553573862</isbn>
            <price>7.50</price>
        </book>
    
        <!-- more books... -->
    
    </inventory>

    Código Java:

    import javax.xml.parsers.DocumentBuilder;
    import javax.xml.parsers.DocumentBuilderFactory;
    
    import org.testng.annotations.DataProvider;
    import org.testng.annotations.Test;
    import org.w3c.dom.Document;
    import org.w3c.dom.Element;
    import org.w3c.dom.Node;
    import org.w3c.dom.NodeList;
    import org.xml.sax.SAXException;
    import org.xml.sax.SAXParseException;
    
    
    try {
    
        DocumentBuilderFactory docBuilderFactory = DocumentBuilderFactory.newInstance();
        DocumentBuilder docBuilder = docBuilderFactory.newDocumentBuilder();
        Document doc = docBuilder.parse (new File("c:\\tmp\\my.xml"));
    
        //normalize text representation
        doc.getDocumentElement().normalize();
        System.out.println ("Root element of the doc is " + doc.getDocumentElement().getNodeName());
    
        NodeList listOfBooks = doc.getElementsByTagName("book");
        int totalBooks = listOfBooks.getLength();
        System.out.println("Total no of books : " + totalBooks);
    
        for(int i=0; i<listOfBooks.getLength() ; i++) {
    
            Node firstBookNode = listOfBooks.item(i);
            if(firstBookNode.getNodeType() == Node.ELEMENT_NODE) {
    
                Element firstElement = (Element)firstBookNode;                              
                System.out.println("Year :"+firstElement.getAttribute("year"));
    
                //-------
                NodeList firstNameList = firstElement.getElementsByTagName("title");
                Element firstNameElement = (Element)firstNameList.item(0);
    
                NodeList textFNList = firstNameElement.getChildNodes();
                System.out.println("title : " + ((Node)textFNList.item(0)).getNodeValue().trim());
            }
        }//end of for loop with s var
    } catch (SAXParseException err) {
        System.out.println ("** Parsing error" + ", line " + err.getLineNumber () + ", uri " + err.getSystemId ());
        System.out.println(" " + err.getMessage ());
    } catch (SAXException e) {
        Exception x = e.getException ();
        ((x == null) ? e : x).printStackTrace ();
    } catch (Throwable t) {
        t.printStackTrace ();
    }                
    • también puede probar este howtodoinjava.com/2013/07/30/…
    • Esto responde a la pregunta, pero sin el uso de XPath, que se solicita explícitamente.
    • Depende de los requisitos. Como por ejemplo esta, si es necesario para obtener el grupo de nodos en lugar de a la específica, a continuación, esta respuesta es mejor.
  4. 6

    Aquí es un ejemplo de procesamiento de xpath con etv-xml… para trabajo pesado de procesamiento de XML es segundo a ninguno. aquí es el de un artículo reciente sobre este tema El procesamiento de XML con Java – Una comparativa del Rendimiento de

    import com.ximpleware.*;
    
    public class changeAttrVal {
        public  static  void main(String s[]) throws VTDException,java.io.UnsupportedEncodingException,java.io.IOException{
            VTDGen vg = new VTDGen();
            if (!vg.parseFile("input.xml", false))
                return;
            VTDNav vn = vg.getNav();
            AutoPilot ap = new AutoPilot(vn);
            XMLModifier xm = new XMLModifier(vn);
            ap.selectXPath("/*/place[@id=\"p14\" and   @initialMarking=\"2\"]/@initialMarking");
            int i=0;
            while((i=ap.evalXPath())!=-1){
                xm.updateToken(i+1, "499");//change initial marking from 2 to 499
            }
            xm.output("new.xml");
        }
    
    }
  5. 1

    Esto muestra cómo

    1. Leer en un archivo XML de un DOM
    2. Filtrar un conjunto de Nodes con XPath
    3. Realizar una determinada acción en cada uno de los extraídos Nodes.

    Vamos a llamar el código con la siguiente declaración

    processFilteredXml(xmlIn, xpathExpr,(node) -> {/*Do something...*/;});

    En nuestro caso queremos imprimir algunos creatorNames de un book.xml utilizando "//book/creators/creator/creatorName" como xpath para realizar un printNode acción en cada Nodo que coincide con la XPath.

    Código completo

    @Test
    public void printXml() {
        try (InputStream in = readFile("book.xml")) {
            processFilteredXml(in, "//book/creators/creator/creatorName", (node) -> {
                printNode(node, System.out);
            });
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    private InputStream readFile(String yourSampleFile) {
        return Thread.currentThread().getContextClassLoader().getResourceAsStream(yourSampleFile);
    }
    
    private void processFilteredXml(InputStream in, String xpath, Consumer<Node> process) {
        Document doc = readXml(in);
        NodeList list = filterNodesByXPath(doc, xpath);
        for (int i = 0; i < list.getLength(); i++) {
            Node node = list.item(i);
            process.accept(node);
        }
    }
    
    public Document readXml(InputStream xmlin) {
        try {
            DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
            DocumentBuilder db = dbf.newDocumentBuilder();
            return db.parse(xmlin);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    private NodeList filterNodesByXPath(Document doc, String xpathExpr) {
        try {
            XPathFactory xPathFactory = XPathFactory.newInstance();
            XPath xpath = xPathFactory.newXPath();
            XPathExpression expr = xpath.compile(xpathExpr);
            Object eval = expr.evaluate(doc, XPathConstants.NODESET);
            return (NodeList) eval;
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
    
    private void printNode(Node node, PrintStream out) {
        try {
            Transformer transformer = TransformerFactory.newInstance().newTransformer();
            transformer.setOutputProperty(OutputKeys.INDENT, "yes");
            transformer.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
            transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", "2");
            StreamResult result = new StreamResult(new StringWriter());
            DOMSource source = new DOMSource(node);
            transformer.transform(source, result);
            String xmlString = result.getWriter().toString();
            out.println(xmlString);
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }

    Imprime

    <creatorName>Fosmire, Michael</creatorName>
    
    <creatorName>Wertz, Ruth</creatorName>
    
    <creatorName>Purzer, Senay</creatorName>

    Para book.xml

    <book>
      <creators>
        <creator>
          <creatorName>Fosmire, Michael</creatorName>
          <givenName>Michael</givenName>
          <familyName>Fosmire</familyName>
        </creator>
        <creator>
          <creatorName>Wertz, Ruth</creatorName>
          <givenName>Ruth</givenName>
          <familyName>Wertz</familyName>
        </creator>
        <creator>
          <creatorName>Purzer, Senay</creatorName>
           <givenName>Senay</givenName>
           <familyName>Purzer</familyName>
        </creator>
      </creators>
      <titles>
        <title>Critical Engineering Literacy Test (CELT)</title>
      </titles>
    </book>
  6. 0

    Ampliando la excelente respuesta por parte de @azulado y @Yishai, aquí está la manera de hacer las listas de nodos como y atributos de nodo de soporte de los iteradores, es decir, el for(Node n: nodelist) interfaz.

    Utilizar como:

    NodeList nl = ...
    for(Node n : XmlUtil.asList(nl))
    {...}

    y

    Node n = ...
    for(Node attr : XmlUtil.asList(n.getAttributes())
    {...}

    El código:

    /**
     * Converts NodeList to an iterable construct.
     * From: https://stackoverflow.com/a/19591302/779521
     */
    public final class XmlUtil {
        private XmlUtil() {}
    
        public static List<Node> asList(NodeList n) {
            return n.getLength() == 0 ? Collections.<Node>emptyList() : new NodeListWrapper(n);
        }
    
        static final class NodeListWrapper extends AbstractList<Node> implements RandomAccess {
            private final NodeList list;
    
            NodeListWrapper(NodeList l) {
                this.list = l;
            }
    
            public Node get(int index) {
                return this.list.item(index);
            }
    
            public int size() {
                return this.list.getLength();
            }
        }
    
        public static List<Node> asList(NamedNodeMap n) {
            return n.getLength() == 0 ? Collections.<Node>emptyList() : new NodeMapWrapper(n);
        }
    
        static final class NodeMapWrapper extends AbstractList<Node> implements RandomAccess {
            private final NamedNodeMap list;
    
            NodeMapWrapper(NamedNodeMap l) {
                this.list = l;
            }
    
            public Node get(int index) {
                return this.list.item(index);
            }
    
            public int size() {
                return this.list.getLength();
            }
        }
    }
  7. 0

    Leer archivo XML utilizando XPathFactory, SAXParserFactory y StAX (JSR-173).

    Usando XPath obtener nodo y su hijo de datos.

    public static void main(String[] args) {
        String xml = "<soapenv:Body xmlns:soapenv='http://schemas.xmlsoap.org/soap/envelope/'>"
                + "<Yash:Data xmlns:Yash='http://Yash.stackoverflow.com/Services/Yash'>"
                + "<Yash:Tags>Java</Yash:Tags><Yash:Tags>Javascript</Yash:Tags><Yash:Tags>Selenium</Yash:Tags>"
                + "<Yash:Top>javascript</Yash:Top><Yash:User>Yash-777</Yash:User>"
                + "</Yash:Data></soapenv:Body>";
        String jsonNameSpaces = "{'soapenv':'http://schemas.xmlsoap.org/soap/envelope/',"
                + "'Yash':'http://Yash.stackoverflow.com/Services/Yash'}";
        String xpathExpression = "//Yash:Data";
    
        Document doc1 = getDocument(false, "fileName", xml);
        getNodesFromXpath(doc1, xpathExpression, jsonNameSpaces);
        System.out.println("\n===== ***** =====");
        Document doc2 = getDocument(true, "./books.xml", xml);
        getNodesFromXpath(doc2, "//person", "{}");
    }
    static Document getDocument( boolean isFileName, String fileName, String xml ) {
        Document doc = null;
        try {
    
            DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
            factory.setValidating(false);
            factory.setNamespaceAware(true);
            factory.setIgnoringComments(true);
            factory.setIgnoringElementContentWhitespace(true);
    
            DocumentBuilder builder = factory.newDocumentBuilder();
            if( isFileName ) {
                File file = new File( fileName );
                FileInputStream stream = new FileInputStream( file );
                doc = builder.parse( stream );
            } else {
                doc = builder.parse( string2Source( xml ) );
            }
        } catch (SAXException | IOException e) {
            e.printStackTrace();
        } catch (ParserConfigurationException e) {
            e.printStackTrace();
        }
        return doc;
    }
    
    /**
     * ELEMENT_NODE[1],ATTRIBUTE_NODE[2],TEXT_NODE[3],CDATA_SECTION_NODE[4],
     * ENTITY_REFERENCE_NODE[5],ENTITY_NODE[6],PROCESSING_INSTRUCTION_NODE[7],
     * COMMENT_NODE[8],DOCUMENT_NODE[9],DOCUMENT_TYPE_NODE[10],DOCUMENT_FRAGMENT_NODE[11],NOTATION_NODE[12]
     */
    public static void getNodesFromXpath( Document doc, String xpathExpression, String jsonNameSpaces ) {
        try {
            XPathFactory xpf = XPathFactory.newInstance();
            XPath xpath = xpf.newXPath();
    
            JSONObject namespaces = getJSONObjectNameSpaces(jsonNameSpaces);
            if ( namespaces.size() > 0 ) {
                NamespaceContextImpl nsContext = new NamespaceContextImpl();
    
                Iterator<?> key = namespaces.keySet().iterator();
                while (key.hasNext()) { //Apache WebServices Common Utilities
                    String pPrefix = key.next().toString();
                    String pURI = namespaces.get(pPrefix).toString();
                    nsContext.startPrefixMapping(pPrefix, pURI);
                }
                xpath.setNamespaceContext(nsContext );
            }
    
            XPathExpression compile = xpath.compile(xpathExpression);
            NodeList nodeList = (NodeList) compile.evaluate(doc, XPathConstants.NODESET);
            displayNodeList(nodeList);
        } catch (XPathExpressionException e) {
            e.printStackTrace();
        }
    }
    
    static void displayNodeList( NodeList nodeList ) {
        for (int i = 0; i < nodeList.getLength(); i++) {
            Node node = nodeList.item(i);
            String NodeName = node.getNodeName();
    
            NodeList childNodes = node.getChildNodes();
            if ( childNodes.getLength() > 1 ) {
                for (int j = 0; j < childNodes.getLength(); j++) {
    
                    Node child = childNodes.item(j);
                    short nodeType = child.getNodeType();
                    if ( nodeType == 1 ) {
                        System.out.format( "\n\t Node Name:[%s], Text[%s] ", child.getNodeName(), child.getTextContent() );
                    }
                }
            } else {
                System.out.format( "\n Node Name:[%s], Text[%s] ", NodeName, node.getTextContent() );
            }
    
        }
    }
    static InputSource string2Source( String str ) {
        InputSource inputSource = new InputSource( new StringReader( str ) );
        return inputSource;
    }
    static JSONObject getJSONObjectNameSpaces( String jsonNameSpaces ) {
        if(jsonNameSpaces.indexOf("'") > -1)    jsonNameSpaces = jsonNameSpaces.replace("'", "\"");
        JSONParser parser = new JSONParser();
        JSONObject namespaces = null;
        try {
            namespaces = (JSONObject) parser.parse(jsonNameSpaces);
        } catch (ParseException e) {
            e.printStackTrace();
        }
        return namespaces;
    }

    Documento XML

    <?xml version="1.0" encoding="UTF-8"?>
    <book>
    <person>
      <first>Yash</first>
      <last>M</last>
      <age>22</age>
    </person>
    <person>
      <first>Bill</first>
      <last>Gates</last>
      <age>46</age>
    </person>
    <person>
      <first>Steve</first>
      <last>Jobs</last>
      <age>40</age>
    </person>
    </book>

    Para poner fuera de la XPathExpression:

    String xpathExpression = "//person/first";
    /*OutPut:
     Node Name:[first], Text[Yash] 
     Node Name:[first], Text[Bill] 
     Node Name:[first], Text[Steve] */
    
    String xpathExpression = "//person";
    /*OutPut:
         Node Name:[first], Text[Yash] 
         Node Name:[last], Text[M] 
         Node Name:[age], Text[22] 
         Node Name:[first], Text[Bill] 
         Node Name:[last], Text[Gates] 
         Node Name:[age], Text[46] 
         Node Name:[first], Text[Steve] 
         Node Name:[last], Text[Jobs] 
         Node Name:[age], Text[40] */
    
    String xpathExpression = "//Yash:Data";
    /*OutPut:
         Node Name:[Yash:Tags], Text[Java] 
         Node Name:[Yash:Tags], Text[Javascript] 
         Node Name:[Yash:Tags], Text[Selenium] 
         Node Name:[Yash:Top], Text[javascript] 
         Node Name:[Yash:User], Text[Yash-777] */

    Ver en este enlace para nuestra propia Implementación de NamespaceContext

  8. 0

    Si usted tiene un xml como el siguiente

    <e:Envelope
        xmlns:d = "http://www.w3.org/2001/XMLSchema"
        xmlns:e = "http://schemas.xmlsoap.org/soap/envelope/"
        xmlns:wn0 = "http://systinet.com/xsd/SchemaTypes/"
        xmlns:i = "http://www.w3.org/2001/XMLSchema-instance">
        <e:Header>
            <Friends>
                <friend>
                    <Name>Testabc</Name>
                    <Age>12121</Age>
                    <Phone>Testpqr</Phone>
                </friend>
            </Friends>
        </e:Header>
        <e:Body>
            <n0:ForAnsiHeaderOperResponse xmlns:n0 = "http://systinet.com/wsdl/com/magicsoftware/ibolt/localhost/ForAnsiHeader/ForAnsiHeaderImpl#ForAnsiHeaderOper?KExqYXZhL2xhbmcvU3RyaW5nOylMamF2YS9sYW5nL1N0cmluZzs=">
                <response i:type = "d:string">12--abc--pqr</response>
            </n0:ForAnsiHeaderOperResponse>
        </e:Body>
    </e:Envelope>

    y quería extraer el siguiente xml

    <e:Header>
       <Friends>
          <friend>
             <Name>Testabc</Name>
             <Age>12121</Age>
             <Phone>Testpqr</Phone>
          </friend>
       </Friends>
    </e:Header>

    El código de abajo, ayuda a alcanzar el mismo

    public static void main(String[] args) {
    
        File fXmlFile = new File("C://Users//abhijitb//Desktop//Test.xml");
        DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
        Document document;
        Node result = null;
        try {
            document = dbf.newDocumentBuilder().parse(fXmlFile);
            XPath xPath = XPathFactory.newInstance().newXPath();
            String xpathStr = "//Envelope//Header";
            result = (Node) xPath.evaluate(xpathStr, document, XPathConstants.NODE);
            System.out.println(nodeToString(result));
        } catch (SAXException | IOException | ParserConfigurationException | XPathExpressionException
                | TransformerException e) {
            e.printStackTrace();
        }
    }
    
    private static String nodeToString(Node node) throws TransformerException {
        StringWriter buf = new StringWriter();
        Transformer xform = TransformerFactory.newInstance().newTransformer();
        xform.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
        xform.transform(new DOMSource(node), new StreamResult(buf));
        return (buf.toString());
    }

    Ahora si desea que sólo el xml como el siguiente

    <Friends>
       <friend>
          <Name>Testabc</Name>
          <Age>12121</Age>
          <Phone>Testpqr</Phone>
       </friend>
    </Friends>

    Usted necesita para cambiar el

    String xpathStr = "//Envelope//Header"; a String xpathStr = "//Envelope//Header/*";

Kommentieren Sie den Artikel

Bitte geben Sie Ihren Kommentar ein!
Bitte geben Sie hier Ihren Namen ein

Pruebas en línea