-
Notifications
You must be signed in to change notification settings - Fork 0
Dokumentation
Ein XML-Dokument sollte sich an diverse Syntaxregeln halten. Wenn alle Syntaxregeln eingehalten werden, dann wird das Dokument als „Wohlgeformt“ bezeichnet. Die Syntaxregeln lauten:
XML-Dokumente müssen ein root-Element haben. XML-Elemente müssen ein schließendes Tag haben. XML-Tags sind Case Sensitive. XML-Elemente müssen korrekt verschachtelt werden. XML-Attributewerte müssen in Anführungszeichen stehen.
<?xml version="1.0" encoding="UTF-8"?>
<brief>
<absender>Tove</absender>
<empfaenger>Jani</empfaenger>
<titel>Reminder</titel>
<inhalt>Don't forget me this weekend!</inhalt>
</brief>
Ein Valides XML-Dokument ist ein Wohlgeformtes XML-Dokument, welches zudem noch an Regeln einer Document Type Definition (DTD) hält. Beispiel:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE brief SYSTEM "Brief.dtd">
<brief>
<absender>Tove</absender>
<empfaenger>Jani</empfaenger>
<titel>Reminder</titel>
<inhalt>Don't forget me this weekend!</inhalt>
</brief>
Die DTD:
<!DOCTYPE brief
[
<!ELEMENT brief (absender,empfaenger,titel,body)>
<!ELEMENT absender (#PCDATA)>
<!ELEMENT empfaenger (#PCDATA)>
<!ELEMENT titel (#PCDATA)>
<!ELEMENT inhalt (#PCDATA)>
]>
Alternativ zu DTD ist es auch möglich das XML-Basierte XML-Schema zu verwenden, welches wie folgt aussieht:
<xs:element name="brief">
<xs:complexType>
<xs:sequence>
<xs:element name="absender" type="xs:string"/>
<xs:element name="empfaenger" type="xs:string"/>
<xs:element name="titel" type="xs:string"/>
<xs:element name="inhalt" type="xs:string"/>
</xs:sequence>
</xs:complexType>
</xs:element>
Namespaces sind dazu da potentielle Namenskonflikte zwischen den verschiedenen Elementen zu verhindern. Wenn man z.B. ein element
nennt, weil man einen Tisch ansprechen will, es aber auch das HTML-Element<h:table>
<h:tr>
<h:td>Stuff</h:td>
<h:td>Other Stuff</h:td>
</h:tr>
</h:table>
<m:table>
<m:name>Tischi</m:name>
<m:holz>Teak</m:holz>
<m:preis>200€</m:preis>
</m:table>
Der namespace des Präfix' muss definiert werden. Dies geschieht über das xmlns-Attribut im öffnenden Tag eines Elements. Sie können im root-Tag oder erst wenn sie verwendet werden definiert werden. Der Syntax ist wie folgt xmlns:prefix="URI".
<root xmlns:h="http://www.w3.org/TR/html4/" xmlns:m="http://www.w3schools.com/moebel">
<h:table>
[...]
</h:table>
<m:table>
[...]
</m:table>
</root>
Als erstes wird ein root-Tag erstellt, welches hier einfach „form“ (als kurzform von Formular) genannt wird. Damit hat man dann <form></form>
Nun hat man einen Gruppenleiter und kann noch beliebig viele zusätzliche Personen hinzufügen. Somit wir also ein Element namens „person“ erstellt, welches das Attribut „typ“, dessen Wert entweder „leiter“ oder „mitglied“ sein kann. Alternativ hätte man auch ein eigenes Element für den Gruppenleiter und die Mitglieder erstellen können, aber dies wäre spätestens beim erstellen eines XML-Schema äußerst umständlich. Somit hat man nun:
<form>
<person typ="leiter">
</person>
<person typ="mitglied">
</person>
[...]
</form>
Nun muss das Element „person“ nur noch mit den passenden Elementen befüllt werden. In diesem Fall sind es „vorname“, „nachname“, „email“, „geburtsdatum“, „erfahrung“, „schlagzeug“ und „anmerkungen“. Nachdem diese eingefügt wurden ist das Formular vollständig:
<form>
<person typ="leiter">
<vorname></vorname>
<nachname></nachname>
<email></email>
<geburtsdatum></geburtsdatum>
<erfahrung></erfahrung>
<schlagzeug></schlagzeug>
<anmerkungen></anmerkungen>
</person>
</form>
Um eine equivalente JSON-Datei zu erstellen nimmt man „form“ wieder als root-Element.
{
"form": {
}
}
Da es mehrere Personen geben kann, werden eckige Klammern gesetzt um dies zu signalisieren (siehe Array).
{
"form": {
"person": [
]
}
}
In diese Klammern kann man nun eine unbegrenzte Anzahl von Personen hineinschreiben.
{
"form": {
"person": [
{
"-typ": "leiter",
"vorname": "Hans",
"nachname": "Anderson",
"email": "[email protected]",
"geburtsdatum": "01.01.1970",
"erfahrung": "Profi",
"schlagzeug": "vorhanden",
"anmerkungen": "Wichtig für meine Gruppe ist gutes Essen"
},
[...]
]
}
}
Um das Rezept für den Kuchen in XML umzusetzen beginnt man wie immer erstmal mit dem root-Element, welches in diesem Fall das Rezept an sich ist.
<rezept></rezept>
Wenn man sich das Rezept betrachtet erkennt man drei Hauptstrukturen: einen Titel, welcher den Namen der Speise angibt, die Zutaten die für die Zubereitung der Speise von Nöten sind und schließlich die Zubereitung an sich. Fügt man diese hinzu sollte das Dokument so aussehen:
<rezept>
<titel></titel>
<zutaten>
</zutaten>
<zubereitung>
</zubereitung>
</rezept>
Nun gibt es nicht nur eine Zutat pro Speise, sondern mehrere und diese haben eine Art und eine Menge. Also versieht man das Element „Zutaten“ mit einem Unterelement „Zutat“, welches wiederum die Unterelemente „Menge“ und „Art“ hat. Alternativ hätte man auch dem Element „Zutat“ auch die Menge und die Art als Attribute zuweisen können. Das Ergebnis sieht dann so aus:
<rezept>
<titel></titel>
<zutaten>
<zutat>
<menge></menge>
<art></art>
</zutat>
[...]
</zutaten>
<zubereitung>
</zubereitung>
</rezept>
Nun ist das Werk auch fast vollbracht. Unter die Zubereitung fallen dann noch Punkte, wie Schwierigkeitsgrad, Brennwert, Arbeitsdauer und die einzelnen Arbeitsschritte, wovon es wieder bliebig viele geben kann. Alternativ hätte man auch nur ein Element für die Gsamtheit der Arbeitsschritte machen können. Fertig sieht das XML-Dokument dann so aus:
<rezept>
<titel></titel>
<zutaten>
<zutat>
<menge></menge>
<art></art>
</zutat>
[...]
</zutaten>
<zubereitung>
<portionen></portionen>
<arbeitszeit></arbeitszeit>
<schwierigkeit></schwierigkeit>
<brennwert></brennwert>
<anleitung>
<schritt></schritt>
[...]
</anleitung>
</zubereitung>
</rezept>
Andere Rezepte auf der Seite chefkoch.de haben die gleiche Struktur und meistens auch die gleichen oder ähnliche Parameter. Alle Rezepte haben einen Titel, eine Zutatenliste und eine Zubereitungsanleitung. Punkte wie Arbeitszeit, Schwierigkeit und Brennwert können variieren. Auch können die Zutaten unterteilt werden, falls man gewisse Dinge getrennt anfertigt (wie z.B. Kuchen und eine spezielle Glasur).
Welche Daten müssen in simple und welche in complex-types abgebildet werden? Alle Elemente, welche keine Unterelemente oder Attribute haben können als Simple-Type abgebildet werden, alle anderen zwangsläufig als Complex-Type.
Für welche Daten ist die Abbildung in Attributen sinnvoller? Dinge wie Identifikationsnummern oder ähnliche Daten machen als Attribut mehr Sinn, da es ein primitiver Datentyp ist wie oft nur eine Zahl oder ein Buchstabe.
Welche Datentypen müssen für die Elemente definiert werden? In dieser Variante wurden lediglich Strings verwendet, jedoch könnte man alternativ auch diverse Mengenangaben als Integer darstellen, sowie auch den Brennwert.
Welche Restriktionen müssen definiert werden? Es muss immer mindestens eine Zutat geben und einen Arbeitsschritt, da man sonst schlecht eine Speise zubereiten kann.
Da dieses mal mehrere Rezepte möglich sind wird zunächst das root-Element „rezepte“ definiert. Dieses Element kann beliebig viele Elemente vom Typ „rezept“ beinhalten. Dies wird durch die Attribute minOccurs="1" und maxOccurs="unbounded" erreicht. Das ganze sieht dann etwa so aus:
<xsd:element name="rezepte">
<xsd:complexType>
<xsd:sequence>
<xsd:element ref="rezept" minOccurs="1" maxOccurs="unbounded"></xsd:element>
</xsd:sequence>
</xsd:complexType>
</xsd:element>
Nun wird das Element „rezept“ definiert. „rezept“ enthält ein Element des Typs „titel“, eins des Typs „zutaten“ und eins des Typs „zubereitung“. Der Titel an sich ist ein simples Element und enthält lediglich Text. Dies wird duch das Attribut type="xsd:string" festgelegt.
Das Element „zutaten“ enthält eine beliebige Anzahl vom Element „zutat“, welches wieder durch
minOccurs="1" und maxOccurs="unbounded" ermöglicht wird. Das gleiche gilt für das Element „schritt“, welches in „zubereitung“ und „anleitung“ verschachtelt ist.
Die restlichen Elemente werden ihren parent-Elementen zugeordnet. Jede „zutat“ hat eine „art“ und „menge“. Die Zubereitung hat neben der „anleitung“ noch „schwierigkeit“, „brennwert“ und „arbeitszeit“.
Siehe Quellcode in Aufgabe4.java.
Das Speichern von Daten im XML oder JSON Format ist durch verschiedene Faktoren sinnvoll. Der naheliegenste Grund ist die Strukturierung der Daten. Die Daten werden nach einem festgelegtem System abgespeichert und es ist für den Programmierer leicht ersichtlich, wie der Aufbau dieser Struktur ist und das Auslesen der Daten fällt somit auch leichter. Es weiterer Grund für die nutzung von XML und JSON ist die flexibilität der beiden Formate. Man kann für seine Bedürfnisse meistens eine passende XML oder JSON Datei anlegen.
Beide Formate sind ähnlich strukturiert, aber sie haben dennoch Unterschiede. Während JSON Dateien sehr spartanisch aufgebaut sind, was einem Schreibarbeit erspart, können XML-Dateien doch etwas deskriptiver werden, was für den Anwender klarer verständlich ist. Zudem gibt es bei XML noch die Schemas, welche die Struktur noch einmal verständlicher machen.