Java XML - Kurzanleitung

Was ist XML?

XML ist eine einfache textbasierte Sprache, die zum Speichern und Transportieren von Daten im Nur-Text-Format entwickelt wurde. Es steht für Extensible Markup Language. Im Folgenden sind einige der wichtigsten Funktionen von XML aufgeführt.

  • XML ist eine Auszeichnungssprache.

  • XML ist eine tagbasierte Sprache wie HTML.

  • XML-Tags sind nicht wie HTML vordefiniert.

  • Sie können Ihre eigenen Tags definieren, weshalb es als erweiterbare Sprache bezeichnet wird.

  • XML-Tags sind so konzipiert, dass sie sich selbst beschreiben.

  • XML ist die W3C-Empfehlung für die Datenspeicherung und Datenübertragung.

Beispiel

<?xml version = "1.0"?>
<Class>
   <Name>First</Name>
   <Sections>
      <Section>
         <Name>A</Name>
         <Students>
            <Student>Rohan</Student>
            <Student>Mohan</Student>
            <Student>Sohan</Student>
            <Student>Lalit</Student>
            <Student>Vinay</Student>
         </Students>
      </Section>
      
      <Section>
         <Name>B</Name>
         <Students>
            <Student>Robert</Student>
            <Student>Julie</Student>
            <Student>Kalie</Student>
            <Student>Michael</Student>
         </Students>
      </Section>
   </Sections>
</Class>

Vorteile

Im Folgenden sind die Vorteile aufgeführt, die XML bietet:

  • Technology agnostic- Als einfacher Text ist XML technologieunabhängig. Es kann von jeder Technologie zur Datenspeicherung und Datenübertragung verwendet werden.

  • Human readable- XML ​​verwendet ein einfaches Textformat. Es ist menschlich lesbar und verständlich.

  • Extensible - In XML können benutzerdefinierte Tags sehr einfach erstellt und verwendet werden.

  • Allow Validation - Mit XSD können DTD- und XML-Strukturen einfach validiert werden.

Nachteile

Im Folgenden sind die Nachteile der Verwendung von XML aufgeführt:

  • Redundant Syntax - Normalerweise enthalten XML-Dateien viele sich wiederholende Begriffe.

  • Verbose - Als ausführliche Sprache erhöht die Größe der XML-Datei die Übertragungs- und Speicherkosten.

XML-Analyse bezieht sich auf das Durchlaufen eines XML-Dokuments, um auf Daten zuzugreifen oder diese zu ändern.

Was ist XML-Parser?

XML Parser bietet eine Möglichkeit, auf Daten in einem XML-Dokument zuzugreifen oder diese zu ändern. Java bietet mehrere Optionen zum Parsen von XML-Dokumenten. Im Folgenden sind die verschiedenen Arten von Parsern aufgeführt, die üblicherweise zum Parsen von XML-Dokumenten verwendet werden.

  • Dom Parser - Analysiert ein XML-Dokument, indem der gesamte Inhalt des Dokuments geladen und sein vollständiger hierarchischer Baum im Speicher erstellt wird.

  • SAX Parser- Analysiert ein XML-Dokument nach ereignisbasierten Triggern. Lädt nicht das gesamte Dokument in den Speicher.

  • JDOM Parser - Analysiert ein XML-Dokument auf ähnliche Weise wie der DOM-Parser, jedoch auf einfachere Weise.

  • StAX Parser - Analysiert ein XML-Dokument auf ähnliche Weise wie der SAX-Parser, jedoch effizienter.

  • XPath Parser - Analysiert ein XML-Dokument basierend auf Ausdruck und wird häufig in Verbindung mit XSLT verwendet.

  • DOM4J Parser- Eine Java-Bibliothek zum Parsen von XML, XPath und XSLT mithilfe des Java Collections Framework. Es bietet Unterstützung für DOM, SAX und JAXP.

Für die objektorientierte XML-Analyse stehen JAXB- und XSLT-APIs zur Verfügung. Wir werden jeden Parser in den folgenden Kapiteln dieses Tutorials ausführlich erläutern.

Das Document Object Model (DOM) ist eine offizielle Empfehlung des World Wide Web Consortium (W3C). Es definiert eine Schnittstelle, über die Programme auf Stil, Struktur und Inhalt von XML-Dokumenten zugreifen und diese aktualisieren können. XML-Parser, die DOM unterstützen, implementieren diese Schnittstelle.

Wann verwenden?

Sie sollten einen DOM-Parser verwenden, wenn -

  • Sie müssen viel über die Struktur eines Dokuments wissen.

  • Sie müssen Teile eines XML-Dokuments verschieben (möglicherweise möchten Sie beispielsweise bestimmte Elemente sortieren).

  • Sie müssen die Informationen in einem XML-Dokument mehrmals verwenden.

Was du bekommst?

Wenn Sie ein XML-Dokument mit einem DOM-Parser analysieren, erhalten Sie eine Baumstruktur zurück, die alle Elemente Ihres Dokuments enthält. Das DOM bietet eine Vielzahl von Funktionen, mit denen Sie den Inhalt und die Struktur des Dokuments untersuchen können.

Vorteile

Das DOM ist eine gemeinsame Schnittstelle zum Bearbeiten von Dokumentstrukturen. Eines der Entwurfsziele besteht darin, dass Java-Code, der für einen DOM-kompatiblen Parser geschrieben wurde, auf jedem anderen DOM-kompatiblen Parser ausgeführt werden sollte, ohne dass Änderungen vorgenommen werden müssen.

DOM-Schnittstellen

Das DOM definiert mehrere Java-Schnittstellen. Hier sind die häufigsten Schnittstellen -

  • Node - Der Basisdatentyp des DOM.

  • Element - Die überwiegende Mehrheit der Objekte, mit denen Sie sich befassen, sind Elemente.

  • Attr - Repräsentiert ein Attribut eines Elements.

  • Text - Der tatsächliche Inhalt eines Elements oder Attr.

  • Document- Repräsentiert das gesamte XML-Dokument. Ein Dokumentobjekt wird häufig als DOM-Baum bezeichnet.

Gängige DOM-Methoden

Wenn Sie mit DOM arbeiten, gibt es verschiedene Methoden, die Sie häufig verwenden werden -

  • Document.getDocumentElement() - Gibt das Stammelement des Dokuments zurück.

  • Node.getFirstChild() - Gibt das erste Kind eines bestimmten Knotens zurück.

  • Node.getLastChild() - Gibt das letzte Kind eines bestimmten Knotens zurück.

  • Node.getNextSibling() - Diese Methoden geben das nächste Geschwister eines bestimmten Knotens zurück.

  • Node.getPreviousSibling() - Diese Methoden geben das vorherige Geschwister eines bestimmten Knotens zurück.

  • Node.getAttribute(attrName) - Für einen bestimmten Knoten wird das Attribut mit dem angeforderten Namen zurückgegeben.

Schritte zur Verwendung von JDOM

Im Folgenden werden die Schritte beschrieben, die beim Parsen eines Dokuments mit JDOM Parser ausgeführt werden.

  • XML-bezogene Pakete importieren.
  • Erstellen Sie einen DocumentBuilder
  • Erstellen Sie ein Dokument aus einer Datei oder einem Stream
  • Extrahieren Sie das Stammelement
  • Attribute untersuchen
  • Untersuchen Sie die Unterelemente

XML-bezogene Pakete importieren

import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;

Erstellen Sie einen DocumentBuilder

DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

Erstellen Sie ein Dokument aus einer Datei oder einem Stream

StringBuilder xmlStringBuilder = new StringBuilder();
xmlStringBuilder.append("<?xml version="1.0"?> 
       
      ");
ByteArrayInputStream input = new ByteArrayInputStream(
   xmlStringBuilder.toString().getBytes("UTF-8"));
Document doc = builder.parse(input);

Extrahieren Sie das Stammelement

Element root = document.getDocumentElement();

Attribute untersuchen

//returns specific attribute
getAttribute("attributeName");

//returns a Map (table) of names/values
getAttributes();

Untersuchen Sie die Unterelemente

//returns a list of subelements of specified name
getElementsByTagName("subelementName");

//returns a list of all child nodes
getChildNodes();

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

DomParserDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;

public class DomParserDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
         Document doc = dBuilder.parse(inputFile);
         doc.getDocumentElement().normalize();
         System.out.println("Root element :" + doc.getDocumentElement().getNodeName());
         NodeList nList = doc.getElementsByTagName("student");
         System.out.println("----------------------------");
         
         for (int temp = 0; temp < nList.getLength(); temp++) {
            Node nNode = nList.item(temp);
            System.out.println("\nCurrent Element :" + nNode.getNodeName());
            
            if (nNode.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) nNode;
               System.out.println("Student roll no : " 
                  + eElement.getAttribute("rollno"));
               System.out.println("First Name : " 
                  + eElement
                  .getElementsByTagName("firstname")
                  .item(0)
                  .getTextContent());
               System.out.println("Last Name : " 
                  + eElement
                  .getElementsByTagName("lastname")
                  .item(0)
                  .getTextContent());
               System.out.println("Nick Name : " 
                  + eElement
                  .getElementsByTagName("nickname")
                  .item(0)
                  .getTextContent());
               System.out.println("Marks : " 
                  + eElement
                  .getElementsByTagName("marks")
                  .item(0)
                  .getTextContent());
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Root element :class
----------------------------

Current Element :student
Student roll no : 393
First Name : dinkar
Last Name : kad
Nick Name : dinkar
Marks : 85

Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95

Current Element :student
Student roll no : 593
First Name : jasvir
Last Name : singn
Nick Name : jazz
Marks : 90

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir abfragen müssen -

<?xml version = "1.0"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferarri 101</carname>
      <carname type = "sports car">Ferarri 201</carname>
      <carname type = "sports car">Ferarri 301</carname>
   </supercars>
   
   <supercars company = "Lamborgini">
      <carname>Lamborgini 001</carname>
      <carname>Lamborgini 002</carname>
      <carname>Lamborgini 003</carname>
   </supercars>
   
   <luxurycars company = "Benteley">
      <carname>Benteley 1</carname>
      <carname>Benteley 2</carname>
      <carname>Benteley 3</carname>
   </luxurycars>
</cars>

QueryXmlFileDemo.java

package com.tutorialspoint.xml;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import org.w3c.dom.Document;
import org.w3c.dom.NodeList;
import org.w3c.dom.Node;
import org.w3c.dom.Element;
import java.io.File;

public class QueryXmlFileDemo {

   public static void main(String argv[]) {
 
      try {
         File inputFile = new File("input.txt");
         DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
         Document doc = dBuilder.parse(inputFile);
         doc.getDocumentElement().normalize();
         System.out.print("Root element: ");
         System.out.println(doc.getDocumentElement().getNodeName());
         NodeList nList = doc.getElementsByTagName("supercars");
         System.out.println("----------------------------");
         
         for (int temp = 0; temp < nList.getLength(); temp++) {
            Node nNode = nList.item(temp);
            System.out.println("\nCurrent Element :");
            System.out.print(nNode.getNodeName());
            
            if (nNode.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) nNode;
               System.out.print("company : ");
               System.out.println(eElement.getAttribute("company"));
               NodeList carNameList = eElement.getElementsByTagName("carname");
               
               for (int count = 0; count < carNameList.getLength(); count++) {
                  Node node1 = carNameList.item(count);
                  
                  if (node1.getNodeType() == node1.ELEMENT_NODE) {
                     Element car = (Element) node1;
                     System.out.print("car name : ");
                     System.out.println(car.getTextContent());
                     System.out.print("car type : ");
                     System.out.println(car.getAttribute("type"));
                  }
               }
            }
         }
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Root element: cars
----------------------------

Current Element :
supercarscompany : Ferrari
car name : Ferarri 101
car type : formula one
car name : Ferarri 201
car type : sports car
car name : Ferarri 301
car type : sports car

Current Element :
supercarscompany : Lamborgini
car name : Lamborgini 001
car type : 
car name : Lamborgini 002
car type : 
car name : Lamborgini 003
car type :

Demo-Beispiel

Hier ist das XML, das wir erstellen müssen -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

CreateXmlFileDemo.java

package com.tutorialspoint.xml;

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Attr;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import java.io.File;

public class CreateXmlFileDemo {

   public static void main(String argv[]) {

      try {
         DocumentBuilderFactory dbFactory =
         DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder = dbFactory.newDocumentBuilder();
         Document doc = dBuilder.newDocument();
         
         // root element
         Element rootElement = doc.createElement("cars");
         doc.appendChild(rootElement);

         // supercars element
         Element supercar = doc.createElement("supercars");
         rootElement.appendChild(supercar);

         // setting attribute to element
         Attr attr = doc.createAttribute("company");
         attr.setValue("Ferrari");
         supercar.setAttributeNode(attr);

         // carname element
         Element carname = doc.createElement("carname");
         Attr attrType = doc.createAttribute("type");
         attrType.setValue("formula one");
         carname.setAttributeNode(attrType);
         carname.appendChild(doc.createTextNode("Ferrari 101"));
         supercar.appendChild(carname);

         Element carname1 = doc.createElement("carname");
         Attr attrType1 = doc.createAttribute("type");
         attrType1.setValue("sports");
         carname1.setAttributeNode(attrType1);
         carname1.appendChild(doc.createTextNode("Ferrari 202"));
         supercar.appendChild(carname1);

         // write the content into xml file
         TransformerFactory transformerFactory = TransformerFactory.newInstance();
         Transformer transformer = transformerFactory.newTransformer();
         DOMSource source = new DOMSource(doc);
         StreamResult result = new StreamResult(new File("C:\\cars.xml"));
         transformer.transform(source, result);
         
         // Output to console for testing
         StreamResult consoleResult = new StreamResult(System.out);
         transformer.transform(source, consoleResult);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>

<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir ändern müssen -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
   
   <luxurycars company = "Benteley">
      <carname>Benteley 1</carname>
      <carname>Benteley 2</carname>
      <carname>Benteley 3</carname>
   </luxurycars>
</cars>

ModifyXmlFileDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.NamedNodeMap;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;

public class ModifyXmlFileDemo {

   public static void main(String argv[]) {

      try {
         File inputFile = new File("input.xml");
         DocumentBuilderFactory docFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder docBuilder = docFactory.newDocumentBuilder();
         Document doc = docBuilder.parse(inputFile);
         Node cars = doc.getFirstChild();
         Node supercar = doc.getElementsByTagName("supercars").item(0);
         
         // update supercar attribute
         NamedNodeMap attr = supercar.getAttributes();
         Node nodeAttr = attr.getNamedItem("company");
         nodeAttr.setTextContent("Lamborigini");

         // loop the supercar child node
         NodeList list = supercar.getChildNodes();
         
         for (int temp = 0; temp < list.getLength(); temp++) {
            Node node = list.item(temp);
            if (node.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) node;
               if ("carname".equals(eElement.getNodeName())) {
                  if("Ferrari 101".equals(eElement.getTextContent())) {
                     eElement.setTextContent("Lamborigini 001");
                  }
                  if("Ferrari 202".equals(eElement.getTextContent()))
                     eElement.setTextContent("Lamborigini 002");
               }
            }
         }
         NodeList childNodes = cars.getChildNodes();
         
         for(int count = 0; count < childNodes.getLength(); count++) {
            Node node = childNodes.item(count);
            
            if("luxurycars".equals(node.getNodeName()))
               cars.removeChild(node);
         }

         // write the content on console
         TransformerFactory transformerFactory = TransformerFactory.newInstance();
         Transformer transformer = transformerFactory.newTransformer();
         DOMSource source = new DOMSource(doc);
         System.out.println("-----------Modified File-----------");
         StreamResult consoleResult = new StreamResult(System.out);
         transformer.transform(source, consoleResult);
      } catch (Exception e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

-----------Modified File-----------
<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>

<cars>
   <supercars company = "Lamborigini">
      <carname type = "formula one">Lamborigini 001</carname>
      <carname type = "sports">Lamborigini 002</carname>
   </supercars>
</cars>

SAX (Simple API for XML) ist ein ereignisbasierter Parser für XML-Dokumente. Im Gegensatz zu einem DOM-Parser erstellt ein SAX-Parser keinen Analysebaum. SAX ist eine Streaming-Schnittstelle für XML. Dies bedeutet, dass Anwendungen, die SAX verwenden, Ereignisbenachrichtigungen über das XML-Dokument erhalten, das als Element und Attribut zu einem Zeitpunkt in sequenzieller Reihenfolge verarbeitet wird, beginnend am Anfang des Dokuments und endend mit dem Schließen des ROOT-Element.

  • Liest ein XML-Dokument von oben nach unten und erkennt die Token, aus denen ein wohlgeformtes XML-Dokument besteht.

  • Token werden in derselben Reihenfolge verarbeitet, in der sie im Dokument angezeigt werden.

  • Meldet dem Anwendungsprogramm die Art der Token, auf die der Parser beim Auftreten gestoßen ist.

  • Das Anwendungsprogramm bietet einen "Ereignis" -Handler, der beim Parser registriert werden muss.

  • Wenn die Token identifiziert werden, werden Rückrufmethoden im Handler mit den relevanten Informationen aufgerufen.

Wann verwenden?

Sie sollten einen SAX-Parser verwenden, wenn -

  • Sie können das XML-Dokument linear von oben nach unten verarbeiten.

  • Das Dokument ist nicht tief verschachtelt.

  • Sie verarbeiten ein sehr großes XML-Dokument, dessen DOM-Baum zu viel Speicher verbrauchen würde. Typische DOM-Implementierungen verwenden zehn Byte Speicher, um ein Byte XML darzustellen.

  • Das zu lösende Problem betrifft nur einen Teil des XML-Dokuments.

  • Daten sind verfügbar, sobald sie vom Parser angezeigt werden. Daher funktioniert SAX gut für ein XML-Dokument, das über einen Stream eingeht.

Nachteile von SAX

  • Wir haben keinen zufälligen Zugriff auf ein XML-Dokument, da es nur vorwärts weitergeleitet wird.

  • Wenn Sie die vom Parser gesehenen Daten verfolgen oder die Reihenfolge der Elemente ändern müssen, müssen Sie den Code schreiben und die Daten selbst speichern.

ContentHandler-Schnittstelle

Diese Schnittstelle gibt die Rückrufmethoden an, mit denen der SAX-Parser ein Anwendungsprogramm über die Komponenten des XML-Dokuments benachrichtigt, die er gesehen hat.

  • void startDocument() - Wird am Anfang eines Dokuments aufgerufen.

  • void endDocument() - Wird am Ende eines Dokuments aufgerufen.

  • void startElement(String uri, String localName, String qName, Attributes atts) - Wird am Anfang eines Elements aufgerufen.

  • void endElement(String uri, String localName,String qName) - Wird am Ende eines Elements aufgerufen.

  • void characters(char[] ch, int start, int length) - Wird aufgerufen, wenn Zeichendaten gefunden werden.

  • void ignorableWhitespace( char[] ch, int start, int length) - Wird aufgerufen, wenn eine DTD vorhanden ist und ignorierbare Leerzeichen auftreten.

  • void processingInstruction(String target, String data) - Wird aufgerufen, wenn eine Verarbeitungsanweisung erkannt wird.

  • void setDocumentLocator(Locator locator)) - Bietet einen Locator, mit dem Positionen im Dokument identifiziert werden können.

  • void skippedEntity(String name) - Wird aufgerufen, wenn eine nicht aufgelöste Entität gefunden wird.

  • void startPrefixMapping(String prefix, String uri) - Wird aufgerufen, wenn eine neue Namespace-Zuordnung definiert wird.

  • void endPrefixMapping(String prefix) - Wird aufgerufen, wenn eine Namespace-Definition ihren Gültigkeitsbereich beendet.

Attributs-Schnittstelle

Diese Schnittstelle gibt Methoden zum Verarbeiten der mit einem Element verbundenen Attribute an.

  • int getLength() - Gibt die Anzahl der Attribute zurück.

  • String getQName(int index)

  • String getValue(int index)

  • String getValue(String qname)

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

UserHandler.java

package com.tutorialspoint.xml;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;

   @Override
   public void startElement(String uri, 
   String localName, String qName, Attributes attributes) throws SAXException {

      if (qName.equalsIgnoreCase("student")) {
         String rollNo = attributes.getValue("rollno");
         System.out.println("Roll No : " + rollNo);
      } else if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      }
      else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(String uri, 
   String localName, String qName) throws SAXException {
      if (qName.equalsIgnoreCase("student")) {
         System.out.println("End Element :" + qName);
      }
   }

   @Override
   public void characters(char ch[], int start, int length) throws SAXException {
      
      if (bFirstName) {
         System.out.println("First Name: " 
            + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

SAXParserDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SAXParserDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXParserFactory factory = SAXParserFactory.newInstance();
         SAXParser saxParser = factory.newSAXParser();
         UserHandler userhandler = new UserHandler();
         saxParser.parse(inputFile, userhandler);     
      } catch (Exception e) {
         e.printStackTrace();
      }
   }   
}

class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;

   @Override
   public void startElement(
      String uri, String localName, String qName, Attributes attributes)
      throws SAXException {
      
      if (qName.equalsIgnoreCase("student")) {
         String rollNo = attributes.getValue("rollno");
         System.out.println("Roll No : " + rollNo);
      } else if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      }
      else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(String uri, 
      String localName, String qName) throws SAXException {
      
      if (qName.equalsIgnoreCase("student")) {
         System.out.println("End Element :" + qName);
      }
   }

   @Override
   public void characters(char ch[], int start, int length) throws SAXException {

      if (bFirstName) {
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element :student
Roll No : 493
First Name: Vaneet
Last Name: Gupta
Nick Name: vinni
Marks: 95
End Element :student
Roll No : 593
First Name: jasvir
Last Name: singn
Nick Name: jazz
Marks: 90
End Element :student

Demo-Beispiel

Hier ist die Eingabetextdatei, die wir für rollno abfragen müssen: 393

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

UserHandler.java

package com.tutorialspoint.xml;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
 
public class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;
   String rollNo = null;

   @Override
   public void startElement(
      String uri, String localName, String qName, Attributes attributes)
      throws SAXException {

      if (qName.equalsIgnoreCase("student")) {
         rollNo = attributes.getValue("rollno");
      }
      if(("393").equals(rollNo) && 
         qName.equalsIgnoreCase("student")) {
         System.out.println("Start Element :" + qName);      
      }       
      if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      }
      else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(
      String uri, String localName, String qName) throws SAXException {
      
      if (qName.equalsIgnoreCase("student")) {
         if(("393").equals(rollNo) && qName.equalsIgnoreCase("student"))
         System.out.println("End Element :" + qName);
      }
   }

   @Override
   public void characters(char ch[], int start, int length) throws SAXException {

      if (bFirstName && ("393").equals(rollNo)) {
         //age element, set Employee age
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName && ("393").equals(rollNo)) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName && ("393").equals(rollNo)) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks && ("393").equals(rollNo)) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

SAXQueryDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;

import org.xml.sax.Attributes;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;

public class SAXQueryDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXParserFactory factory = SAXParserFactory.newInstance();
         SAXParser saxParser = factory.newSAXParser();
         UserHandler userhandler = new UserHandler();
         saxParser.parse(inputFile, userhandler);     
      } catch (Exception e) {
         e.printStackTrace();
      }
   }   
}

class UserHandler extends DefaultHandler {

   boolean bFirstName = false;
   boolean bLastName = false;
   boolean bNickName = false;
   boolean bMarks = false;
   String rollNo = null;

   @Override
   public void startElement(String uri, 
      String localName, String qName, Attributes attributes)
      throws SAXException {

      if (qName.equalsIgnoreCase("student")) {
         rollNo = attributes.getValue("rollno");
      }
      if(("393").equals(rollNo) && qName.equalsIgnoreCase("student")) {
         System.out.println("Start Element :" + qName);      
      }       
      if (qName.equalsIgnoreCase("firstname")) {
         bFirstName = true;
      } else if (qName.equalsIgnoreCase("lastname")) {
         bLastName = true;
      } else if (qName.equalsIgnoreCase("nickname")) {
         bNickName = true;
      }
      else if (qName.equalsIgnoreCase("marks")) {
         bMarks = true;
      }
   }

   @Override
   public void endElement(
      String uri, String localName, String qName) throws SAXException {
      
      if (qName.equalsIgnoreCase("student")) {

         if(("393").equals(rollNo) 
            && qName.equalsIgnoreCase("student"))
            System.out.println("End Element :" + qName);
         }
   }


   @Override
   public void characters(
      char ch[], int start, int length) throws SAXException {

      if (bFirstName && ("393").equals(rollNo)) {
         //age element, set Employee age
         System.out.println("First Name: " + new String(ch, start, length));
         bFirstName = false;
      } else if (bLastName && ("393").equals(rollNo)) {
         System.out.println("Last Name: " + new String(ch, start, length));
         bLastName = false;
      } else if (bNickName && ("393").equals(rollNo)) {
         System.out.println("Nick Name: " + new String(ch, start, length));
         bNickName = false;
      } else if (bMarks && ("393").equals(rollNo)) {
         System.out.println("Marks: " + new String(ch, start, length));
         bMarks = false;
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Start Element :student
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element :student

It is better to use StAX parser for creating XML documents rather than using SAX parser. Please refer the Java StAX Parser section for the same.

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir ändern müssen, indem wir <Ergebnis> Pass <Ergebnis /> am Ende des </marks> -Tags anhängen.

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

SAXModifyDemo.java

package com.tutorialspoint.xml;

import java.io.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import org.xml.sax.helpers.DefaultHandler;

public class SAXModifyDemo extends DefaultHandler {
   static String displayText[] = new String[1000];
   static int numberLines = 0;
   static String indentation = "";

   public static void main(String args[]) {

      try {
         File inputFile = new File("input.txt");
         SAXParserFactory factory = 
         SAXParserFactory.newInstance();
         SAXModifyDemo obj = new SAXModifyDemo();
         obj.childLoop(inputFile);
         FileWriter filewriter = new FileWriter("newfile.xml");
         
         for(int loopIndex = 0; loopIndex < numberLines; loopIndex++) {
            filewriter.write(displayText[loopIndex].toCharArray());
            filewriter.write('\n');
            System.out.println(displayText[loopIndex].toString());
         }
         filewriter.close();
      }
      catch (Exception e) {
         e.printStackTrace(System.err);
      }
   }

   public void childLoop(File input) {
      DefaultHandler handler = this;
      SAXParserFactory factory = SAXParserFactory.newInstance();
      
      try {
         SAXParser saxParser = factory.newSAXParser();
         saxParser.parse(input, handler);
      } catch (Throwable t) {}
   }

   public void startDocument() {
      displayText[numberLines] = indentation;
      displayText[numberLines] += "<?xml version = \"1.0\" encoding = \""+
         "UTF-8" + "\"?>";
      numberLines++;
   }

   public void processingInstruction(String target, String data) {
      displayText[numberLines] = indentation;
      displayText[numberLines] += "<?";
      displayText[numberLines] += target;
      
      if (data != null && data.length() > 0) {
         displayText[numberLines] += ' ';
         displayText[numberLines] += data;
      }
      displayText[numberLines] += "?>";
      numberLines++;
   }

   public void startElement(String uri, String localName, String qualifiedName,
      Attributes attributes) {

      displayText[numberLines] = indentation;

      indentation += "    ";

      displayText[numberLines] += '<';
      displayText[numberLines] += qualifiedName;
      
      if (attributes != null) {
         int numberAttributes = attributes.getLength();

         for (int loopIndex = 0; loopIndex < numberAttributes; loopIndex++) {
            displayText[numberLines] += ' ';
            displayText[numberLines] += attributes.getQName(loopIndex);
            displayText[numberLines] += "=\"";
            displayText[numberLines] += attributes.getValue(loopIndex);
            displayText[numberLines] += '"';
         }
      }
      displayText[numberLines] += '>';
      numberLines++;
   }

   public void characters(char characters[], int start, int length) {
      String characterData = (new String(characters, start, length)).trim();
      
      if(characterData.indexOf("\n") < 0 && characterData.length() > 0) {
         displayText[numberLines] = indentation;
         displayText[numberLines] += characterData;
         numberLines++;
      }
   }

   public void endElement(String uri, String localName, String qualifiedName) {
      indentation = indentation.substring(0, indentation.length() - 4) ;
      displayText[numberLines] = indentation;
      displayText[numberLines] += "</";
      displayText[numberLines] += qualifiedName;
      displayText[numberLines] += '>';
      numberLines++;

      if (qualifiedName.equals("marks")) {
         startElement("", "Result", "Result", null);
         characters("Pass".toCharArray(), 0, "Pass".length());
         endElement("", "Result", "Result");
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8"?>
<class>
   <student rollno = "393">
      <firstname>
         dinkar
      </firstname>
      <lastname>
         kad
      </lastname>
      <nickname>
         dinkar
      </nickname>
      <marks>
         85
      </marks>
      <Result>
         Pass
      </Result>
   </student>
   <student rollno = "493">
      <firstname>
         Vaneet
      </firstname>
      <lastname>
         Gupta
      </lastname>
      <nickname>
         vinni
      </nickname>
      <marks>
         95
      </marks>
      <Result>
         Pass
      </Result>
   </student>
   <student rollno = "593">
      <firstname>
         jasvir
      </firstname>
      <lastname>
         singn
      </lastname>
      <nickname>
         jazz
      </nickname>
      <marks>
         90
      </marks>
      <Result>
         Pass
      </Result>
   </student>
</class>

JDOM ist eine Java-basierte Open Source-Bibliothek zum Parsen von XML-Dokumenten. Es ist normalerweise eine Java-Entwickler-freundliche API. Es ist Java-optimiert und verwendet Java-Sammlungen wie List und Arrays.

JDOM arbeitet mit DOM- und SAX-APIs und kombiniert das Beste aus beiden. Es hat einen geringen Speicherbedarf und ist fast so schnell wie SAX.

Umgebungs-Setup

Um den JDOM-Parser verwenden zu können, sollte jdom.jar im Klassenpfad Ihrer Anwendung enthalten sein. Laden Sie jdom-2.0.5.zip herunter .

Wann verwenden?

Sie sollten einen JDOM-Parser verwenden, wenn -

  • Sie müssen viel über die Struktur eines XML-Dokuments wissen.

  • Sie müssen Teile eines XMl-Dokuments verschieben (möglicherweise möchten Sie beispielsweise bestimmte Elemente sortieren).

  • Sie müssen die Informationen in einem XML-Dokument mehrmals verwenden.

  • Sie sind Java-Entwickler und möchten die Java-optimierte Analyse von XML nutzen.

Was du bekommst?

Wenn Sie ein XML-Dokument mit einem JDOM-Parser analysieren, erhalten Sie die Flexibilität, eine Baumstruktur wiederherzustellen, die alle Elemente Ihres Dokuments enthält, ohne den Speicherbedarf der Anwendung zu beeinträchtigen.

JDOM bietet eine Vielzahl von Dienstprogrammfunktionen, mit denen Sie den Inhalt und die Struktur eines XML-Dokuments untersuchen können, falls das Dokument gut strukturiert und seine Struktur bekannt ist.

Vorteile

JDOM bietet Java-Entwicklern die Flexibilität und einfache Wartbarkeit von XML-Parsing-Code. Es ist eine leichte und schnelle API.

JDOM-Klassen

JDOM definiert mehrere Java-Klassen. Hier sind die häufigsten Klassen -

  • Document- Repräsentiert ein gesamtes XML-Dokument. Ein Dokumentobjekt wird häufig als DOM-Baum bezeichnet.

  • Element- Repräsentiert ein XML-Element. Das Elementobjekt verfügt über Methoden zum Bearbeiten seiner untergeordneten Elemente, seines Texts, seiner Attribute und seiner Namespaces.

  • Attribute- Repräsentiert ein Attribut eines Elements. Das Attribut verfügt über eine Methode zum Abrufen und Festlegen des Attributwerts. Es hat übergeordneten und Attributtyp.

  • Text - Repräsentiert den Text des XML-Tags.

  • Comment - Repräsentiert die Kommentare in einem XML-Dokument.

Allgemeine JDOM-Methoden

Wenn Sie mit JDOM arbeiten, gibt es verschiedene Methoden, die Sie häufig verwenden werden:

  • SAXBuilder.build(xmlSource)() - Erstellen Sie das JDOM-Dokument aus der XML-Quelle.

  • Document.getRootElement() - Holen Sie sich das Stammelement des XML.

  • Element.getName() - Rufen Sie den Namen des XML-Knotens ab.

  • Element.getChildren() - Holen Sie sich alle direkten untergeordneten Knoten eines Elements.

  • Node.getChildren(Name) - Holen Sie sich alle direkten untergeordneten Knoten mit einem bestimmten Namen.

  • Node.getChild(Name) - Holen Sie sich den ersten untergeordneten Knoten mit dem angegebenen Namen.

Schritte zur Verwendung von JDOM

Im Folgenden werden die Schritte beschrieben, die beim Parsen eines Dokuments mit JDOM Parser ausgeführt werden.

  • XML-bezogene Pakete importieren.
  • Erstellen Sie einen SAXBuilder
  • Erstellen Sie ein Dokument aus einer Datei oder einem Stream
  • Extrahieren Sie das Stammelement
  • Attribute untersuchen
  • Untersuchen Sie die Unterelemente

XML-bezogene Pakete importieren

import java.io.*;
import java.util.*;
import org.jdom2.*;

Erstellen Sie einen DocumentBuilder

SAXBuilder saxBuilder = new SAXBuilder();

Erstellen Sie ein Dokument aus einer Datei oder einem Stream

File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);

Extrahieren Sie das Stammelement

Element classElement = document.getRootElement();

Attribute untersuchen

//returns specific attribute
getAttribute("attributeName");

Untersuchen Sie die Unterelemente

//returns a list of subelements of specified name
getChildren("subelementName"); 

//returns a list of all child nodes
getChildren(); 

//returns first child node
getChild("subelementName");

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

DomParserDemo.java

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;


public class JDomParserDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXBuilder saxBuilder = new SAXBuilder();
         Document document = saxBuilder.build(inputFile);
         System.out.println("Root element :" + document.getRootElement().getName());
         Element classElement = document.getRootElement();

         List<Element> studentList = classElement.getChildren();
         System.out.println("----------------------------");

         for (int temp = 0; temp < studentList.size(); temp++) {    
            Element student = studentList.get(temp);
            System.out.println("\nCurrent Element :" 
               + student.getName());
            Attribute attribute =  student.getAttribute("rollno");
            System.out.println("Student roll no : " 
               + attribute.getValue() );
            System.out.println("First Name : "
               + student.getChild("firstname").getText());
            System.out.println("Last Name : "
               + student.getChild("lastname").getText());
            System.out.println("Nick Name : "
               + student.getChild("nickname").getText());
            System.out.println("Marks : "
               + student.getChild("marks").getText());
         }
      } catch(JDOMException e) {
         e.printStackTrace();
      } catch(IOException ioe) {
         ioe.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Root element :class
----------------------------

Current Element :student
Student roll no : 393
First Name : dinkar
Last Name : kad
Nick Name : dinkar
Marks : 85

Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95

Current Element :student
Student roll no : 593
First Name : jasvir
Last Name : singn
Nick Name : jazz
Marks : 90

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir abfragen müssen -

<?xml version = "1.0"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferarri 101</carname>
      <carname type = "sports car">Ferarri 201</carname>
      <carname type = "sports car">Ferarri 301</carname>
   </supercars>
   
   <supercars company = "Lamborgini">
      <carname>Lamborgini 001</carname>
      <carname>Lamborgini 002</carname>
      <carname>Lamborgini 003</carname>
   </supercars>
   
   <luxurycars company = "Benteley">
      <carname>Benteley 1</carname>
      <carname>Benteley 2</carname>
      <carname>Benteley 3</carname>
   </luxurycars>
</cars>

QueryXmlFileDemo.java

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;


public class QueryXmlFileDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXBuilder saxBuilder = new SAXBuilder();
         Document document = saxBuilder.build(inputFile);
         System.out.println("Root element :" + document.getRootElement().getName());
         Element classElement = document.getRootElement();

         List<Element> supercarList = classElement.getChildren("supercars");
         System.out.println("----------------------------");

         for (int temp = 0; temp < supercarList.size(); temp++) {    
            Element supercarElement = supercarList.get(temp);
            System.out.println("\nCurrent Element :" + supercarElement.getName());
            Attribute attribute = supercarElement.getAttribute("company");
            System.out.println("company : " + attribute.getValue() );
            List<Element> carNameList = supercarElement.getChildren("carname");
            
            for (int count = 0; count < carNameList.size(); count++) {	 
               Element carElement = carNameList.get(count);
               System.out.print("car name : ");
               System.out.println(carElement.getText());
               System.out.print("car type : ");
               Attribute typeAttribute = carElement.getAttribute("type");
               
               if(typeAttribute != null)
                  System.out.println(typeAttribute.getValue());
               else {
                  System.out.println("");
               }
            }
         }
      } catch(JDOMException e) {
         e.printStackTrace();
      } catch(IOException ioe) {
         ioe.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Root element :cars
----------------------------

Current Element :supercars
company : Ferrari
car name : Ferarri 101
car type : formula one
car name : Ferarri 201
car type : sports car
car name : Ferarri 301
car type : sports car

Current Element :supercars
company : Lamborgini
car name : Lamborgini 001
car type : 
car name : Lamborgini 002
car type : 
car name : Lamborgini 003
car type :

Demo-Beispiel

Hier ist die XML-Datei, die wir erstellen müssen -

<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

CreateXmlFileDemo.java

import java.io.IOException;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;


public class CreateXmlFileDemo {

   public static void main(String[] args) {

      try{
         //root element
         Element carsElement = new Element("cars");
         Document doc = new Document(carsElement);

         //supercars element
         Element supercarElement = new Element("supercars");
         supercarElement.setAttribute(new Attribute("company","Ferrari"));

         //supercars element
         Element carElement1 = new Element("carname");
         carElement1.setAttribute(new Attribute("type","formula one"));
         carElement1.setText("Ferrari 101");

         Element carElement2 = new Element("carname");
         carElement2.setAttribute(new Attribute("type","sports"));
         carElement2.setText("Ferrari 202");

         supercarElement.addContent(carElement1);
         supercarElement.addContent(carElement2);

         doc.getRootElement().addContent(supercarElement);

         XMLOutputter xmlOutput = new XMLOutputter();

         // display ml
         xmlOutput.setFormat(Format.getPrettyFormat());
         xmlOutput.output(doc, System.out); 
      } catch(IOException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

Demo-Beispiel

Hier ist die Eingabetextdatei, die wir ändern müssen -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
   
   <luxurycars company = "Benteley">
      <carname>Benteley 1</carname>
      <carname>Benteley 2</carname>
      <carname>Benteley 3</carname>
   </luxurycars>
</cars>

ModifyXmlFileDemo.java

import java.io.File;
import java.io.IOException;
import java.util.List;

import org.jdom2.Attribute;
import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;


public class ModifyXMLFileDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXBuilder saxBuilder = new SAXBuilder();
         Document document = saxBuilder.build(inputFile);
         Element rootElement = document.getRootElement();

         //get first supercar
         Element supercarElement = rootElement.getChild("supercars");

         // update supercar attribute
         Attribute attribute = supercarElement.getAttribute("company");
         attribute.setValue("Lamborigini");

         // loop the supercar child node
         List<Element> list = supercarElement.getChildren();
         
         for (int temp = 0; temp < list.size(); temp++) {
            Element carElement = list.get(temp);
            
            if("Ferrari 101".equals(carElement.getText())) {
               carElement.setText("Lamborigini 001");
            }
            if("Ferrari 202".equals(carElement.getText())) {
               carElement.setText("Lamborigini 002");
            }
         }

         //get all supercars element
         List<Element> supercarslist = rootElement.getChildren();
         
         for (int temp = 0; temp < supercarslist.size(); temp++) {
            Element tempElement = supercarslist.get(temp);
            
            if("luxurycars".equals(tempElement.getName())) {
               rootElement.removeContent(tempElement);
            }        	 
         }

         XMLOutputter xmlOutput = new XMLOutputter();
   
         // display xml
         xmlOutput.setFormat(Format.getPrettyFormat());
         xmlOutput.output(document, System.out); 
      } catch (JDOMException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
   <supercars company = "Lamborigini">
      <carname type = "formula one">Lamborigini 001</carname>
      <carname type = "sports">Lamborigini 002</carname>
   </supercars>
</cars>

StAX ist eine Java-basierte API zum Parsen von XML-Dokumenten auf ähnliche Weise wie der SAX-Parser. Es gibt jedoch zwei Hauptunterschiede zwischen den beiden APIs:

  • StAX ist eine PULL-API, während SAX eine PUSH-API ist. Dies bedeutet, dass im Fall eines StAX-Parsers eine Clientanwendung den StAX-Parser auffordern muss, Informationen aus XML abzurufen, wann immer dies erforderlich ist. Im Falle eines SAX-Parsers ist jedoch eine Clientanwendung erforderlich, um Informationen abzurufen, wenn der SAX-Parser die Clientanwendung benachrichtigt, dass Informationen verfügbar sind.

  • Die StAX-API kann XML-Dokumente lesen und schreiben. Mit der SAX-API kann eine XML-Datei nur gelesen werden.

Umgebungs-Setup

Um den StAX-Parser verwenden zu können, sollte stax.jar im Klassenpfad Ihrer Anwendung enthalten sein.

Im Folgenden sind die Funktionen der StAX-API aufgeführt:

  • Liest ein XML-Dokument von oben nach unten und erkennt die Token, aus denen ein wohlgeformtes XML-Dokument besteht.

  • Token werden in derselben Reihenfolge verarbeitet, in der sie im Dokument angezeigt werden.

  • Meldet dem Anwendungsprogramm die Art der Token, auf die der Parser beim Auftreten gestoßen ist.

  • Das Anwendungsprogramm bietet einen "Ereignis" -Leser, der als Iterator fungiert und das Ereignis durchläuft, um die erforderlichen Informationen zu erhalten. Ein weiterer verfügbarer Reader ist "Cursor", der als Zeiger auf XML-Knoten fungiert.

  • Sobald die Ereignisse identifiziert sind, können XML-Elemente aus dem Ereignisobjekt abgerufen und weiterverarbeitet werden.

Wann verwenden?

Sie sollten einen StAX-Parser verwenden, wenn -

  • Sie können das XML-Dokument linear von oben nach unten verarbeiten.

  • Das Dokument ist nicht tief verschachtelt.

  • Sie verarbeiten ein sehr großes XML-Dokument, dessen DOM-Baum zu viel Speicher verbrauchen würde. Typische DOM-Implementierungen verwenden zehn Byte Speicher, um ein Byte XML darzustellen.

  • Das zu lösende Problem betrifft nur einen Teil des XML-Dokuments.

  • Daten sind verfügbar, sobald sie vom Parser angezeigt werden. Daher funktioniert StAX gut für ein XML-Dokument, das über einen Stream eingeht.

Nachteile von SAX

  • Wir haben keinen zufälligen Zugriff auf ein XML-Dokument, da es nur vorwärts weitergeleitet wird.

  • Wenn Sie die Daten verfolgen müssen, die der Parser gesehen hat oder bei denen der Parser die Reihenfolge der Elemente geändert hat, müssen Sie den Code schreiben und die Daten selbst speichern.

XMLEventReader-Klasse

Diese Klasse bietet einen Iterator für Ereignisse, mit dem Ereignisse beim Parsen eines XML-Dokuments durchlaufen werden können.

  • StartElement asStartElement() - Wird verwendet, um den Wert und die Attribute eines Elements abzurufen.

  • EndElement asEndElement() - Wird am Ende eines Elements aufgerufen.

  • Characters asCharacters() - Kann verwendet werden, um Zeichen wie CDATA, Leerzeichen usw. abzurufen.

XMLEventWriter-Klasse

Diese Schnittstelle gibt Methoden zum Erstellen eines Ereignisses an.

  • add(Event event) - Fügen Sie XML Ereignisse hinzu, die Elemente enthalten.

XMLStreamReader-Klasse

Diese Klasse bietet einen Iterator für Ereignisse, mit dem Ereignisse beim Parsen eines XML-Dokuments durchlaufen werden können.

  • int next() - Wird verwendet, um das nächste Ereignis abzurufen.

  • boolean hasNext() - Wird verwendet, um zu überprüfen, ob weitere Ereignisse vorhanden sind oder nicht.

  • String getText() - Wird verwendet, um den Text eines Elements abzurufen.

  • String getLocalName() - Wird verwendet, um den Namen eines Elements abzurufen.

XMLStreamWriter-Klasse

Diese Schnittstelle gibt Methoden zum Erstellen eines Ereignisses an.

  • writeStartElement(String localName) - Fügen Sie ein Startelement mit Vorname hinzu.

  • writeEndElement(String localName) - Fügen Sie ein Endelement mit Vorname hinzu.

  • writeAttribute(String localName, String value) - Schreiben Sie Attribute in ein Element.

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

StAXParserDemo.java

package com.tutorialspoint.xml;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

public class StAXParserDemo {
   public static void main(String[] args) {
      boolean bFirstName = false;
      boolean bLastName = false;
      boolean bNickName = false;
      boolean bMarks = false;
      
      try {
         XMLInputFactory factory = XMLInputFactory.newInstance();
         XMLEventReader eventReader =
         factory.createXMLEventReader(new FileReader("input.txt"));

         while(eventReader.hasNext()) {
            XMLEvent event = eventReader.nextEvent();
               
            switch(event.getEventType()) {
               
               case XMLStreamConstants.START_ELEMENT:
                  StartElement startElement = event.asStartElement();
                  String qName = startElement.getName().getLocalPart();

               if (qName.equalsIgnoreCase("student")) {
                  System.out.println("Start Element : student");
                  Iterator<Attribute> attributes = startElement.getAttributes();
                  String rollNo = attributes.next().getValue();
                  System.out.println("Roll No : " + rollNo);
               } else if (qName.equalsIgnoreCase("firstname")) {
                  bFirstName = true;
               } else if (qName.equalsIgnoreCase("lastname")) {
                  bLastName = true;
               } else if (qName.equalsIgnoreCase("nickname")) {
                  bNickName = true;
               }
               else if (qName.equalsIgnoreCase("marks")) {
                  bMarks = true;
               }
               break;

               case XMLStreamConstants.CHARACTERS:
                  Characters characters = event.asCharacters();
               if(bFirstName) {
                  System.out.println("First Name: " + characters.getData());
                  bFirstName = false;
               }
               if(bLastName) {
                  System.out.println("Last Name: " + characters.getData());
                  bLastName = false;
               }
               if(bNickName) {
                  System.out.println("Nick Name: " + characters.getData());
                  bNickName = false;
               }
               if(bMarks) {
                  System.out.println("Marks: " + characters.getData());
                  bMarks = false;
               }
               break;

               case XMLStreamConstants.END_ELEMENT:
                  EndElement endElement = event.asEndElement();
                  
               if(endElement.getName().getLocalPart().equalsIgnoreCase("student")) {
                  System.out.println("End Element : student");
                  System.out.println();
               }
               break;
            } 
         }
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (XMLStreamException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Start Element : student
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element : student

Start Element : student
Roll No : 493
First Name: Vaneet
Last Name: Gupta
Nick Name: vinni
Marks: 95
End Element : student

Start Element : student
Roll No : 593
First Name: jasvir
Last Name: singn
Nick Name: jazz
Marks: 90
End Element : student

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

StAXParserDemo.java

package com.tutorialspoint.xml;

import java.io.FileNotFoundException;
import java.io.FileReader;
import java.util.Iterator;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

public class StAXQueryDemo {
   public static void main(String[] args) {
      boolean bFirstName = false;
      boolean bLastName = false;
      boolean bNickName = false;
      boolean bMarks = false;
      boolean isRequestRollNo = false;
      
      try {
         XMLInputFactory factory = XMLInputFactory.newInstance();
         XMLEventReader eventReader =
         factory.createXMLEventReader(new FileReader("input.txt"));

         String requestedRollNo = "393";
         
         while(eventReader.hasNext()) {
            XMLEvent event = eventReader.nextEvent();
            
            switch(event.getEventType()) {
               case XMLStreamConstants.START_ELEMENT:
                  StartElement startElement = event.asStartElement();
                  String qName = startElement.getName().getLocalPart();
                  
               if (qName.equalsIgnoreCase("student")) {
                  Iterator<Attribute> attributes = startElement.getAttributes();
                  String rollNo = attributes.next().getValue();
                     
                  if(rollNo.equalsIgnoreCase(requestedRollNo)) {
                     System.out.println("Start Element : student");
                     System.out.println("Roll No : " + rollNo);
                     isRequestRollNo = true;
                  }
               } else if (qName.equalsIgnoreCase("firstname")) {
                  bFirstName = true;
               } else if (qName.equalsIgnoreCase("lastname")) {
                  bLastName = true;
               } else if (qName.equalsIgnoreCase("nickname")) {
                  bNickName = true;
               }
               else if (qName.equalsIgnoreCase("marks")) {
                  bMarks = true;
               }
               break;
               
               case XMLStreamConstants.CHARACTERS:
                  Characters characters = event.asCharacters();
               
               if(bFirstName && isRequestRollNo) {
                  System.out.println("First Name: " + characters.getData());
                  bFirstName = false;
               }
               if(bLastName && isRequestRollNo) {
                  System.out.println("Last Name: " + characters.getData());
                  bLastName = false;
               }
               if(bNickName && isRequestRollNo) {
                  System.out.println("Nick Name: " + characters.getData());
                  bNickName = false;
               }
               if(bMarks && isRequestRollNo) {
                  System.out.println("Marks: " + characters.getData());
                  bMarks = false;
               }
               break;
               
               case XMLStreamConstants.END_ELEMENT:
                  EndElement endElement = event.asEndElement();
                  
               if(endElement.getName().getLocalPart().equalsIgnoreCase(
                  "student") && isRequestRollNo) {
                  System.out.println("End Element : student");
                  System.out.println();
                  isRequestRollNo = false;
               }
               break;
            }
         }
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (XMLStreamException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Start Element : student
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element : student

Demo-Beispiel

Hier ist das XML, das wir erstellen müssen -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

StAXCreateXMLDemo.java

package com.tutorialspoint.xml;

import java.io.IOException;
import java.io.StringWriter;

import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamWriter;

public class StAXCreateXMLDemo {

   public static void main(String[] args) {

      try {
         StringWriter stringWriter = new StringWriter();

         XMLOutputFactory xMLOutputFactory = XMLOutputFactory.newInstance();
         XMLStreamWriter xMLStreamWriter =
            xMLOutputFactory.createXMLStreamWriter(stringWriter);
   
         xMLStreamWriter.writeStartDocument();
         xMLStreamWriter.writeStartElement("cars");
   
         xMLStreamWriter.writeStartElement("supercars");	
         xMLStreamWriter.writeAttribute("company", "Ferrari");
      
         xMLStreamWriter.writeStartElement("carname");
         xMLStreamWriter.writeAttribute("type", "formula one");
         xMLStreamWriter.writeCharacters("Ferrari 101");
         xMLStreamWriter.writeEndElement();

         xMLStreamWriter.writeStartElement("carname");			
         xMLStreamWriter.writeAttribute("type", "sports");
         xMLStreamWriter.writeCharacters("Ferrari 202");
         xMLStreamWriter.writeEndElement();

         xMLStreamWriter.writeEndElement();
         xMLStreamWriter.writeEndDocument();

         xMLStreamWriter.flush();
         xMLStreamWriter.close();

         String xmlString = stringWriter.getBuffer().toString();

         stringWriter.close();

         System.out.println(xmlString);

      } catch (XMLStreamException e) {
         e.printStackTrace();
      } catch (IOException e) {
         // TODO Auto-generated catch block
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8" standalone = "no"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

Demo-Beispiel

Hier ist das XML, das wir ändern müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singh</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

StAXModifyDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.IOException;
import java.util.Iterator;
import java.util.List;

import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamConstants;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Attribute;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;

import org.jdom2.Document;
import org.jdom2.Element;
import org.jdom2.JDOMException;
import org.jdom2.input.SAXBuilder;
import org.jdom2.output.Format;
import org.jdom2.output.XMLOutputter;

public class StAXModifyDemo {

   public static void main(String[] args) {

      try {
         XMLInputFactory factory = XMLInputFactory.newInstance();
         XMLEventReader eventReader = factory.createXMLEventReader(
            new FileReader("input.txt"));
         SAXBuilder saxBuilder = new SAXBuilder();
         Document document = saxBuilder.build(new File("input.txt"));
         Element rootElement = document.getRootElement();
         List<Element> studentElements = rootElement.getChildren("student");

         while(eventReader.hasNext()) {
            XMLEvent event = eventReader.nextEvent();
            
            switch(event.getEventType()) {
               case XMLStreamConstants.START_ELEMENT:
               StartElement startElement = event.asStartElement();
               String qName = startElement.getName().getLocalPart();

               if (qName.equalsIgnoreCase("student")) {
                  Iterator<Attribute> attributes = startElement.getAttributes();
                  String rollNo = attributes.next().getValue();
                  
                  if(rollNo.equalsIgnoreCase("393")) {
                     //get the student with roll no 393

                     for(int i = 0;i < studentElements.size();i++) {
                        Element studentElement = studentElements.get(i);

                        if(studentElement.getAttribute(
                           "rollno").getValue().equalsIgnoreCase("393")) {
                           studentElement.removeChild("marks");
                           studentElement.addContent(new Element("marks").setText("80"));
                        }
                     }
                  }
               }
               break;
            }
         }
         XMLOutputter xmlOutput = new XMLOutputter();

         // display xml
         xmlOutput.setFormat(Format.getPrettyFormat());
         xmlOutput.output(document, System.out);
      } catch (FileNotFoundException e) {
         e.printStackTrace();
      } catch (XMLStreamException e) {
         e.printStackTrace();
      } catch (JDOMException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8"?>
<student rollno = "393">
   <firstname>dinkar</firstname>
   <lastname>kad</lastname>
   <nickname>dinkar</nickname>
   <marks>80</marks>
</student>
<student rollno = "493">
   <firstname>Vaneet</firstname>
   <lastname>Gupta</lastname>
   <nickname>vinni</nickname>
   <marks>95</marks>
</student>
<student rollno = "593">
   <firstname>jasvir</firstname>
   <lastname>singh</lastname>
   <nickname>jazz</nickname>
   <marks>90</marks>
</student>

XPath ist eine offizielle Empfehlung des World Wide Web Consortium (W3C). Es definiert eine Sprache zum Suchen von Informationen in einer XML-Datei. Es wird verwendet, um Elemente und Attribute eines XML-Dokuments zu durchlaufen. XPath bietet verschiedene Arten von Ausdrücken, mit denen relevante Informationen aus dem XML-Dokument abgefragt werden können.

Was ist XPath?

  • Structure Definations - XPath definiert die Teile eines XML-Dokuments wie Element-, Attribut-, Text-, Namespace-, Verarbeitungsanweisungs-, Kommentar- und Dokumentknoten.

  • Path Expressions - XPath bietet leistungsstarke Pfadausdrücke wie ausgewählte Knoten oder eine Liste von Knoten in XML-Dokumenten.

  • Standard Functions - XPath bietet eine umfangreiche Bibliothek mit Standardfunktionen für die Bearbeitung von Zeichenfolgenwerten, numerischen Werten, Datums- und Zeitvergleich, Knoten- und QName-Manipulation, Sequenzmanipulation, Booleschen Werten usw.

  • Major part of XSLT - XPath ist eines der Hauptelemente des XSLT-Standards und es müssen ausreichende Kenntnisse in XPath vorhanden sein, um mit XSLT-Dokumenten arbeiten zu können.

  • W3C recommendation - XPath ist eine offizielle Empfehlung des World Wide Web Consortium (W3C).

XPath-Ausdrücke

XPath verwendet einen Pfadausdruck, um einen Knoten oder eine Liste von Knoten aus einem XML-Dokument auszuwählen. Im Folgenden finden Sie eine Liste nützlicher Pfade und Ausdrücke zum Auswählen eines beliebigen Knotens / einer beliebigen Liste von Knoten aus einem XML-Dokument.

Sr.Nr. Ausdruck & Beschreibung
1

node-name

Wählen Sie alle Knoten mit dem angegebenen Namen "Knotenname" aus.
2

/

Die Auswahl beginnt am Wurzelknoten
3

//

Die Auswahl beginnt am aktuellen Knoten, der der Auswahl entspricht
4

.

Wählt den aktuellen Knoten aus
5

..

Wählt das übergeordnete Element des aktuellen Knotens aus
6

@

Wählt Attribute aus
7

student

Example - Wählt alle Knoten mit dem Namen "Student" aus
8

class/student

Example - Wählt alle Schülerelemente aus, die Kinder der Klasse sind
9

//student

Wählt alle Schülerelemente aus, unabhängig davon, wo sie sich im Dokument befinden

Prädikate

Prädikate werden verwendet, um einen bestimmten Knoten oder einen Knoten mit einem bestimmten Wert zu finden, und werden mit [...] definiert.

Ausdruck Ergebnis
/ Klasse / Schüler [1] Wählt das erste Schülerelement aus, das das untergeordnete Element des Klassenelements ist.
/ class / student [last ()] Wählt das letzte Schülerelement aus, das das untergeordnete Element des Klassenelements ist.
/ class / student [last () - 1] Wählt das vorletzte Schülerelement aus, das das untergeordnete Element des Klassenelements ist.
// student [@rollno = '493'] Wählt alle Schülerelemente aus, die ein Attribut namens rollno mit dem Wert '493' haben.

Schritte zur Verwendung von XPath

Im Folgenden finden Sie die Schritte zum Parsen eines Dokuments mit XPath Parser.

  • XML-bezogene Pakete importieren.

  • Erstellen Sie einen DocumentBuilder.

  • Erstellen Sie ein Dokument aus einer Datei oder einem Stream.

  • Erstellen Sie ein Xpath-Objekt und einen XPath-Pfadausdruck.

  • Kompilieren Sie den XPath-Ausdruck mit XPath.compile() und erhalten Sie eine Liste von Knoten, indem Sie den kompilierten Ausdruck über auswerten XPath.evaluate().

  • Durchlaufen Sie die Liste der Knoten.

  • Attribute untersuchen.

  • Untersuchen Sie die Unterelemente.

XML-bezogene Pakete importieren

import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import javax.xml.xpath.*;
import java.io.*;

Erstellen Sie einen DocumentBuilder

DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();

Erstellen Sie ein Dokument aus einer Datei oder einem Stream

StringBuilder xmlStringBuilder = new StringBuilder();
xmlStringBuilder.append("<?xml version = "1.0"?> <class> </class>");
ByteArrayInputStream input =  new ByteArrayInputStream(
   xmlStringBuilder.toString().getBytes("UTF-8"));
Document doc = builder.parse(input);

Erstellen Sie XPath

XPath xPath =  XPathFactory.newInstance().newXPath();

Bereiten Sie den Pfadausdruck vor und werten Sie ihn aus

String expression = "/class/student";	        
NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
   doc, XPathConstants.NODESET);

Iterieren Sie über NodeList

for (int i = 0; i < nodeList.getLength(); i++) {
   Node nNode = nodeList.item(i);
   ...
}

Attribute untersuchen

//returns specific attribute
getAttribute("attributeName");

//returns a Map (table) of names/values
getAttributes();

Untersuchen Sie die Unterelemente

//returns a list of subelements of specified name
getElementsByTagName("subelementName");

//returns a list of all child nodes
getChildNodes();

Demo-Beispiel

Hier ist die Eingabetextdatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singh</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

XPathParserDemo.java

package com.tutorialspoint.xml;

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

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

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

public class XPathParserDemo {
   
   public static void main(String[] args) {
      
      try {
         File inputFile = new File("input.txt");
         DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder;

         dBuilder = dbFactory.newDocumentBuilder();

         Document doc = dBuilder.parse(inputFile);
         doc.getDocumentElement().normalize();

         XPath xPath =  XPathFactory.newInstance().newXPath();

         String expression = "/class/student";	        
         NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
            doc, XPathConstants.NODESET);

         for (int i = 0; i < nodeList.getLength(); i++) {
            Node nNode = nodeList.item(i);
            System.out.println("\nCurrent Element :" + nNode.getNodeName());
            
            if (nNode.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) nNode;
               System.out.println("Student roll no :" + eElement.getAttribute("rollno"));
               System.out.println("First Name : " 
                  + eElement
                  .getElementsByTagName("firstname")
                  .item(0)
                  .getTextContent());
               System.out.println("Last Name : " 
                  + eElement
                  .getElementsByTagName("lastname")
                  .item(0)
                  .getTextContent());
               System.out.println("Nick Name : " 
                  + eElement
                  .getElementsByTagName("nickname")
                  .item(0)
                  .getTextContent());
               System.out.println("Marks : " 
                  + eElement
                  .getElementsByTagName("marks")
                  .item(0)
                  .getTextContent());
            }
         }
      } catch (ParserConfigurationException e) {
         e.printStackTrace();
      } catch (SAXException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (XPathExpressionException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Current Element :student
Student roll no : 393
First Name : dinkar
Last Name : kad
Nick Name : dinkar
Marks : 85

Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95

Current Element :student
Student roll no : 593
First Name : jasvir
Last Name : singh
Nick Name : jazz
Marks : 90

Demo-Beispiel

Hier ist die Eingabetextdatei, die wir abfragen müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

XPathParserDemo.java

package com.tutorialspoint.xml;

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

import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.xpath.XPath;
import javax.xml.xpath.XPathConstants;
import javax.xml.xpath.XPathExpressionException;
import javax.xml.xpath.XPathFactory;

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

public class XPathParserDemo {

   public static void main(String[] args) {
      
      try {
         File inputFile = new File("input.txt");
         DocumentBuilderFactory dbFactory = DocumentBuilderFactory.newInstance();
         DocumentBuilder dBuilder;

         dBuilder = dbFactory.newDocumentBuilder();

         Document doc = dBuilder.parse(inputFile);
         doc.getDocumentElement().normalize();

         XPath xPath =  XPathFactory.newInstance().newXPath();

         String expression = "/class/student[@rollno = '493']";
         NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
            doc, XPathConstants.NODESET);
         
         for (int i = 0; i < nodeList.getLength(); i++) {
            Node nNode = nodeList.item(i);
            System.out.println("\nCurrent Element :" + nNode.getNodeName());
            
            if (nNode.getNodeType() == Node.ELEMENT_NODE) {
               Element eElement = (Element) nNode;
               System.out.println("Student roll no : " 
                  + eElement.getAttribute("rollno"));
               System.out.println("First Name : " 
                  + eElement
                  .getElementsByTagName("firstname")
                  .item(0)
                  .getTextContent());
               System.out.println("Last Name : " 
                  + eElement
                  .getElementsByTagName("lastname")
                  .item(0)
                  .getTextContent());
               System.out.println("Nick Name : " 
                  + eElement
                  .getElementsByTagName("nickname")
                  .item(0)
                  .getTextContent());
               System.out.println("Marks : " 
                  + eElement
                  .getElementsByTagName("marks")
                  .item(0)
                  .getTextContent());
            }
         }
      } catch (ParserConfigurationException e) {
         e.printStackTrace();
      } catch (SAXException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      } catch (XPathExpressionException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95

XPath parser is used to navigate XML Documents only. It is better to use DOM parser for creating XML. Please refer the Java DOM Parser section for the same.

XPath parser is used to navigate XML Documents only. It is better to use DOM parser for modifying XML. Please refer the Java DOM Parser section for the same.

DOM4J ist eine Java-basierte Open Source-Bibliothek zum Parsen von XML-Dokumenten. Es ist eine hochflexible und speichereffiziente API. Es ist Java-optimiert und verwendet Java-Sammlungen wie List und Arrays.

DOM4J funktioniert mit DOM, SAX, XPath und XSLT. Es kann große XML-Dokumente mit sehr geringem Speicherbedarf analysieren.

Umgebungs-Setup

Um den DOM4J-Parser verwenden zu können, sollten dom4j-1.6.1.jar und jaxen.jar im Klassenpfad Ihrer Anwendung enthalten sein. Laden Sie dom4j-1.6.1.zip herunter .

Wann verwenden?

Sie sollten einen DOM4J-Parser verwenden, wenn -

  • Sie müssen viel über die Struktur eines XML-Dokuments wissen.

  • Sie müssen Teile eines XML-Dokuments verschieben (möglicherweise möchten Sie beispielsweise bestimmte Elemente sortieren).

  • Sie müssen die Informationen in einem XML-Dokument mehrmals verwenden.

  • Sie sind Java-Entwickler und möchten die Java-optimierte Analyse von XML nutzen.

Was du bekommst?

Wenn Sie ein XML-Dokument mit einem DOM4J-Parser analysieren, erhalten Sie die Flexibilität, eine Baumstruktur wiederherzustellen, die alle Elemente Ihres Dokuments enthält, ohne den Speicherbedarf der Anwendung zu beeinträchtigen.

DOM4J bietet eine Vielzahl von Dienstprogrammfunktionen, mit denen Sie den Inhalt und die Struktur eines XML-Dokuments untersuchen können, falls das Dokument gut strukturiert und seine Struktur bekannt ist.

DOM4J verwendet den XPath-Ausdruck, um durch ein XML-Dokument zu navigieren.

Vorteile

DOM4J bietet Java-Entwicklern die Flexibilität und einfache Wartbarkeit von XML-Parsing-Code. Es ist eine leichte und schnelle API.

DOM4J-Klassen

DOM4J definiert mehrere Java-Klassen. Hier sind die häufigsten Klassen -

  • Document- Repräsentiert das gesamte XML-Dokument. Ein Dokumentobjekt wird häufig als DOM-Baum bezeichnet.

  • Element- Repräsentiert ein XML-Element. Das Elementobjekt verfügt über Methoden zum Bearbeiten seiner untergeordneten Elemente, Texte, Attribute und Namespaces.

  • Attribute- Repräsentiert ein Attribut eines Elements. Das Attribut verfügt über eine Methode zum Abrufen und Festlegen des Attributwerts. Es hat übergeordneten und Attributtyp.

  • Node - Repräsentiert Element, Attribut oder ProcessingInstruction.

Gängige DOM4J-Methoden

Wenn Sie mit dem DOM4J arbeiten, gibt es verschiedene Methoden, die Sie häufig verwenden werden -

  • SAXReader.read(xmlSource)() - Erstellen Sie das DOM4J-Dokument aus einer XML-Quelle.

  • Document.getRootElement() - Holen Sie sich das Stammelement eines XML-Dokuments.

  • Element.node(index) - Holen Sie sich den XML-Knoten an einem bestimmten Index in einem Element.

  • Element.attributes() - Holen Sie sich alle Attribute eines Elements.

  • Node.valueOf(@Name) - Ruft die Werte eines Attributs mit dem angegebenen Namen eines Elements ab.

Schritte zur Verwendung von DOM4J

Im Folgenden werden die Schritte beschrieben, die beim Parsen eines Dokuments mit DOM4J Parser ausgeführt werden.

  • XML-bezogene Pakete importieren.

  • Erstellen Sie einen SAXReader.

  • Erstellen Sie ein Dokument aus einer Datei oder einem Stream.

  • Rufen Sie mit XPath Expression die erforderlichen Knoten ab, indem Sie document.selectNodes () aufrufen.

  • Extrahieren Sie das Stammelement.

  • Durchlaufen Sie die Liste der Knoten.

  • Attribute untersuchen.

  • Untersuchen Sie die Unterelemente.

XML-bezogene Pakete importieren

import java.io.*;
import java.util.*;
import org.dom4j.*;

Erstellen Sie einen DocumentBuilder

SAXBuilder saxBuilder = new SAXBuilder();

Erstellen Sie ein Dokument aus einer Datei oder einem Stream

File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);

Extrahieren Sie das Stammelement

Element classElement = document.getRootElement();

Attribute untersuchen

//returns specific attribute
valueOf("@attributeName");

Untersuchen Sie die Unterelemente

//returns first child node
selectSingleNode("subelementName");

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

DOM4JParserDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

public class DOM4JParserDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXReader reader = new SAXReader();
         Document document = reader.read( inputFile );

         System.out.println("Root element :" + document.getRootElement().getName());

         Element classElement = document.getRootElement();

         List<Node> nodes = document.selectNodes("/class/student" );
         System.out.println("----------------------------");
         
         for (Node node : nodes) {
            System.out.println("\nCurrent Element :"
               + node.getName());
            System.out.println("Student roll no : " 
               + node.valueOf("@rollno") );
            System.out.println("First Name : "
               + node.selectSingleNode("firstname").getText());
            System.out.println("Last Name : "
               + node.selectSingleNode("lastname").getText());
            System.out.println("First Name : "
               + node.selectSingleNode("nickname").getText());
            System.out.println("Marks : "
               + node.selectSingleNode("marks").getText());
         }
      } catch (DocumentException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Root element :class
----------------------------

Current Element :student
Student roll no : 
First Name : dinkar
Last Name : kad
First Name : dinkar
Marks : 85

Current Element :student
Student roll no : 
First Name : Vaneet
Last Name : Gupta
First Name : vinni
Marks : 95

Current Element :student
Student roll no : 
First Name : jasvir
Last Name : singn
First Name : jazz
Marks : 90

Demo-Beispiel

Hier ist die XML-Eingabedatei, die wir analysieren müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

DOM4JQueryDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.SAXReader;

public class DOM4JQueryDemo {

   public static void main(String[] args) {

      try {
         File inputFile = new File("input.txt");
         SAXReader reader = new SAXReader();
         Document document = reader.read( inputFile );

         System.out.println("Root element :" + document.getRootElement().getName());

         Element classElement = document.getRootElement();

         List<Node> nodes = document.selectNodes("/class/student[@rollno = '493']" );
         System.out.println("----------------------------");
         
         for (Node node : nodes) {
            System.out.println("\nCurrent Element :" 
               + node.getName());
            System.out.println("Student roll no : " 
               + node.valueOf("@rollno") );
            System.out.println("First Name : "
               + node.selectSingleNode("firstname").getText());
            System.out.println("Last Name : "
               + node.selectSingleNode("lastname").getText());
            System.out.println("First Name : "
               + node.selectSingleNode("nickname").getText());
            System.out.println("Marks : "
               + node.selectSingleNode("marks").getText());
         }
      } catch (DocumentException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

Root element :class
----------------------------
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
First Name : vinni
Marks : 95

Demo-Beispiel

Hier ist das XML, das wir erstellen müssen -

<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

CreateXmlFileDemo.java

package com.tutorialspoint.xml;

import java.io.IOException;
import java.io.UnsupportedEncodingException;

import org.dom4j.Document;
import org.dom4j.DocumentHelper;
import org.dom4j.Element;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.XMLWriter;

public class DOM4JCreateXMLDemo {

   public static void main(String[] args) {
      
      try {
         Document document = DocumentHelper.createDocument();
         Element root = document.addElement( "cars" );
         Element supercarElement = root.addElement("supercars")
            .addAttribute("company", "Ferrai");

         supercarElement.addElement("carname")
            .addAttribute("type", "Ferrari 101")
            .addText("Ferrari 101");

         supercarElement.addElement("carname")
            .addAttribute("type", "sports")
            .addText("Ferrari 202");

         // Pretty print the document to System.out
         OutputFormat format = OutputFormat.createPrettyPrint();
         XMLWriter writer;
         writer = new XMLWriter( System.out, format );
         writer.write( document );
      } catch (UnsupportedEncodingException e) {
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8"?>
<cars>
   <supercars company = "Ferrari">
      <carname type = "formula one">Ferrari 101</carname>
      <carname type = "sports">Ferrari 202</carname>
   </supercars>
</cars>

Demo-Beispiel

Hier ist das XML, das wir ändern müssen -

<?xml version = "1.0"?>
<class>
   <student rollno = "393">
      <firstname>dinkar</firstname>
      <lastname>kad</lastname>
      <nickname>dinkar</nickname>
      <marks>85</marks>
   </student>
   
   <student rollno = "493">
      <firstname>Vaneet</firstname>
      <lastname>Gupta</lastname>
      <nickname>vinni</nickname>
      <marks>95</marks>
   </student>
   
   <student rollno = "593">
      <firstname>jasvir</firstname>
      <lastname>singn</lastname>
      <nickname>jazz</nickname>
      <marks>90</marks>
   </student>
</class>

DOM4jModifyXMLDemo.java

package com.tutorialspoint.xml;

import java.io.File;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.Iterator;
import java.util.List;

import org.dom4j.Document;
import org.dom4j.DocumentException;
import org.dom4j.Element;
import org.dom4j.Node;
import org.dom4j.io.OutputFormat;
import org.dom4j.io.SAXReader;
import org.dom4j.io.XMLWriter;

public class DOM4jModifyXMLDemo {

   public static void main(String[] args) {
   
      try {
         File inputFile = new File("input.txt");
         SAXReader reader = new SAXReader();
         Document document = reader.read( inputFile );

         Element classElement = document.getRootElement();

         List<Node> nodes = document.selectNodes("/class/student[@rollno = '493']" );
         
         for (Node node : nodes) {
            Element element = (Element)node;
            Iterator<Element> iterator = element.elementIterator("marks");

            while(iterator.hasNext()) {
               Element marksElement = (Element)iterator.next();
               marksElement.setText("80");
            }
         }

         // Pretty print the document to System.out
         OutputFormat format = OutputFormat.createPrettyPrint();
         XMLWriter writer;
         writer = new XMLWriter( System.out, format );
         writer.write( document );
      } catch (DocumentException e) {
         e.printStackTrace();
      } catch (UnsupportedEncodingException e) {         
         e.printStackTrace();
      } catch (IOException e) {
         e.printStackTrace();
      }
   }
}

Dies würde das folgende Ergebnis erzeugen -

<?xml version = "1.0" encoding = "UTF-8"?>

<class> 
   <student rollno = "393"> 
      <firstname>dinkar</firstname>  
      <lastname>kad</lastname>  
      <nickname>dinkar</nickname>  
      <marks>85</marks> 
   </student>
   <student rollno = "493"> 
      <firstname>Vaneet</firstname>  
      <lastname>Gupta</lastname>  
      <nickname>vinni</nickname>  
      <marks>80</marks> 
   </student>  
   <student rollno = "593"> 
      <firstname>jasvir</firstname>  
      <lastname>singn</lastname>  
      <nickname>jazz</nickname>  
      <marks>90</marks> 
   </student> 
</class>
ja/tutorial
es/tutorial
de/tutorial
fr/tutorial
th/tutorial
pt/tutorial
ru/tutorial
vi/tutorial
it/tutorial
ko/tutorial
tr/tutorial
id/tutorial
pl/tutorial
hi/tutorial
japost
espost
depost
frpost
thpost
ptpost
rupost
vipost
itpost
kopost
trpost
idpost
plpost
hipost

© Copyright 2021 - 2024 | All Rights Reserved