XML-Parser fu r kleine XML

Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
XML-Parser fur kleine XML-Container
Gruppe 10:
Beiglböck Thomas
0726784
Fuker Wolfgang
0725381
Pichler Markus
0726556
Seite 1 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Inhaltsverzeichnis
Inhaltsverzeichnis .................................................................................................................................... 2
Aufgabenstellung..................................................................................................................................... 3
Einführung und Überblick........................................................................................................................ 4
Spezifikation der Testumgebung ............................................................................................................. 6
Ergebnisauswertung und Interpretationen ............................................................................................. 9
Fazit und Schlusswort ............................................................................................................................ 12
Anhang mit Sourcecode ........................................................................................................................ 13
Seite 2 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Aufgabenstellung
Gesucht wird ein nicht kommerzieller XML-Parser, der kleine XML-Container Dateien
möglichst schnell parst. Weiters soll eine Testumgebung geschaffen werden, um einige frei
erhältlichen Parser zu testen. Anschließend sollen die Testergebnisse ausgewertet werden
und der schnellste XML-Parser eruiert werden.
Seite 3 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Einführung und Überblick
XML bedeutet Extensible Markup Language und ist eine auszeichnende Metasprache die
dazu verwendet wird, hierarchisch strukturierte Datensätze in Form von Text darzustellen.
XML ist plattformunabhängig. Primär verwendet man XML, um Datensätze zwischen
Computersystemen die über ein Netzwerk (LAN, WAN, Internet) verbunden sind,
auszutauschen. XML ist von Computern und Menschen lesbar. Die Syntax, die Grammatik,
die Struktur und die Bedeutung der zu generierenden Sprache wird mit einer DTD
(Document Type Definition) oder einem XML-Schema definiert. Zusätzlich ist die Darstellung
und das Layout der Informationen vom Inhalt des XML-Dokumentes getrennt. Dazu dienen
sogenannte XSL-Dateien (Extensible Style Language).
Ein XML-Parser “liest“ das XML-Dokument komplett durch und stellt die enthaltenen
Informationen (Elemente, Attribute, usw.), zum Beispiel einer Anwendung zur Verfügung.
XML-Parser können selbst geschrieben werden, wodurch man die Möglichkeit hat, auf die
eigenen Wünsche konkreter einzugehen und somit den Pars-Vorgang optimieren kann oder
es wird ein existierender, kommerzieller oder frei lizensierter Parser benutzt. XML-Parser
Schnittstellen (SAX, DOM) sind größtenteils standardisiert.
Es gibt zwei Aspekte wodurch XML-Parser klassifiziert werden:

Validierende / Nicht validierende:
Ein validierender Parser untersucht das zu parsende XML-Dokument ob es
DTD konform und wohlgeformt (die Regeln des Standards befolgt, korrekte
Schachtelung, kurz: die Regeln von XML befolgt) ist. Wenn dies zutrifft so ist
es valide/gültig. Nachteil bei validierenden XML-Parsern ist, dass der
Validierungsvorgang zeitaufwändig ist.
Ein nicht-validierender Parser prüft nur ob das XML-Dokument wohlgeformt
ist. (keine Überprüfung der DTD). Dieser sollte nur verwendet werden, wenn
anderweitig garantiert werden kann, dass das zu parsende XML-Dokument
valide ist.
Seite 4 von 24
Beiglböck, Fuker, Pichler

Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
SAX (= Simple API for XML) / DOM (Document Object Model):
Bei SAX Parsern (eher für Lesen und Ausgeben eingesetzt) werden Events
ausgelöst, wenn ein Konstrukt (Kommentar, Processing Instruction, Fehler)
eingelesen wird, und durch einen selbst programmierten Eventhandler (= eine
Methode) behandelt. Das bedeutet dass die Reaktion auf das Ereignis, frei
wählbar ist. Es können auch für Fehler und Warnungen entsprechende
Reaktionsabläufe definiert werden. Nach dem Abarbeiten des Ereignisses ist
dieses allerdings vergangen und wird nicht automatisch zwischengespeichert.
Somit muss man Ergebnisse oder Werte die man eventuell später benötigt
zwischenspeichern.
Bei DOM Parsern (eher für interaktive Zugriffe) wird beim Parsen ein DOMTree aufgebaut, der in den Speicher geladen wird. Somit befindet sich dort ein
virtuelles Abbild des XML Dokuments. Auf die Blätter des Baumes kann
zugegriffen werden und sie können verändert werden. Ein DOM-Parser ist
langsamer und benötigt mehr Speicherplatz als ein SAX-Parser, da das
Erzeugen des DOM-Trees mehr Zeit und Ressourcen in Anspruch nimmt.
Generell gilt, dass SAX-Parser schneller sind und einfacher handzuhaben, als DOM-Parser,
jedoch gibt es kein persistentes Abbild im Speicher. Deswegen eignen sich SAX-Parser eher
für das schnelle Einlesen und Anzeigen/Übergeben der Informationen eines XMLDokuments. DOM-Parser sollten verwendet werden, wenn man die eingelesenen
Information bearbeiten/verändern will oder öfter auf das eingelesene Dokument zugegriffen
wird.
Seite 5 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Spezifikation der Testumgebung
Die Testumgebung verwendet Dateien, die von einer eigens erstellten Klasse erzeugt wird.
Mit dieser werden Files der XML Version 1.0 erzeugt und es wird der Zeichensatz ISO-8859-1
verwendet. Das Hauptaugenmerk der Testumgebung wird auf schnelle automatisierte
Verarbeitung gelegt. Die verschiedenen Texteinträge sind alle randomisiert aus den ASCIIcodierten Zeichen 97-122, welche den Kleinbuchstaben des Alphabets entsprechen.
Aufgrund der randomisierten Texte muss es eine DTD geben, um die neu erzeugten
Elemente zu interpretieren. Zudem wird auf Attribute verzichtet, da diese auch mit
Elementen dargestellt werden.
Aufgrund von Buffering und Parallelität der Prozessausführung wurden folgende Annahmen
getroffen:
-
Jeder Parser wird in einer eigenen Klasse realisiert
-
Die Zeitmessung des Anfangspunktes erfolgt vor der Erzeugung der Java-Klasse. Aus
Speichergründen wird der Parser neu generiert.
-
Die Zeitmessung des Endpunktes ist nach der Ausführung des jeweiligen parseKommandos
Es werden immer mehrere Dateien mit unterschiedlichen Elementen aber gleicher Struktur
getestet. Dies erfolgt aufgrund des geringen Zeitaufwandes für eine Datei. Aus diesem und
dem vorher genannten Grund ergibt sich ein guter Durchschnitt für den Aufwand eines
Parsers, eine Datei zu parsen, da im Realbetrieb ein Parser sicherlich nicht bei jedem neu zu
parsenden File aufgerufen werden muss, jedoch der Parser nicht jedes File im Cache hat und
bei mehreren gleichzeitig verwendeten Parsern muss gegebenenfalls einer erzeugt werden.
Seite 6 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Als Testparser wurden ausgewählt:
-
Aelfred Parser ( http://saxon.sourceforge.net/aelfred.html)
-
CrimsonParser2 (http://xml.apache.org/crimson/ )
-
Xerces DocumentBuilderImpl (aus JDK 1.6.0)
-
Xerces DOMXSImplementationSourceImpl (aus dem xercesImpl.jar und dem package
org.apache.xerces.dom.
-
DOMXSImplementationSourceImpl
-
Xerces Sax Parser (aus jdk1.6.0)
Alle diese Parser validieren nicht und wurden ausgewählt,
performancetechnischen Gründen nicht der Aufgabenstellung entsprechen.
da
sie
aus
Die Parser Aelfred und CrimsonParser2 wiesen zudem Fehler bei XML-Dateien mit DTDs auf
und wurden deshalb ohne diese getestet.
Testumgebung
OS: Windows XP
CPU: Intel Core 2 Duo E8400@ 3.00 GHz (2 CPUs)
Arbeitsspeicher 3326MB Ram
HD: SATA
Seite 7 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Die erhobenen Daten und die benötigten Informationen zur Auswertung werden in eine
Textdatei formatiert gespeichert.
Diese Diagnosedateien sehen wie folgt aus:
Datei Eigenschaften: Maximale Tiefe: 3
Anzahl der Dateien: 100
Labellänge: 5 - 15
Textlänge: 20 - 30
Ebene 1, Elemente: 6
Ebene 2, Elemente: 2
Ebene 3, Elemente: 4
Durchschnittliche Dateigroeße: 1451.2399999999998 Byte
Aelfred Parser: Verbrauchte Zeit = 62
Crimson Parser2: Verbrauchte Zeit = 78
XercesDocumentBuilderImpl Parser: Verbrauchte Zeit = 188
XercesDomParser Parser: Verbrauchte Zeit = 187
Xerces Sax Parser: Verbrauchte Zeit = 140
Seite 8 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Ergebnisauswertung und Interpretationen
Wie erwartet schnitten die SAX Parser, gegenüber den DOM Parser in Sachen Performanz
wesentlich besser ab. Wie vorhin beschrieben, eignen sich SAX Parser dafür, Informationen
schnell einzulesen. Jedoch konnte man erkennen, dass der Xerces DOM Parser, die
generierten XML-Dateien, im Durchschnitt schneller geparst hat, als sein Konkurrent. Ob der
Xcerces DOM Parser auch bei der weiteren Verarbeitung die besseren Ergebnisse erzielen
würde, wurde nicht untersucht und es soll nicht weiter darauf eingegangen werden.
Wenn man alle Testergebnisse, betrachtet und auswertet, ist gut zu erkennen, dass der
Saxon Parser der schnellste Parser für kleine und wenige XML-Dateien ist. Je größer die
Dateigröße und je mehr Dateien zu parsen sind, umso länger braucht der Saxon Parser dafür.
Es konnten keine Abhängigkeiten von der Performanz der Parser, zu den gewählten
Parametern, der maximalen Tiefe und der Label- und Textlänge, festgestellt werden. Das
heißt zum Beispiel, dass sich durch ein variieren dieser Werte und Bereiche der erstellten
XML-Dokumente, kein Parser besonders für Dateien einer geringen oder hohen maximalen
Tiefe eignet. Die Kreisdiagramme stellen die Platzierung der Parser dar, gereiht nach der
prozentualen Anzahl der erzielten Siege, im Hinblick auf die Parszeit, und unter
Berücksichtigung der gesamten stichprobenartigen Testfälle.
Die eigentlichen Bezeichnungen der verwendeten Parser sind hier aufgeführt, werden aber
der Einfachheit halber durch ein Synonym ersetzt:
Aelfred Saxon Parser = Saxon Parser
Crimson Parser2 = Crimson Parser
Xerces SAX Parser = Xerces SAX Parser
XercesDocumentBuilderImpl Parser = DOMImpl Parser
XercesDomParser Parser = Xerces DOM Parser
Seite 9 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Bei 5 XML-Dokumenten:
25%
1. Saxon
2. Crimson
75%
Bei 100 XML-Dokumenten:
29%
Bei 500 XML-Dokumenten:
41%
1. Saxon
71%
2. Crimson
Bei 1000 XML-Dokumenten:
48%
52%
1. Saxon
59%
2. Crimson
Bei 2000 XML-Dokumenten:
1. Saxon
1. Crimson
39%
2. Crimson
61%
2. Saxon
Zu erkennen ist, dass der Saxon Parser bis zu 1000 XML-Dokumente am schnellsten von allen
Parsern parst (Dementsprechend auch 1 Dokument). Dies beruht darauf, wie oben erklärt,
an der mitgestoppten Anlegezeit des Parsers, welche durch die Größe des Parser beeinflusst
wird. Bei 1000 XML-Dokumenten kann man sehen, dass der Crimson den Saxon Parser schon
beinahe eingeholt hat. Bei 2000 Dokumenten schlägt der Crimson den Saxon Parser in der
Parsgeschwindigkeit.
Seite 10 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Wenn man die besten Parszeiten insgesamt von jedem Parser, im Hinblick auf die
durchschnittliche Dateigröße betrachtet, und entsprechend aufschlüsselt, so kann man
erkennen, das anfänglich zwar der Saxon Parser triumphiert, aber mit steigenden
Dateigrößen, sich der Vorsprung gegenüber dem Crimson Parser relativiert. Die folgende
Aufstellung zeigt, in welchen Dateigrößenbereichen welche Parser das, im Durchschnitt,
beste Ergebnis liefern, ohne Berücksichtigung der Dateianzahl. Die Auswertung wurde in
Kilobyte-Schritten durchgeführt.
1 - 3 KB:
Saxon Parser
> 3 KB:
Crimson Parser
Dadurch hat sich herauskristallisiert, dass der Saxon Parser eher bei einer durchschnittlichen
Dateigröße unter 3 KB sinnvoll anzuwenden sind, da sich mit anwachsender Größe die
Parszeiten tendenziell verschlechtern. Ab 3 KB ist es sinnvoll den Crimson Parser zu
verwenden.
Die durchschnittlichen Parszeiten von jedem Parser im Hinblick auf die durchschnittliche
Dateigröße, ohne Berücksichtigung der Dateianzahl, betragen:
Dateien unter 2 KB Größe:





Crimson Parser:
Xerces SAX Parser:
Saxon Parser:
DOMImpl Parser:
Xerces DOM Parser:
195,9 ms
237,4 ms
164,5 ms
290,6 ms
273,9 ms
Dateien von 2 KB bis 4 KB Größe:





Crimson Parser:
Xerces SAX Parser:
Saxon Parser:
DOMImpl Parser:
Xerces DOM Parser:
416,7 ms
454,7 ms
437,6 ms
582,5 ms
486,9 ms
Dateien von 4 KB bis 8 KB Größe:





Crimson Parser:
Xerces SAX Parser:
Saxon Parser:
DOMImpl Parser:
Xerces DOM Parser:
622,9 ms
762,8 ms
765,3 ms
992,8 ms
901,4 ms
Seite 11 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Fazit und Schlusswort
Fazit der Untersuchungen ist, dass die zwei schnellsten Parser (Saxon und Crimson), je nach
Anwendungsgebiet, gefunden wurden. Folglich gibt es keinen Parser der generell der
schnellste wäre. Jedoch ist der für die Aufgabenstellung relevante schnellste Parser (Saxon)
eruiert worden. Die Testergebnisse beruhen auf statistischen Stichproben und wurden
anschließend interpretiert. Um dies zu bewerkstelligen wurde eine Testumgebung in Java
aufgebaut, die aus mehreren Teilen besteht. Zum einen den XML-Creator und zum anderen
die Einbindungen der verschiedenen zu testenden Parsern.
Seite 12 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
Anhang mit Sourcecode
XmlCreator.java
Diese Klasse erstellt ein XML-File. Die Konfiguration wird über die Methode initialising durchgeführt,
mit der es möglich ist XML-Files zu erstellen.
package eemw2010;
import java.io.*;
import java.util.Random;
import java.util.Vector;
public class XMLCreator implements Config {
/**
* @param args
* @throws IOException
* @throws IOException
*/
private static int depth = 0; // Maximale Tiefe
private static Vector<Integer> ele; // Elemente pro Ebene Vektor
private static Random rand; // Randomnumbergenerator
private static final int maxb = 5; // Konstante zur Begrenzung des
// Eintragverdoppelungsarray
private static FileWriter fdoc; // FileWriter für die DTD Datei
private static int llc, // Labellengthconstant,
llv, // Labellenghtvariable,
dlc, // Datalengthconstant,
dlv; // Datalenghtvariable
/*
* Erstellt ein Xml File mit aus den zuvor initialisierten Variablen (aus
* der Methode initialsing) in den FileWriter
*/
private static void CreateXml(FileWriter fw) {
String xml1;
int cdepth = 0;
int i = 0;
Vector<Integer> used = new Vector<Integer>();
used.setSize(depth + 1);
for (i = 0; i < depth + 1; i++)
used.set(i, 0);
try {
Seite 13 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
xml1 = ranText(rand.nextInt(llv) + llc);
recWrite(fw, cdepth, used, xml1);
} catch (IOException e) {
e.printStackTrace();
}
}
/*
* Rekursive SchreibMethode, fw = FileWriter Schreiben in die Datei, cdepth
* = aktuelle Tiefe, used = Vector zum Zählen der derzeit eingesetzten
* Elemente, l = LabelString im Xml
*/
private static boolean recWrite(FileWriter fw, int cdepth,
Vector<Integer> used, String l) throws IOException {
Vector<String> docv = new Vector<String>(); // Vector zum Erstellen der
// DTD
String s; // String für den Zufallstext
StringBuffer sb = new StringBuffer(); // StringBuffer zum Erstellen des
// Strings für die DTD
if (depth > cdepth) {
// Tabulatoren im Xml-File erzeugen
for (int i = 0; i < cdepth; i++) {
fw.write(9);
}
fw.write("<" + l + ">\n");
fdoc.write("<!ELEMENT EEMTEST (" + l + ")>\n");
s = ranText(rand.nextInt(llv) + llc);
WriteLevel(fw, s, cdepth + 1); // Einen Texteintrag erzwingen
docv.add(s); // Eintrag für die DTD merken
used.set(cdepth, used.get(cdepth) + 1);
while (used.get(cdepth) < ele.get(cdepth)) {
if (rand.nextInt(2) == 1) {
s = ranText(rand.nextInt(llv) + llc);
docv.add(s);
recWrite(fw, cdepth + 1, used, s);
} else {
s = ranText(rand.nextInt(llv) + llc);
docv.add(s);
WriteLevel(fw, s, cdepth + 1);
}
used.set(cdepth, used.get(cdepth) + 1); // Elemente zählen
}
// Tabulatoren im Xml-File erzeugen
for (int i = 0; i < cdepth; i++) {
fw.write(9);
}
fw.write("</" + l + ">\n");
// DTD Eintrag generieren
sb.append(docv.get(0));
Seite 14 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
for (int i = 1; i < docv.size(); i++) {
sb.append(", ");
sb.append(docv.get(i));
}
fdoc.write("<!ELEMENT " + l + " (" + sb.toString() + ") >\n");
used.set(cdepth, 0);
return true;
} else {
WriteLevel(fw, ranText(rand.nextInt(llv) + llc), cdepth + 1);
used.set(cdepth, used.get(cdepth) + 1);
while (used.get(cdepth) < ele.get(cdepth)) {
if (rand.nextInt(2) == 0) {
WriteLevel(fw, ranText(rand.nextInt(llv) + llc), cdepth + 1);
}
used.set(cdepth, used.get(cdepth) + 1);
}
used.set(cdepth, 0);
return true;
}
}
/*
* Schreibt einen randomisierten Text in den FileWriter fw, label als
* xml-Label, cdepth als aktuelle Tiefe
*/
private static void WriteLevel(FileWriter fw, String label, int cdepth)
throws IOException {
for (int i = 0; i < cdepth; i++) {
fw.write(9);
}
fw.write("<" + label + ">");
fw.write(ranText(dlc + rand.nextInt(dlv)));
fw.write("</" + label + ">\n");
fdoc.write("<!ELEMENT " + label + " (#PCDATA) >\n");
}
// Erzeugt einen Text mit Länge l, aus den ASCII Zeichen 97- 122 (a-z)
private static String ranText(int l) {
StringBuffer sb = new StringBuffer();
for (int i = 0; i < l; i++)
sb.append((char) (rand.nextInt(26) + 97));
return sb.toString();
}
public static void main(String[] args) throws IOException {
FileWriter fw; // FileWriter für die Datei zu schreiben
FileReader fr; // FileReader zum Vergrössern von Dateien unter 1kb
BufferedReader br;
String line = null;
ele = new Vector<Integer>();
rand = new Random();
Seite 15 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
String filename2 = null;
int usebuffer = 0;
StringBuffer sb[] = new StringBuffer[maxb];
File datei, fdiag;
long fl[] = new long[anz]; // Filegröße gesamt
double erg = 0; // Filegröße ergebnis
fdiag = new File(diagname);
BufferedWriter diag = new BufferedWriter(new FileWriter(fdiag, true));
// Configuration:
initialsing();
// Diagnosefile erstellen
diag.write("\nDatei Eigenschaften: Maximale Tiefe: " + depth
+ "\nAnzahl der Dateien: " + anz + "\n");
diag.write("Labellänge: " + llc + " - " + (llv + llc) + "\n"
+ "Textlänge: " + dlc + " - " + (dlv + dlc) + "\n");
for (int i = 0; i < depth; i++) {
diag.write("Ebene " + (i + 1) + ", Elemente: " + ele.get(i) + "\n");
}
for (int i = 0; i < anz; i++) { // For-Schleife für jede Datei
// StringBuffer resetten
for (int b = 0; b < maxb; b++) {
sb[b] = new StringBuffer();
}
fdoc = new FileWriter(new File(filename + i + ".dtd"));
filename2 = filename + i + ".xml";
datei = new File(filename2);
fw = new FileWriter(datei);
fw.write("<?xml version=\"1.0\" encoding=\"ISO-8859-1\"?>\n");
/*
* fw.write("<!DOCTYPE EEMTEST SYSTEM \"" + filename + i + ".dtd" +
* "\">\n");
*/
fw.write("<EEMTEST>\n");
CreateXml(fw);
fw.write("\n");
fw.close();
// Vergroessern der Datei
if (datei.length() < 1000) {
usebuffer = 1;
while (usebuffer * datei.length() < 1000)
usebuffer++;
if (usebuffer > maxb)
usebuffer = maxb;
usebuffer--; // Anzahl der Verdoppelungen um 1 verringern
fr = new FileReader(datei);
Seite 16 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
br = new BufferedReader(fr);
//
while ((line = br.readLine()) != null) {
if (line.compareTo("<?xml version=\"1.0\" encoding=\"ISO8859-1\"?>") == 0) {
// XML Version ignorieren
} else if (line.compareTo("<!DOCTYPE EEMTEST SYSTEM \""
+ filename + i + ".dtd" + "\">") == 0) {
// DOCTYPE ignorieren
} else if (line.compareTo("<EEMTEST>") == 0) {
// ersten öffentlichen Tag ignorieren
} else if (line.indexOf('<') == line.lastIndexOf('<')) {
// Öffentliche und schließende Tags in den Buffer
// aufnehmenden
for (int u = 0; u < usebuffer; u++) {
sb[u].append(line);
sb[u].append('\n');
}
} else {
// Neue Dateneinträge erstellen
for (int u = 0; u < usebuffer; u++) {
sb[u].append(line.substring(0,
line.indexOf('>') + 1));
sb[u].append(ranText(dlc +
rand.nextInt(dlv)));
sb[u].append(line.substring
(line.lastIndexOf('<')));
sb[u].append('\n');
}
}
}
br.close();
fr.close();
// Neue Einträge schreiben
fw = new FileWriter(datei, true);
for (int u = 0; u < usebuffer; u++) {
fw.write(sb[u].toString());
fw.write("\n");
}
// Abschließenden Tag schreiben
fw.write("</EEMTEST>\n");
fw.close();
fdoc.close();
} else { // Datei wird nicht vergrößert
// Abschließenden Tag schreiben
fw = new FileWriter(datei, true);
fw.write("</EEMTEST>\n");
fw.close();
fdoc.close();
Seite 17 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
}
// Dateilänge merken
fl[i] = datei.length();
}
// Dateigröße erstellen
for (int j = 0; j < anz; j++)
erg += ((double) fl[j]) / anz;
// Dateigröße schreiben
diag.write("Durchschnittliche Dateigroeße: " + erg + " Byte \n");
diag.close();
// Files ohne DTD-Erstellen generieren
for (int i = 0; i < anz; i++) {
try {
fw = new FileWriter(filename + i + "o.xml");
fr = new FileReader(filename + i + ".xml");
br = new BufferedReader(fr);
while ((line = br.readLine()) != null) {
if (line.compareTo("<!DOCTYPE EEMTEST SYSTEM \"" + ^
filename+ i + ".dtd" + "\">") == 0) {
// DOCTYPE ignorieren
} else {
fw.write(line);
fw.write("\n");
}
}
fw.close();
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
System.out.println("Files created");
}
private static void initialsing() {
depth = rand.nextInt(6) + 2; // Tiefe
/* Maximale Anzahl der Elemente auf der Ebene 0 */
ele.add(rand.nextInt(4) + 3);
ele.add(rand.nextInt(4) + 2);
Seite 18 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
ele.add(rand.nextInt(4) + 2);
ele.add(rand.nextInt(5) + 2);
ele.add(rand.nextInt(6) + 2);
ele.add(rand.nextInt(3) + 2);
ele.add(rand.nextInt(3) + 1);
ele.add(rand.nextInt(3) + 1);
llc = 5; // Labellengthconstant,
llv = 10; // Labellenghtvariable,
dlv = 10; // Datalenghtvariable
dlc = 20; // Datalengthconstant,
}
}
Config-Interface
package eemw2010;
public interface Config {
public final static int anz = 100;
public final static String filename = "c:\\test\\test";
public final static String diagname = "C:\\test\\diag100.txt";
}
Aelfred Parser Test
package eemw2010;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import org.xml.sax.SAXException;
import org.xml.sax.helpers.DefaultHandler;
public class AelfredTest implements Config {
/**
* @param args
*/
Seite 19 von 24
XML-Parser
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 0;
long start = 0, end = 0, t = 0;
BufferedWriter diag;
File f[] = new File[anz];
DefaultHandler tmp = new DefaultHandler();
for (i = 0; i < anz; i++)
f[i] = new File(filename + i + "o.xml");
start = System.currentTimeMillis();
try {
diag = new BufferedWriter(new FileWriter(new File(diagname), true));
SAXParserFactory spf = net.sf.saxon.aelfred.SAXParserFactoryImpl
.newInstance("net.sf.saxon.aelfred.SAXParserFactoryImpl",null);
SAXParser sp = spf.newSAXParser();
for (i = 0; i < anz; i++) {
sp.parse(f[i], tmp);
}
end = System.currentTimeMillis();
t = end - start;
diag.write("Aelfred Parser: Verbrauchte Zeit = " + t + "\n");
diag.close();
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
}
}
}
CrimsonParser2 Parser Test
package eemw2010;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
Seite 20 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
import java.io.IOException;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
public class CrimsonParser2 implements Config {
public static void main(String[] args) {
int i = 0;
long start = 0, end = 0, t = 0;
BufferedWriter diag;
start = System.currentTimeMillis();
try {
org.apache.crimson.parser.Parser2 p = new
org.apache.crimson.parser.Parser2();
diag = new BufferedWriter(new FileWriter(new File(diagname), true));
for (i = 0; i < anz; i++) {
p.parse(new InputSource(filename + i + "o.xml"));
}
end = System.currentTimeMillis();
t = end - start;
diag.write("Crimson Parser2: Verbrauchte Zeit = " + t + "\n");
diag.close();
} catch (SAXException e) {
System.out.println(i);
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} finally {
}
}
}
XercesDocumentBuilderImpl Test
package eemw2010;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import javax.xml.parsers.DocumentBuilder;
Seite 21 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.ParserConfigurationException;
import org.xml.sax.SAXException;
public class XercesDocumentBuilderImplTest implements Config {
public static void main(String[] args) {
int i = 0;
long start = 0, end = 0, t = 0;
BufferedWriter diag;
File f[] = new File[anz];
for (i = 0; i < anz; i++)
f[i] = new File(filename + i + ".xml");
start = System.currentTimeMillis();
try {
diag = new BufferedWriter(new FileWriter(new File(diagname), true));
DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
DocumentBuilder db = dbf.newDocumentBuilder();
for (i = 0; i < anz; i++) {
db.parse(f[i]);
}
end = System.currentTimeMillis();
t = end - start;
diag.write("XercesDocumentBuilderImpl Parser: Verbrauchte Zeit = "
+ t + "\n");
diag.close();
} catch (ParserConfigurationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Xerces DOM Test
package eemw2010;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import org.w3c.dom.bootstrap.DOMImplementationRegistry;
import org.w3c.dom.ls.DOMImplementationLS;
import org.w3c.dom.ls.LSParser;
Seite 22 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
public class XercesDomParserImplTest implements Config {
public static void main(String[] args) {
// TODO Auto-generated method stub
int i = 0;
long start = 0, end = 0, t = 0;
BufferedWriter diag;
start = System.currentTimeMillis();
LSParser builder;
System.setProperty(DOMImplementationRegistry.PROPERTY,
"org.apache.xerces.dom.DOMXSImplementationSourceImpl");
DOMImplementationRegistry registry;
try { diag = new BufferedWriter(new FileWriter(new File(diagname), true));
registry = DOMImplementationRegistry.newInstance();
DOMImplementationLS impl = (DOMImplementationLS) registry
.getDOMImplementation("LS");
builder=impl.createLSParser(DOMImplementationLS.MODE_SYNCHRONOUS,
null);
for (i = 0; i < anz; i++) {builder.parseURI(filename + i + ".xml");}
end = System.currentTimeMillis();
t = end - start;
diag.write("XercesDomParser Parser: Verbrauchte Zeit = " + t + "\n");
diag.close();
} catch (ClassCastException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (ClassNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (InstantiationException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IllegalAccessException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Xerces Sax Parser Test
package eemw2010;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.helpers.XMLReaderFactory;
Seite 23 von 24
Beiglböck, Fuker, Pichler
Entwurf, Errichtung und Management
von Datennetzen WS09
XML-Parser
public class XercesSaxParserTest implements Config {
public static void main(String[] args) {
int i = 0;
long start = 0, end = 0, t = 0;
BufferedWriter diag;
start = System.currentTimeMillis();
try {
diag = new BufferedWriter(new FileWriter(new File(diagname), true));
XMLReader x = XMLReaderFactory.createXMLReader();
for (i = 0; i < anz; i++) {
x.parse(filename + i + ".xml");
}
end = System.currentTimeMillis();
t = end - start;
diag.write("Xerces Sax Parser: Verbrauchte Zeit = " + t + "\n");
diag.close();
} catch (SAXException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
Seite 24 von 24