Java XML - Guide rapide
Qu'est-ce que XML?
XML est un langage textuel simple conçu pour stocker et transporter des données au format texte brut. Il signifie Extensible Markup Language. Voici quelques-unes des principales fonctionnalités de XML.
XML est un langage de balisage.
XML est un langage basé sur des balises comme HTML.
Les balises XML ne sont pas prédéfinies comme HTML.
Vous pouvez définir vos propres balises, c'est pourquoi on l'appelle langage extensible.
Les balises XML sont conçues pour être auto-descriptives.
XML est la recommandation du W3C pour le stockage et le transfert de données.
Exemple
<?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>Avantages
Voici les avantages qu'offre XML -
Technology agnostic- Étant du texte brut, XML est indépendant de la technologie. Il peut être utilisé par toute technologie à des fins de stockage et de transfert de données.
Human readable- XML utilise un format de texte simple. Il est lisible et compréhensible par l'homme.
Extensible - En XML, les balises personnalisées peuvent être créées et utilisées très facilement.
Allow Validation - L'utilisation des structures XSD, DTD et XML peut être validée facilement.
Désavantages
Voici les inconvénients de l'utilisation de XML -
Redundant Syntax - Normalement, les fichiers XML contiennent beaucoup de termes répétitifs.
Verbose - Étant un langage verbeux, la taille du fichier XML augmente les coûts de transmission et de stockage.
L'analyse XML fait référence au passage à travers un document XML afin d'accéder ou de modifier des données.
Qu'est-ce que XML Parser?
L'analyseur XML fournit un moyen d'accéder ou de modifier des données dans un document XML. Java fournit plusieurs options pour analyser les documents XML. Voici les différents types d'analyseurs couramment utilisés pour analyser les documents XML.
Dom Parser - Analyse un document XML en chargeant le contenu complet du document et en créant son arbre hiérarchique complet en mémoire.
SAX Parser- Analyse un document XML sur des déclencheurs basés sur des événements. Ne charge pas le document complet dans la mémoire.
JDOM Parser - Analyse un document XML d'une manière similaire à l'analyseur DOM mais d'une manière plus simple.
StAX Parser - Analyse un document XML de manière similaire à l'analyseur SAX mais d'une manière plus efficace.
XPath Parser - Analyse un document XML basé sur l'expression et est largement utilisé en conjonction avec XSLT.
DOM4J Parser- Une bibliothèque java pour analyser XML, XPath et XSLT à l'aide de Java Collections Framework. Il prend en charge DOM, SAX et JAXP.
Il existe des API JAXB et XSLT disponibles pour gérer l'analyse XML de manière orientée objet. Nous développerons chaque analyseur en détail dans les chapitres suivants de ce tutoriel.
Le Document Object Model (DOM) est une recommandation officielle du World Wide Web Consortium (W3C). Il définit une interface qui permet aux programmes d'accéder et de mettre à jour le style, la structure et le contenu des documents XML. Les analyseurs XML qui prennent en charge DOM implémentent cette interface.
Quand utiliser?
Vous devez utiliser un analyseur DOM lorsque -
Vous devez en savoir beaucoup sur la structure d'un document.
Vous devez déplacer des parties d'un document XML (vous voudrez peut-être trier certains éléments, par exemple).
Vous devez utiliser les informations d'un document XML plusieurs fois.
Ce que vous obtenez?
Lorsque vous analysez un document XML avec un analyseur DOM, vous récupérez une arborescence qui contient tous les éléments de votre document. Le DOM fournit une variété de fonctions que vous pouvez utiliser pour examiner le contenu et la structure du document.
Avantages
Le DOM est une interface courante pour manipuler les structures de documents. L'un de ses objectifs de conception est que le code Java écrit pour un analyseur compatible DOM doit s'exécuter sur tout autre analyseur compatible DOM sans avoir à effectuer de modifications.
Interfaces DOM
Le DOM définit plusieurs interfaces Java. Voici les interfaces les plus courantes -
Node - Le type de données de base du DOM.
Element - La grande majorité des objets que vous traitez sont des éléments.
Attr - Représente un attribut d'un élément.
Text - Le contenu réel d'un élément ou Attr.
Document- Représente l'intégralité du document XML. Un objet Document est souvent appelé une arborescence DOM.
Méthodes DOM courantes
Lorsque vous travaillez avec DOM, vous utilisez souvent plusieurs méthodes -
Document.getDocumentElement() - Renvoie l'élément racine du document.
Node.getFirstChild() - Renvoie le premier enfant d'un nœud donné.
Node.getLastChild() - Renvoie le dernier enfant d'un nœud donné.
Node.getNextSibling() - Ces méthodes renvoient le frère suivant d'un nœud donné.
Node.getPreviousSibling() - Ces méthodes renvoient le frère précédent d'un Node donné.
Node.getAttribute(attrName) - Pour un Node donné, il renvoie l'attribut avec le nom demandé.
Étapes à suivre pour utiliser JDOM
Voici les étapes utilisées lors de l'analyse d'un document à l'aide de JDOM Parser.
- Importez des packages liés au XML.
- Créer un DocumentBuilder
- Créer un document à partir d'un fichier ou d'un flux
- Extraire l'élément racine
- Examiner les attributs
- Examiner les sous-éléments
Importer des packages liés au XML
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;Créer un DocumentBuilder
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();Créer un document à partir d'un fichier ou d'un flux
StringBuilder xmlStringBuilder = new StringBuilder();
xmlStringBuilder.append("<?xml version="1.0"?>
");
ByteArrayInputStream input = new ByteArrayInputStream(
xmlStringBuilder.toString().getBytes("UTF-8"));
Document doc = builder.parse(input);Extraire l'élément racine
Element root = document.getDocumentElement();Examiner les attributs
//returns specific attribute
getAttribute("attributeName");
//returns a Map (table) of names/values
getAttributes();Examiner les sous-éléments
//returns a list of subelements of specified name
getElementsByTagName("subelementName");
//returns a list of all child nodes
getChildNodes();Exemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
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 : 90Exemple de démonstration
Voici le fichier xml d'entrée que nous devons interroger -
<?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();
}
}
}Cela produirait le résultat suivant -
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 :Exemple de démonstration
Voici le XML que nous devons créer -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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>Exemple de démonstration
Voici le fichier xml d'entrée que nous devons modifier -
<?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();
}
}
}Cela produirait le résultat suivant -
-----------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) est un analyseur basé sur les événements pour les documents XML. Contrairement à un analyseur DOM, un analyseur SAX ne crée aucun arbre d'analyse. SAX est une interface de streaming pour XML, ce qui signifie que les applications utilisant SAX reçoivent des notifications d'événements concernant le document XML en cours de traitement, un élément et un attribut, à la fois dans un ordre séquentiel commençant en haut du document et se terminant par la fermeture du Élément ROOT.
Lit un document XML de haut en bas, en reconnaissant les jetons qui composent un document XML bien formé.
Les jetons sont traités dans le même ordre qu'ils apparaissent dans le document.
Indique au programme d'application la nature des jetons que l'analyseur a rencontrés au fur et à mesure qu'ils se produisent.
Le programme d'application fournit un gestionnaire "d'événement" qui doit être enregistré auprès de l'analyseur.
Lorsque les jetons sont identifiés, les méthodes de rappel dans le gestionnaire sont appelées avec les informations pertinentes.
Quand utiliser?
Vous devez utiliser un analyseur SAX lorsque -
Vous pouvez traiter le document XML de manière linéaire de haut en bas.
Le document n'est pas profondément imbriqué.
Vous traitez un très gros document XML dont l'arborescence DOM consommerait trop de mémoire. Les implémentations DOM typiques utilisent dix octets de mémoire pour représenter un octet de XML.
Le problème à résoudre ne concerne qu'une partie du document XML.
Les données sont disponibles dès qu'elles sont vues par l'analyseur, donc SAX fonctionne bien pour un document XML qui arrive sur un flux.
Inconvénients de SAX
Nous n'avons pas d'accès aléatoire à un document XML car il est traité de manière directe uniquement.
Si vous avez besoin de garder une trace des données que l'analyseur a vues ou de modifier l'ordre des éléments, vous devez écrire le code et stocker les données vous-même.
Interface ContentHandler
Cette interface spécifie les méthodes de rappel utilisées par l'analyseur SAX pour notifier à un programme d'application les composants du document XML qu'il a vus.
void startDocument() - Appelé au début d'un document.
void endDocument() - Appelé à la fin d'un document.
void startElement(String uri, String localName, String qName, Attributes atts) - Appelé au début d'un élément.
void endElement(String uri, String localName,String qName) - Appelé à la fin d'un élément.
void characters(char[] ch, int start, int length) - Appelé lorsque des données de caractère sont rencontrées.
void ignorableWhitespace( char[] ch, int start, int length) - Appelé lorsqu'une DTD est présente et qu'un espace blanc ignorable est rencontré.
void processingInstruction(String target, String data) - Appelé lorsqu'une instruction de traitement est reconnue.
void setDocumentLocator(Locator locator)) - Fournit un localisateur qui peut être utilisé pour identifier les positions dans le document.
void skippedEntity(String name) - Appelé lorsqu'une entité non résolue est rencontrée.
void startPrefixMapping(String prefix, String uri) - Appelé lorsqu'un nouveau mappage d'espace de noms est défini.
void endPrefixMapping(String prefix) - Appelé lorsqu'une définition d'espace de noms termine sa portée.
Interface d'attributs
Cette interface spécifie les méthodes de traitement des attributs connectés à un élément.
int getLength() - Renvoie le nombre d'attributs.
String getQName(int index)
String getValue(int index)
String getValue(String qname)
Exemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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;
}
}
}Cela produirait le résultat suivant -
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 :studentExemple de démonstration
Voici le fichier texte d'entrée dont nous avons besoin pour interroger rollno: 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;
}
}
}Cela produirait le résultat suivant -
Start Element :student
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element :studentIt 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.
Exemple de démonstration
Voici le fichier XML d'entrée que nous devons modifier en ajoutant la balise <Result> Pass <Result /> à la fin de </marks>.
<?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");
}
}
}Cela produirait le résultat suivant -
<?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 est une bibliothèque open source basée sur Java pour analyser les documents XML. Il s'agit généralement d'une API conviviale pour les développeurs Java. Il est optimisé pour Java et utilise des collections Java telles que List et Arrays.
JDOM fonctionne avec les API DOM et SAX et combine le meilleur des deux. Il a une faible empreinte mémoire et est presque aussi rapide que SAX.
Configuration de l'environnement
Pour utiliser l'analyseur JDOM, vous devez avoir jdom.jar dans le chemin de classe de votre application. Téléchargez jdom-2.0.5.zip.
Quand utiliser?
Vous devez utiliser un analyseur JDOM lorsque -
Vous devez en savoir beaucoup sur la structure d'un document XML.
Vous devez déplacer des parties d'un document XMl (vous voudrez peut-être trier certains éléments, par exemple).
Vous devez utiliser les informations d'un document XML plusieurs fois.
Vous êtes un développeur Java et souhaitez tirer parti de l'analyse optimisée Java de XML.
Ce que vous obtenez?
Lorsque vous analysez un document XML avec un analyseur JDOM, vous avez la possibilité de récupérer une arborescence contenant tous les éléments de votre document sans affecter l'encombrement mémoire de l'application.
JDOM fournit une variété de fonctions utilitaires que vous pouvez utiliser pour examiner le contenu et la structure d'un document XML au cas où le document serait bien structuré et sa structure connue.
Avantages
JDOM offre aux développeurs Java la flexibilité et la facilité de maintenance du code d'analyse XML. C'est une API légère et rapide.
Classes JDOM
JDOM définit plusieurs classes Java. Voici les classes les plus courantes -
Document- Représente un document XML entier. Un objet Document est souvent appelé une arborescence DOM.
Element- Représente un élément XML. L'objet Element a des méthodes pour manipuler ses éléments enfants, son texte, ses attributs et ses espaces de noms.
Attribute- Représente un attribut d'un élément. L'attribut a une méthode pour obtenir et définir la valeur de l'attribut. Il a le type de parent et d'attribut.
Text - Représente le texte de la balise XML.
Comment - Représente les commentaires dans un document XML.
Méthodes JDOM courantes
Lorsque vous travaillez avec JDOM, vous utilisez souvent plusieurs méthodes -
SAXBuilder.build(xmlSource)() - Construisez le document JDOM à partir de la source xml.
Document.getRootElement() - Récupérez l'élément racine du XML.
Element.getName() - Obtenez le nom du nœud XML.
Element.getChildren() - Obtenez tous les nœuds enfants directs d'un élément.
Node.getChildren(Name) - Obtenez tous les nœuds enfants directs avec un nom donné.
Node.getChild(Name) - Obtenez le premier nœud enfant avec le nom donné.
Étapes à suivre pour utiliser JDOM
Voici les étapes utilisées lors de l'analyse d'un document à l'aide de JDOM Parser.
- Importez des packages liés au XML.
- Créer un SAXBuilder
- Créer un document à partir d'un fichier ou d'un flux
- Extraire l'élément racine
- Examiner les attributs
- Examiner les sous-éléments
Importer des packages liés au XML
import java.io.*;
import java.util.*;
import org.jdom2.*;Créer un DocumentBuilder
SAXBuilder saxBuilder = new SAXBuilder();Créer un document à partir d'un fichier ou d'un flux
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);Extraire l'élément racine
Element classElement = document.getRootElement();Examiner les attributs
//returns specific attribute
getAttribute("attributeName");Examiner les sous-éléments
//returns a list of subelements of specified name
getChildren("subelementName");
//returns a list of all child nodes
getChildren();
//returns first child node
getChild("subelementName");Exemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
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 : 90Exemple de démonstration
Voici le fichier xml d'entrée que nous devons interroger -
<?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();
}
}
}Cela produirait le résultat suivant -
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 :Exemple de démonstration
Voici le fichier XML que nous devons créer -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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>Exemple de démonstration
Voici le fichier texte d'entrée que nous devons modifier -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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 est une API basée sur Java pour analyser un document XML de la même manière que l'analyseur SAX. Mais il y a deux différences majeures entre les deux API -
StAX est une API PULL, tandis que SAX est une API PUSH. Cela signifie que dans le cas de l'analyseur StAX, une application cliente doit demander à l'analyseur StAX d'obtenir des informations à partir de XML chaque fois qu'il en a besoin. Mais dans le cas de l'analyseur SAX, une application client est nécessaire pour obtenir des informations lorsque l'analyseur SAX informe l'application cliente que des informations sont disponibles.
L'API StAX peut lire et écrire des documents XML. En utilisant SAX API, un fichier XML ne peut être lu.
Configuration de l'environnement
Pour utiliser l'analyseur StAX, vous devez avoir stax.jar dans le chemin de classe de votre application.
Voici les fonctionnalités de l'API StAX -
Lit un document XML de haut en bas, en reconnaissant les jetons qui composent un document XML bien formé.
Les jetons sont traités dans le même ordre qu'ils apparaissent dans le document.
Indique au programme d'application la nature des jetons que l'analyseur a rencontrés au fur et à mesure qu'ils se produisent.
Le programme d'application fournit un lecteur "événement" qui agit comme un itérateur et effectue une itération sur l'événement pour obtenir les informations requises. Un autre lecteur disponible est "curseur" qui agit comme un pointeur vers les nœuds XML.
Au fur et à mesure que les événements sont identifiés, les éléments XML peuvent être extraits de l'objet événement et peuvent être traités ultérieurement.
Quand utiliser?
Vous devez utiliser un analyseur StAX lorsque -
Vous pouvez traiter le document XML de manière linéaire de haut en bas.
Le document n'est pas profondément imbriqué.
Vous traitez un très gros document XML dont l'arborescence DOM consommerait trop de mémoire. Les implémentations DOM typiques utilisent dix octets de mémoire pour représenter un octet de XML.
Le problème à résoudre ne concerne qu'une partie du document XML.
Les données sont disponibles dès qu'elles sont vues par l'analyseur, donc StAX fonctionne bien pour un document XML qui arrive sur un flux.
Inconvénients de SAX
Nous n'avons pas d'accès aléatoire à un document XML, car il est traité de manière directe uniquement.
Si vous avez besoin de garder une trace des données que l'analyseur a vues ou où l'analyseur a changé l'ordre des éléments, vous devez alors écrire le code et stocker les données vous-même.
Classe XMLEventReader
Cette classe fournit un itérateur d'événements qui peut être utilisé pour parcourir les événements au fur et à mesure qu'ils se produisent lors de l'analyse d'un document XML.
StartElement asStartElement() - Utilisé pour récupérer la valeur et les attributs d'un élément.
EndElement asEndElement() - Appelé à la fin d'un élément.
Characters asCharacters() - Peut être utilisé pour obtenir des caractères tels que CDATA, espaces blancs, etc.
Classe XMLEventWriter
Cette interface spécifie les méthodes de création d'un événement.
add(Event event) - Ajouter un événement contenant des éléments à XML.
Classe XMLStreamReader
Cette classe fournit un itérateur d'événements qui peut être utilisé pour parcourir les événements au fur et à mesure qu'ils se produisent lors de l'analyse d'un document XML.
int next() - Utilisé pour récupérer le prochain événement.
boolean hasNext() - Utilisé pour vérifier que d'autres événements existent ou non.
String getText() - Utilisé pour obtenir le texte d'un élément.
String getLocalName() - Utilisé pour obtenir le nom d'un élément.
Classe XMLStreamWriter
Cette interface spécifie les méthodes de création d'un événement.
writeStartElement(String localName) - Ajouter un élément de départ du nom donné.
writeEndElement(String localName) - Ajouter un élément de fin de nom donné.
writeAttribute(String localName, String value) - Ecrire des attributs à un élément.
Exemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
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 : studentExemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
Start Element : student
Roll No : 393
First Name: dinkar
Last Name: kad
Nick Name: dinkar
Marks: 85
End Element : studentExemple de démonstration
Voici le XML que nous devons créer -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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>Exemple de démonstration
Voici le XML que nous devons modifier -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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 est une recommandation officielle du World Wide Web Consortium (W3C). Il définit une langue pour rechercher des informations dans un fichier XML. Il est utilisé pour parcourir les éléments et les attributs d'un document XML. XPath fournit différents types d'expressions qui peuvent être utilisées pour rechercher des informations pertinentes dans le document XML.
Qu'est-ce que XPath?
Structure Definations - XPath définit les parties d'un document XML comme les nœuds d'élément, d'attribut, de texte, d'espace de nom, d'instruction de traitement, de commentaire et de document.
Path Expressions - XPath fournit des expressions de chemin puissantes telles que des nœuds de sélection ou une liste de nœuds dans des documents XML.
Standard Functions - XPath fournit une riche bibliothèque de fonctions standard pour la manipulation de valeurs de chaîne, de valeurs numériques, de comparaison de date et d'heure, de manipulation de nœuds et de QName, de manipulation de séquences, de valeurs booléennes, etc.
Major part of XSLT - XPath est l'un des éléments majeurs du standard XSLT et il faut avoir une connaissance suffisante de XPath pour travailler avec des documents XSLT.
W3C recommendation - XPath est la recommandation officielle du World Wide Web Consortium (W3C).
Expressions XPath
XPath utilise une expression de chemin pour sélectionner un nœud ou une liste de nœuds à partir d'un document XML. Voici une liste de chemins et d'expressions utiles pour sélectionner n'importe quel nœud / liste de nœuds à partir d'un document XML.
| Sr.No. | Expression et description |
|---|---|
| 1 | node-name Sélectionnez tous les nœuds avec le nom donné "nodename" |
| 2 | / La sélection commence à partir du nœud racine |
| 3 | // La sélection commence à partir du nœud actuel qui correspond à la sélection |
| 4 | . Sélectionne le nœud actuel |
| 5 | .. Sélectionne le parent du nœud actuel |
| 6 | @ Sélectionne les attributs |
| sept | student Example - Sélectionne tous les nœuds avec le nom "étudiant" |
| 8 | class/student Example - Sélectionne tous les éléments étudiants qui sont des enfants de la classe |
| 9 | //student Sélectionne tous les éléments de l'élève, peu importe où ils se trouvent dans le document |
Prédicats
Les prédicats sont utilisés pour trouver un nœud spécifique ou un nœud contenant une valeur spécifique et sont définis à l'aide de [...].
| Expression | Résultat |
|---|---|
| / classe / étudiant [1] | Sélectionne le premier élément étudiant qui est l'enfant de l'élément classe. |
| / classe / étudiant [dernier ()] | Sélectionne le dernier élément étudiant qui est l'enfant de l'élément classe. |
| / classe / étudiant [dernier () - 1] | Sélectionne le dernier mais un élément étudiant qui est l'enfant de l'élément classe. |
| // étudiant [@rollno = '493'] | Sélectionne tous les éléments étudiants qui ont un attribut nommé rollno avec une valeur de '493' |
Étapes à suivre pour utiliser XPath
Voici les étapes utilisées lors de l'analyse d'un document à l'aide de XPath Parser.
Importez des packages liés au XML.
Créez un DocumentBuilder.
Créez un document à partir d'un fichier ou d'un flux.
Créez un objet Xpath et une expression de chemin XPath.
Compilez l'expression XPath en utilisant XPath.compile() et obtenez une liste de nœuds en évaluant l'expression compilée via XPath.evaluate().
Parcourez la liste des nœuds.
Examinez les attributs.
Examinez les sous-éléments.
Importer des packages liés au XML
import org.w3c.dom.*;
import org.xml.sax.*;
import javax.xml.parsers.*;
import javax.xml.xpath.*;
import java.io.*;Créer un DocumentBuilder
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();Créer un document à partir d'un fichier ou d'un flux
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);Construire XPath
XPath xPath = XPathFactory.newInstance().newXPath();Préparez l'expression de chemin et évaluez-la
String expression = "/class/student";
NodeList nodeList = (NodeList) xPath.compile(expression).evaluate(
doc, XPathConstants.NODESET);Itérer sur NodeList
for (int i = 0; i < nodeList.getLength(); i++) {
Node nNode = nodeList.item(i);
...
}Examiner les attributs
//returns specific attribute
getAttribute("attributeName");
//returns a Map (table) of names/values
getAttributes();Examiner les sous-éléments
//returns a list of subelements of specified name
getElementsByTagName("subelementName");
//returns a list of all child nodes
getChildNodes();Exemple de démonstration
Voici le fichier texte d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
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 : 90Exemple de démonstration
Voici le fichier texte d'entrée que nous devons interroger -
<?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();
}
}
}Cela produirait le résultat suivant -
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
Nick Name : vinni
Marks : 95XPath 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 est une bibliothèque open source basée sur Java pour analyser les documents XML. Il s'agit d'une API hautement flexible et économe en mémoire. Il est optimisé pour Java et utilise des collections Java telles que List et Arrays.
DOM4J fonctionne avec DOM, SAX, XPath et XSLT. Il peut analyser de gros documents XML avec une très faible empreinte mémoire.
Configuration de l'environnement
Pour utiliser l'analyseur DOM4J, vous devez avoir dom4j-1.6.1.jar et jaxen.jar dans le chemin de classe de votre application. Téléchargez dom4j-1.6.1.zip.
Quand utiliser?
Vous devez utiliser un analyseur DOM4J lorsque -
Vous devez en savoir beaucoup sur la structure d'un document XML.
Vous devez déplacer des parties d'un document XML (vous voudrez peut-être trier certains éléments, par exemple).
Vous devez utiliser les informations d'un document XML plusieurs fois.
Vous êtes un développeur Java et souhaitez exploiter l'analyse syntaxique de XML optimisée pour Java.
Ce que vous obtenez?
Lorsque vous analysez un document XML avec un analyseur DOM4J, vous avez la possibilité de récupérer une arborescence contenant tous les éléments de votre document sans affecter l'empreinte mémoire de l'application.
DOM4J fournit une variété de fonctions utilitaires que vous pouvez utiliser pour examiner le contenu et la structure d'un document XML au cas où le document serait bien structuré et sa structure connue.
DOM4J utilise l'expression XPath pour naviguer dans un document XML.
Avantages
DOM4J offre aux développeurs Java la flexibilité et la facilité de maintenance du code d'analyse XML. C'est une API légère et rapide.
Classes DOM4J
DOM4J définit plusieurs classes Java. Voici les classes les plus courantes -
Document- Représente l'intégralité du document XML. Un objet Document est souvent appelé une arborescence DOM.
Element- Représente un élément XML. L'objet Element a des méthodes pour manipuler ses éléments enfants, son texte, ses attributs et ses espaces de noms.
Attribute- Représente un attribut d'un élément. L'attribut a une méthode pour obtenir et définir la valeur de l'attribut. Il a le type de parent et d'attribut.
Node - Représente l'élément, l'attribut ou l'instruction de traitement.
Méthodes DOM4J courantes
Lorsque vous travaillez avec le DOM4J, il existe plusieurs méthodes que vous utiliserez souvent -
SAXReader.read(xmlSource)() - Construisez le document DOM4J à partir d'une source XML.
Document.getRootElement() - Récupère l'élément racine d'un document XML.
Element.node(index) - Obtenez le nœud XML à un index particulier dans un élément.
Element.attributes() - Obtenez tous les attributs d'un élément.
Node.valueOf(@Name) - Récupère les valeurs d'un attribut avec le nom donné d'un élément.
Étapes à suivre pour utiliser DOM4J
Voici les étapes utilisées lors de l'analyse d'un document à l'aide de l'analyseur DOM4J.
Importez des packages liés au XML.
Créez un SAXReader.
Créez un document à partir d'un fichier ou d'un flux.
Obtenez les nœuds requis à l'aide de XPath Expression en appelant document.selectNodes ()
Extrayez l'élément racine.
Parcourez la liste des nœuds.
Examinez les attributs.
Examinez les sous-éléments.
Importer des packages liés au XML
import java.io.*;
import java.util.*;
import org.dom4j.*;Créer un DocumentBuilder
SAXBuilder saxBuilder = new SAXBuilder();Créer un document à partir d'un fichier ou d'un flux
File inputFile = new File("input.txt");
SAXBuilder saxBuilder = new SAXBuilder();
Document document = saxBuilder.build(inputFile);Extraire l'élément racine
Element classElement = document.getRootElement();Examiner les attributs
//returns specific attribute
valueOf("@attributeName");Examiner les sous-éléments
//returns first child node
selectSingleNode("subelementName");Exemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
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 : 90Exemple de démonstration
Voici le fichier xml d'entrée que nous devons analyser -
<?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();
}
}
}Cela produirait le résultat suivant -
Root element :class
----------------------------
Current Element :student
Student roll no : 493
First Name : Vaneet
Last Name : Gupta
First Name : vinni
Marks : 95Exemple de démonstration
Voici le XML que nous devons créer -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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>Exemple de démonstration
Voici le XML que nous devons modifier -
<?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();
}
}
}Cela produirait le résultat suivant -
<?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>