StAX: So parst man XML-Code mit Java

Peter Mikhalenko

13. August 2008

1 Kommentar

Empfehlen

Beispielcode

Der folgende Code liest die XML-Datei und schickt den Inhalt der Beispieldatei an die Standardausgabe:

package test.xml;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.InputStream;
import javax.xml.stream.XMLEventReader;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.XMLEvent;
public class TestEventStaX {
private String configFile;
public void setFile(String configFile) {
this.configFile = configFile;
}
public void readConfig() {
try {
// zuerst eine neue XMLInputFactory erstellen
XMLInputFactory inputFactory = XMLInputFactory.newInstance();
// einen neuen eventReader einrichten
InputStream in = new FileInputStream(configFile);
XMLEventReader eventReader = inputFactory.createXMLEventReader(in);
// das XML-Dokument lesen
while (eventReader.hasNext()) {
XMLEvent event = eventReader.nextEvent();
if (event.isStartElement()) {
if (event.asStartElement().getName().getLocalPart() == ("port")) {
event = eventReader.nextEvent();
System.out.println(event.asCharacters().getData());
continue;
}
if (event.asStartElement().getName().getLocalPart() == ("baud")) {
event = eventReader.nextEvent();
System.out.println(event.asCharacters().getData());
continue;
}
if (event.asStartElement().getName().getLocalPart() == ("bit")) {
event = eventReader.nextEvent();
System.out.println(event.asCharacters().getData());
continue;
}
if (event.asStartElement().getName().getLocalPart() == ("parity")) {
event = eventReader.nextEvent();
System.out.println(event.asCharacters().getData());
continue;
}
}
}
} catch (FileNotFoundException e) {
e.printStackTrace();
} catch (XMLStreamException e) {
e.printStackTrace();
}
}
public static void main(String args[]) {
TestEventStaX read = new TestEventStaX();
read.setFile("root.xml");
read.readConfig();
}
}

Mehr zu ...

Um denselben Inhalt in die Datei rootfile2.xml zu schreiben, bietet sich diese Möglichkeit an:

package test.xml;
import java.io.FileOutputStream;
import javax.xml.stream.XMLEventFactory;
import javax.xml.stream.XMLEventWriter;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.events.Characters;
import javax.xml.stream.events.EndElement;
import javax.xml.stream.events.StartDocument;
import javax.xml.stream.events.StartElement;
import javax.xml.stream.events.XMLEvent;
public class WriteConfigFile {
private String configFile;
public void setFile(String configFile) {
this.configFile = configFile;
}
public void saveConfig() throws Exception {
// eine XMLOutputFactory erstellen
XMLOutputFactory outputFactory = XMLOutputFactory.newInstance();
// einen XMLEventWriter erstellen
XMLEventWriter eventWriter = outputFactory
.createXMLEventWriter(new FileOutputStream(configFile));
// eine EventFactory erstellen
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
XMLEvent end = eventFactory.createDTD("n");
// Start-Tag erstellen und schreiben
StartDocument startDocument = eventFactory.createStartDocument();
eventWriter.add(startDocument);
// config open tag erstellen
StartElement configStartElement = eventFactory.createStartElement("",
"", "config");
eventWriter.add(configStartElement);
eventWriter.add(end);
// die einzelnen Knoten schreiben
createNode(eventWriter, "port", "1");
createNode(eventWriter, "baud", "9600");
createNode(eventWriter, "bit", "1");
createNode(eventWriter, "parity", "0");
eventWriter.add(eventFactory.createEndElement("", "", "root"));
eventWriter.add(end);
eventWriter.add(eventFactory.createEndDocument());
eventWriter.close();
}
private void createNode(XMLEventWriter eventWriter, String name,
String value) throws XMLStreamException {
XMLEventFactory eventFactory = XMLEventFactory.newInstance();
XMLEvent end = eventFactory.createDTD("n");
XMLEvent tab = eventFactory.createDTD("t");
// Start-Knoten erstellen
StartElement sElement = eventFactory.createStartElement("", "", name);
eventWriter.add(tab);
eventWriter.add(sElement);
// Inhalt erstellen
Characters characters = eventFactory.createCharacters(value);
eventWriter.add(characters);
// End-Knoten erstellen
EndElement eElement = eventFactory.createEndElement("", "", name);
eventWriter.add(eElement);
eventWriter.add(end);
}
/**
* @param args
*/
public static void main(String[] args) {
WriteConfigFile configFile = new WriteConfigFile();
configFile.setFile("rootfile2.xml");
try {
configFile.saveConfig();
} catch (Exception e) {
e.printStackTrace();
}
}
}

Der Konstruktionsprozess für XML hat Ähnlichkeit mit dem DOM-Konzept, unterscheidet sich aber doch ein wenig davon. Der Code dürfte selbsterklärend sein.

Inhalt

Teil 1: StAX: So parst man XML-Code mit Java
Teil 2: Beispielcode
Teil 3: Die Cursor-API
Teil 4: XML-Code schreiben

Fanden Sie diesen Artikel nützlich?
3 von 5 Lesern fanden diesen Artikel nützlich.

Lesermeinungen zum Artikel

Kommentar verfassen

von Det

am 2. Juni 2009, 13:58 Uhr

Unleserliche Codepräsentation macht den Artikel zu einer Qual

Hallo,

dieser Artikel könnte vielleicht sehr nützlich sein (ich hätte die Info für ein Terminprojekt gerade dringend gebrauchen können).

Leider habe ich keine Lust, jedes Codebeispiel erst aus dem Scroll-Feld herauszukopieren und durch einen Beautifyer zu schicken, damit ich das Ganze nachvollziehen kann.

Wenn der Artikel bspw. auch druckbar sein soll, dann sollte man den Code schon qualifizierter präsentieren. Im Druck wird 1.) die Schmalspaltensicht beibehalten und zum Anderen nur der Viewport gezeigt. Alles andere wird abgeschnitten.

Diese Codepräsentation finde ich auf einer IT-lastigen Site wie ZDNet doch eher lächerlich!

Auf diesen Kommentar antworten