Apache Xerces - szybki przewodnik
Co to jest XML?
XML to prosty język tekstowy, który został zaprojektowany do przechowywania i przesyłania danych w formacie zwykłego tekstu. To oznacza Extensible Markup Language. Poniżej przedstawiono niektóre z najważniejszych funkcji XML.
XML to język znaczników.
XML jest językiem opartym na znacznikach, takim jak HTML.
Tagi XML nie są predefiniowane, jak HTML.
Możesz zdefiniować własne tagi, dlatego nazywa się to językiem rozszerzalnym.
Znaczniki XML mają być samoopisowe.
XML to zalecenie W3C dotyczące przechowywania i transportu danych.
Przykład
<?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>Zalety
Oto zalety zapewniane przez XML -
Technology agnostic- Będąc zwykłym tekstem, XML jest niezależny od technologii. Może być używany przez dowolną technologię do przechowywania i przesyłania danych.
Human readable- XML używa prostego formatu tekstowego. Jest czytelny i zrozumiały dla człowieka.
Extensible - W XML można bardzo łatwo tworzyć i używać niestandardowych tagów.
Allow Validation - Używając XSD, DTD i struktury XML można łatwo zweryfikować.
Niedogodności
Poniżej przedstawiono wady używania XML -
Redundant Syntax - Zwykle plik XML zawiera wiele powtarzających się terminów.
Verbose - Będąc językiem rozwlekłym, rozmiar pliku XML zwiększa koszty transmisji i przechowywania.
W tym rozdziale omówiono proces konfiguracji Apache Xerces w systemach opartych na systemach Windows i Linux. Apache Xerces można łatwo zainstalować i zintegrować z aktualnym środowiskiem Java, wykonując kilka prostych kroków bez żadnych skomplikowanych procedur konfiguracyjnych. Administracja użytkownikami jest wymagana podczas instalacji.
wymagania systemowe
| JDK | Java SE 2 JDK 1.5 lub nowsza |
| Pamięć | 1 GB RAM (zalecane) |
| Miejsca na dysku | Brak minimalnych wymagań |
| Wersja systemu operacyjnego | Windows XP lub nowszy, Linux |
Przejdźmy teraz do kroków instalacji Apache Xerces.
Krok 1: Zweryfikuj instalację Java
Przede wszystkim musisz mieć zainstalowany zestaw Java Software Development Kit (SDK) w swoim systemie. Aby to sprawdzić, wykonaj dowolne z dwóch poleceń w zależności od platformy, na której pracujesz.
Jeśli instalacja Java zakończy się powodzeniem, zostanie wyświetlona aktualna wersja i specyfikacja instalacji Java. Przykładowe dane wyjściowe podano w poniższej tabeli.
| Platforma | Komenda | Przykładowe wyjście |
|---|---|---|
| Windows | Otwórz konsolę poleceń i wpisz: java -version | Java wersja „1.7.0_60” Java (TM) SE Run Time Environment (kompilacja 1.7.0_60-b19) Java Hotspot (TM) 64-bitowa maszyna wirtualna serwera (wersja 24.60b09, tryb mieszany) |
| Linux | Otwórz terminal poleceń i wpisz: $ java -version | Wersja Java „1.7.0_25” Open JDK Runtime Environment (rhel-2.3.10.4.el6_4-x86_64) Open JDK 64-bit Server VM (build 23.7-b01, tryb mieszany) |
Zakładamy, że czytelnicy tego samouczka mają zainstalowany pakiet Java SDK w wersji 1.7.0_60 w swoim systemie.
Jeśli nie masz Java SDK, pobierz jego aktualną wersję z https://www.oracle.com/technetwork/java/javase/downloads/index.html i zainstaluj.
Krok 2: Skonfiguruj środowisko Java
Ustaw zmienną środowiskową JAVA_HOME, aby wskazywała lokalizację katalogu podstawowego, w którym na komputerze jest zainstalowana Java. Na przykład,
| Sr.No. | Platforma i opis |
|---|---|
| 1 | Windows Ustaw JAVA_HOME na C: \ ProgramFiles \ java \ jdk1.7.0_60 |
| 2 | Linux Eksportuj JAVA_HOME = / usr / local / java-current |
Dołącz pełną ścieżkę lokalizacji kompilatora Java do ścieżki systemowej.
| Sr.No. | Platforma i opis |
|---|---|
| 1 | Windows Dołącz ciąg „C: \ Program Files \ Java \ jdk1.7.0_60 \ bin” na końcu zmiennej systemowej PATH. |
| 2 | Linux Export PATH = $ PATH: $ JAVA_HOME / bin / |
Wykonaj polecenie w wersji java z wiersza polecenia, jak wyjaśniono powyżej.
Krok 3: Zainstaluj bibliotekę Apache Xerces
Pobierz najnowszą wersję Apache Xerces z https://xerces.apache.org/mirrors.cgi"i rozpakuj jego zawartość do folderu, z którego wymagane biblioteki można połączyć z programem Java. Załóżmy, że pliki są zebrane w folderze xerces-2_11_0 na dysku C.
Dodaj pełną ścieżkę pięciu słoików, jak zaznaczono na powyższym obrazku, do CLASSPATH.
| Sr.No. | Platforma i opis |
|---|---|
| 1 | Windows Dołącz następujące ciągi na końcu zmiennej użytkownika CLASSPATH - C: \ xerces-2_11_0 \ resolver.jar; C: \ xerces-2_11_0 \ serializer.jar; C: \ xerces-2_11_0 \ xercesImpl.jar; C: \ xerces-2_11_0 \ xercesSamples.jar; C: \ xerces-2_11_0 \ xml-apis.jar; |
| 2 | Linux Eksportuj CLASSPATH = $ CLASSPATH - /usr/share/xerces-2_11_0\resolver.jar; /usr/share/xerces-2_11_0\serializer.jar; /usr/share/xerces-2_11_0\xercesImpl.jar; /usr/share/xerces-2_11_0\xercesSamples.jar; /usr/share/xerces-2_11_0\xml-apis.jar; |
Czym jest Apache Xerces2?
Xerces2 to procesor oparty na Javie i zapewnia standardowe interfejsy i implementacje dla następujących standardów API analizy składni XML -
Document Object Model (DOM) Poziom 3
Prosty interfejs API dla XML (SAX) 2.0.2
Streaming API for XML (StAX) 1.0 Event API
Java API do przetwarzania XML (JAXP) 1.4
Co to jest analizowanie XML?
Parsowanie XML oznacza przeglądanie dokumentu XML w celu uzyskania dostępu do danych lub zmodyfikowania danych w ten lub inny sposób.
Co to jest parser XML?
Parser XML umożliwia dostęp do danych zawartych w dokumencie XML lub modyfikowanie ich. Java udostępnia wiele opcji analizowania dokumentu XML. Poniżej przedstawiono różne typy parserów, które są powszechnie używane do analizowania dokumentów XML.
Dom Parser - Analizuje dokument, ładując całą zawartość dokumentu i tworząc w pamięci jego pełne drzewo hierarchiczne.
SAX Parser- Analizuje dokument na podstawie wyzwalaczy opartych na zdarzeniach. Nie ładuje całego dokumentu do pamięci.
StAX Parser - Analizuje dokument w podobny sposób jak parser SAX, ale w bardziej efektywny sposób.
Teraz omówimy każdy parser przy użyciu biblioteki Apache Xerces w kolejnych rozdziałach.
Model obiektu dokumentu jest oficjalną rekomendacją konsorcjum World Wide Web Consortium (W3C). Definiuje interfejs, który umożliwia programom uzyskiwanie dostępu i aktualizowanie stylu, struktury i zawartości dokumentów XML. Parsery XML obsługujące DOM implementują ten interfejs.
Kiedy użyć?
Powinieneś używać parsera DOM, gdy -
Musisz dużo wiedzieć o strukturze dokumentu.
Musisz przesuwać części dokumentu (możesz na przykład posortować pewne elementy).
Musisz użyć informacji zawartych w dokumencie więcej niż raz.
Co dostałeś?
Kiedy parsujesz dokument XML za pomocą parsera DOM, otrzymujesz strukturę drzewa, która zawiera wszystkie elementy twojego dokumentu. DOM zapewnia różnorodne funkcje, których możesz użyć do zbadania zawartości i struktury dokumentu.
Zalety
DOM to wspólny interfejs do manipulowania strukturami dokumentów. Jednym z jego celów projektowych jest to, że kod Java napisany dla jednego parsera zgodnego z DOM powinien działać na każdym innym parserze zgodnym z DOM bez zmian.
Interfejsy DOM
DOM definiuje kilka interfejsów Java. Oto najpopularniejsze interfejsy -
Node - Podstawowy typ danych DOM.
Element - Zdecydowana większość obiektów, którymi będziesz się zajmować, to elementy.
Attr - Reprezentuje atrybut elementu.
Text - rzeczywista zawartość elementu lub atrybutu.
Document- Reprezentuje cały dokument XML. Obiekt Document jest często nazywany drzewem DOM.
Popularne metody DOM
Podczas pracy z DOM istnieje kilka często używanych metod:
Document.getDocumentElement() - Zwraca element główny dokumentu.
Node.getFirstChild() - Zwraca pierwsze dziecko podanego węzła.
Node.getLastChild() - zwraca ostatnie dziecko danego węzła.
Node.getNextSibling() - Te metody zwracają następny element równorzędny danego węzła.
Node.getPreviousSibling() - Te metody zwracają poprzedni element równorzędny danego węzła.
Node.getAttribute(attrName) - Dla danego węzła zwraca atrybut o żądanej nazwie.
Kroki korzystania z DOM
Poniżej przedstawiono kroki używane podczas analizowania dokumentu przy użyciu analizatora DOM Parser.
Importuj pakiety związane z XML.
Utwórz DocumentBuilder
Utwórz dokument z pliku lub strumienia
Wyodrębnij element główny
Zbadaj atrybuty
Zbadaj elementy podrzędne
Importuj pakiety związane z XML
import org.w3c.dom.*;
import javax.xml.parsers.*;
import java.io.*;Utwórz DocumentBuilder
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
DocumentBuilder builder = factory.newDocumentBuilder();Utwórz dokument z pliku lub strumienia
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);Wyodrębnij element główny
Element root = document.getDocumentElement();Zbadaj atrybuty
//returns specific attribute
getAttribute("attributeName");
//returns a Map (table) of names/values
getAttributes();Zbadaj elementy podrzędne
//returns a list of subelements of specified name
getElementsByTagName("subelementName");
//returns a list of all child nodes
getChildNodes();Demo Example
Oto wejściowy plik xml, który musimy przeanalizować -
<?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>Vineet</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>Przykład demo
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();
}
}
}Powyższy program wygeneruje następujący wynik -
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 : Vineet
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 : 90Przykład demo
Oto wejściowy plik xml, który musimy zapytać -
<?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>Przykład demo
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();
}
}
}Powyższy program wygeneruje następujący wynik -
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 :Przykład demo
Oto plik XML, który musimy utworzyć -
<?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>Przykład demo
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();
}
}
}Powyższy program wygeneruje następujący wynik -
<?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>Przykład demo
Oto wejściowy plik xml, który musimy zmodyfikować -
<?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>Przykład demo
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.txt");
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();
}
}
}Powyższy program wygeneruje następujący wynik -
-----------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) to oparty na zdarzeniach parser dla dokumentów xml. W przeciwieństwie do parsera DOM, parser SAX nie tworzy drzewa parsowania. SAX jest interfejsem strumieniowym dla XML, co oznacza, że aplikacje korzystające z SAX otrzymują powiadomienia o zdarzeniach o przetwarzanym dokumencie XML - elemencie i atrybucie, naraz w kolejności od początku dokumentu do zamknięcia element ROOT.
Odczytuje dokument XML od góry do dołu, rozpoznając tokeny, które składają się na dobrze sformułowany dokument XML.
Tokeny są przetwarzane w tej samej kolejności, w jakiej pojawiają się w dokumencie.
Podaje program aplikacji, charakter tokenów napotkanych przez parser w momencie ich wystąpienia.
Aplikacja zapewnia obsługę „zdarzenia”, którą należy zarejestrować w parserze.
Gdy tokeny są identyfikowane, wywoływane są metody wywołania zwrotnego w module obsługi z odpowiednimi informacjami.
Kiedy użyć?
Powinieneś użyć parsera SAX, gdy -
Możesz przetwarzać dokument XML w sposób liniowy od góry do dołu.
Dokument nie jest głęboko zagnieżdżony.
Przetwarzasz bardzo duży dokument XML, którego drzewo DOM będzie wymagało dużo pamięci. Typowe implementacje DOM używają dziesięciu bajtów pamięci do reprezentowania jednego bajtu XML.
Problem do rozwiązania dotyczy tylko części dokumentu XML.
Dane są dostępne, gdy tylko zostaną odczytane przez parser, więc SAX działa dobrze w przypadku dokumentu XML, który pojawia się w strumieniu.
Wady SAX
Nie mamy losowego dostępu do dokumentu XML, ponieważ jest on przetwarzany tylko do przodu.
Jeśli chcesz śledzić dane, które parser widział lub zmienić kolejność elementów, musisz samodzielnie napisać kod i przechowywać dane.
Interfejs ContentHandler
Ten interfejs określa metody wywołania zwrotnego, których parser SAX używa do powiadamiania programu aplikacji o składnikach dokumentu XML, które widział.
void startDocument() - Wywołane na początku dokumentu.
void endDocument() - Wywołane na początku dokumentu.
void startElement(String uri, String localName, String qName, Attributes atts) - Wywoływane na początku elementu.
void endElement(String uri, String localName,String qName) - Wywoływane na końcu elementu.
void characters(char[] ch, int start, int length) - Wywoływane w przypadku napotkania danych znaku.
void ignorableWhitespace( char[] ch, int start, int length) - Wywoływane, gdy obecne jest DTD i napotkano ignorowalne białe znaki.
void processingInstruction(String target, String data) - Wywoływane, gdy rozpoznana zostanie instrukcja przetwarzania.
void setDocumentLocator(Locator locator)) - Zapewnia lokalizator, którego można użyć do identyfikacji pozycji w dokumencie.
void skippedEntity(String name) - Wywoływane w przypadku napotkania nierozwiązanej jednostki.
void startPrefixMapping(String prefix, String uri) - Wywoływane, gdy zdefiniowano nowe mapowanie przestrzeni nazw.
void endPrefixMapping(String prefix) - Wywoływana, gdy definicja przestrzeni nazw kończy swój zakres.
Interfejs atrybutów
Ten interfejs określa metody przetwarzania atrybutów połączonych z elementem.
int getLength() - Zwraca liczbę atrybutów.
String getQName(int index)
String getValue(int index)
String getValue(String qname)
Przykład demo
Oto wejściowy plik xml, który musimy przeanalizować -
<?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>Vineet</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>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;
}
}
}Powyższy program wygeneruje następujący wynik -
Roll No : 393
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element :student
Roll No : 493
First Name: Vineet
Last Name: Gupta
Nick Name: Vinni
Marks: 95
End Element :student
Roll No : 593
First Name: Jasvir
Last Name: Singh
Nick Name: Jazz
Marks: 90
End Element :studentPrzykład demo
Oto wejściowy plik tekstowy, którego potrzebujemy, aby zapytać o rolkę nr: 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>Vineet</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>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;
}
}
}Powyższy program wygeneruje następujący wynik -
Start Element :student
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element :studentLepiej jest używać parsera StAX do tworzenia XML niż parsera SAX. Zobacz sekcję Java StAX Parser.
Przykład demo
Oto wejściowy plik xml, który musimy zmodyfikować, dołączając <Result>Pass<Result/> na końcu </marks> tag.
<?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>Vineet</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>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");
}
}
}Powyższy program wygeneruje następujący wynik -
<?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>
Vineet
</firstname>
<lastname>
Gupta
</lastname>
<nickname>
Vinni
</nickname>
<marks>
95
</marks>
<Result>
Pass
</Result>
</student>
<student rollno = "593">
<firstname>
Jasvir
</firstname>
<lastname>
Singh
</lastname>
<nickname>
Jazz
</nickname>
<marks>
90
</marks>
<Result>
Pass
</Result>
</student>
</class>StAX jest interfejsem API opartym na JAVA do analizowania dokumentów XML w podobny sposób jak parser SAX. Istnieją jednak dwie główne różnice między tymi dwoma interfejsami API -
StAX to PULL API, natomiast SAX to PUSH API. Oznacza to, że w przypadku parsera StAX aplikacja kliencka musi poprosić parser StAX o pobranie informacji z XML, gdy zajdzie taka potrzeba, ale w przypadku parsera SAX aplikacja kliencka musi uzyskać informacje, gdy parser SAX powiadomi aplikację kliencką o tych informacjach jest dostępny.
StAX API może czytać i zapisywać dokumenty XML. Używając SAX API, XML można tylko czytać.
Oto cechy StAX API -
Odczytuje dokument XML od góry do dołu, rozpoznając tokeny, które składają się na dobrze sformułowany dokument XML.
Tokeny są przetwarzane w tej samej kolejności, w jakiej pojawiają się w dokumencie.
Informuje aplikację o naturze tokenów napotkanych przez analizator składni w momencie ich wystąpienia.
Aplikacja zapewnia czytnik „zdarzeń”, który działa jako iterator i wykonuje iterację po zdarzeniu, aby uzyskać wymagane informacje. Innym dostępnym czytnikiem jest czytnik „kursora”, który działa jako wskaźnik do węzłów xml.
Gdy zdarzenia są identyfikowane, elementy xml mogą być pobierane z obiektu zdarzenia i mogą być dalej przetwarzane.
Kiedy użyć?
Powinieneś użyć parsera StAX, gdy -
Możesz przetwarzać dokument XML w sposób liniowy od góry do dołu.
Dokument nie jest głęboko zagnieżdżony.
Przetwarzasz bardzo duży dokument XML, którego drzewo DOM będzie zużywać zbyt dużo pamięci. Typowe implementacje DOM używają dziesięciu bajtów pamięci do reprezentowania jednego bajtu XML.
Problem do rozwiązania dotyczy tylko części dokumentu XML.
Dane są dostępne, gdy tylko zostaną zobaczone przez parser, więc StAX działa dobrze dla dokumentu XML, który dociera do strumienia.
Wady SAX
Nie mamy losowego dostępu do dokumentu XML, ponieważ jest on przetwarzany tylko do przodu.
Jeśli chcesz śledzić dane, które parser widział lub zmienić kolejność elementów, musisz samodzielnie napisać kod i przechowywać dane.
Klasa XMLEventReader
Ta klasa zapewnia iterator zdarzeń, które mogą być używane do iteracji po zdarzeniach podczas ich przetwarzania podczas analizowania dokumentu XML
StartElement asStartElement() - Służy do pobierania wartości i atrybutów elementu.
EndElement asEndElement() - Wywoływane na końcu elementu.
Characters asCharacters() - Może służyć do uzyskiwania znaków, takich jak CDATA, białe znaki itp.
Klasa XMLEventWriter
Ten interfejs określa metody tworzenia zdarzenia.
add(Event event) - Dodaje zdarzenie zawierające elementy do XML.
Klasa XMLStreamReader
Ta klasa zapewnia iterator zdarzeń, które mogą być używane do iteracji po zdarzeniach podczas ich przetwarzania podczas analizowania dokumentu XML
int next() - Służy do pobierania następnego zdarzenia.
boolean hasNext() - Używany do sprawdzania, czy istnieją dalsze wydarzenia, czy nie
String getText() - Służy do pobierania tekstu elementu
String getLocalName() - Używany do uzyskania nazwy elementu
Klasa XMLStreamWriter
Ten interfejs określa metody tworzenia zdarzenia.
writeStartElement(String localName) - Dodaje element początkowy o podanej nazwie.
writeEndElement(String localName) - Dodaje element końcowy do podanej nazwy.
writeAttribute(String localName, String value) - Zapisuje atrybut do elementu.
Przykład demo
Oto wejściowy plik xml, który musimy przeanalizować -
<?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>Vineet</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>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();
}
}
}Powyższy program wygeneruje następujący wynik -
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: Vineet
Last Name: Gupta
Nick Name: Vinni
Marks: 95
End Element : student
Start Element : student
Roll No : 593
First Name: Jasvir
Last Name: Singh
Nick Name: Jazz
Marks: 90
End Element : studentPrzykład demo
Oto wejściowy plik xml, który musimy przeanalizować -
<?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>Vineet</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>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();
}
}
}Powyższy program wygeneruje następujący wynik -
Start Element : student
Roll No : 393
First Name: Dinkar
Last Name: Kad
Nick Name: Dinkar
Marks: 85
End Element : studentPrzykład demo
Here is the XML we need to create −
<?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>Przykład demo
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();
}
}
}Powyższy program wygeneruje następujący wynik -
<?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>Przykład demo
Aby uruchomić ten przykład, w ścieżce klas aplikacji powinien znajdować się plik jdom.jar. Pobierz jdom-2.0.5.zip.
Oto plik XML, który musimy zmodyfikować -
<?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>Vineet</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>Przykład demo
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();
}
}
}Powyższy program wygeneruje następujący wynik -
<student rollno = "393">
<firstname>Dinkar</firstname>
<lastname>Kad</lastname>
<nickname>Dinkar</nickname>
<marks>80</marks>
</student>
<student rollno = "493">
<firstname>Vineet</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>