xml - megloff.ch

XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
<< Einführung in DOM >>
1
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
Übersicht / Lernziele:
2
z
Was ist DOM ?
z
Aufbau von DOM
z
Verwendung von DOM
z
DOM erzeugen und ändern können
z
Serialisierung von DOM Daten
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
<< Was ist DOM ? >>
3
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
Was ist DOM ?
DOM = Document Object Model
Abbildung von XML in ein Objekt Model.
XML Daten können somit als Objekte
gehandhabt werden.
Standardisiert durch W3C. Aktuell ist
Version DOM Level 3
DOM gibt es nicht nur für Java. W3C
definiert daher nur die Schnittstellen und
das Objekt Model. Das andere wird den
Herstellern überlassen.
4
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Anwendung
Auslesen von XML Daten und in Objekte abfüllen:
<xml>
<xml>
Xerces
Parser
DOM
Eigene Objekte
Java Anwendung
5
Ein Parser erzeugt aus dem XML Dokument
das Document Object Model (DOM), welches
aus Java Objekten besteht. aus diesem
Model erzeugen wir dann unsere eigenen
Objekte und verwenden diese weiter.
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Anwendung
Erzeugen von XML Daten:
Xerces
Eigene Objekte
DOM
<xml>
<xml>
Serializer
Java Anwendung
Aus unserem Objektmodel erzeugen wir ein
DOM (XML Struktur im Speicher).
Anschliessend serialisieren wir dieses
Model und erhalten so eine XML Datei.
6
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
DOM Levels:
Level 1: Abstrakte Schnittstellenbeschreibung
in OMG IDL (Object Management Group
Interface Definition Language)
Level 2: Namespace Support, Operationen zum
suchen und ändern. DTD Unterstützung. Import
Funktionalität.
Level 3: Schema Unterstützung, Vergleichen
von Dokumenten und Fragmenten. Normalization von Dokumenten. Standard Prozedur von
laden und speichern von Dokumenten.
7
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
DOM ist unterteilt in folgende Module:
• Core: Erstellen und verändern von Struktur und
Daten
• Events: Generisches Event Handling System,
Keyboard, Maus, Focus Change…
• Views: MVC Pattern, CSS Stylesheets
• Style: Objektmodel für CSS Stylesheets
• HTML: Objektmodel für HTML
• Traversal/Range: Navigation durch
Baumstruktur, Selektion von Datenbereichen
DOM ist ein hierarchisch aufgebautes Model.
Die kleinste Basis Informationseinheit bildet
ein sogenannter „Node“.
8
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
Das Document Object Model: Core
Comment
Processig
Instruction
Notation
NodeList
DOM
Implement
childNodes
implementation
parentNode
Document
Type
Character
Data
Text
doctype
Node
CDATA
Section
ownerDocument
Element
attributes
Entity
Attribut
Entity
Reference
Named
NodeMap
9
Document
Fragment
Document
documentElement
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
Zentrales Designpattern „Container“ (Composite)
0..*
Container
Component
0..*
0..*
Container
Mit dem Designpattern „Container“
lassen sich beliebige Baumstrukturen abbilden.
Extended
Container1
Node
Extended
Container2
Extended
Container3
10
Document
Element
Attribut
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
Vereinfachtes DOM:
document
document
0..*
1
1
element
element
1
0..*
text
text
11
1 0..*
attribut
attribut
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
Übersicht wichtigster DOM Komponenten:
12
Name
Beschreibung
Node
Grundlegender Basistyp, ist ein Container (abstract)
NodeList
Ansammlung von Nodes
Document
Das eigentliche Dokument, oberster Container
Element
Ein einzelnes XML Element
Attribut
Ein einzelnes Attribut eines XML Elementes
NamedMap
Eine Ansammlung von Nodes mit Namen, üblicherweise
verwendet für Attribute eines Elem.
CharacterData
Grundlegender Typ für TextInhalte (abstract)
Text
Parseable TextInhalt (normaler Text mit Markup)
CDATA
Unparsable TextInhalt (für Sonderzeichen, binär)
Comment
XML Kommentar
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
Abbildung einer XML Datei in ein DOM:
<?xml version="1.0"?>
<catalog>
<cd country="USA">
<title>Empire Burlesque</title>
<artist>Bob Dylan</artist>
<price>10.90</price>
</cd>
</catalog>
13
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM - Aufbau
Abbildung in ein DOM:
catalog
catalog
document
document
element
element
cd
cd
title
title artist
artist
element
element
price
price
element
element
element element
text
text
Reale Struktur
14
element
element
text
text
DOM Struktur
text
text
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
Erzeugung und Handhabung eines DOMs :
W3C definiert nur die Schnittstellen und das
Objekt Model. Die Implementationen und
Handhabung wird den Herstellern
überlassen.
In Java wird die Handhabung durch JAXP
(Java API for XML Processing) definiert.
Hersteller und Implementationen für Java:
15
• Xerces (xml.apache.org)
• Crimson (ehemals SUN jetzt Apache)
• JDOM (www.jdom.org)
• DOM4J (www.dom4j.org)
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
Performance der Einzelnen Implementationen :
16
XML mit
Java OpenSource
(c) Mark Egloff 2003
DOM
17
http://www.sosnoski.com/opensrc/xmlbench/results.html
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP
<< Java & DOM >>
18
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP
Java & DOM:
In Java benützen wir in der Regel 2 API‘s zur
Handhabung von DOM‘s:
• org.w3c.dom : Interfaces, Objektmodell DOM
• javax.xml.parsers : Standardisiertes API von Sun
Diese API bestehen nur aus Interfaces. Um sie
zu nutzen müssen wir eine Implementation zur
Laufzeit festlegen Î JAXP Konfiguration
19
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Handhabung von DOM in Java:
JAXP bietet eine Factory um ein neues DOM zu
erstellen:
javax.xml.parsers.DocumentBuilderFactory
Die DOM Core Klassen existieren als Interfaces
im Package:
org.w3c.dom
Wir programmieren nur gegen diese Interfaces
und spüren nichts von der eigentlichen
Implementation (z.B. ob Xerces oder Crimson)
Die Factory liefert dann zur Laufzeit eine
entsprechende Implementation.
20
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Erzeugung eines neuen DOM‘s:
21
1.
DocumentBuilderFactory Implementation
festlegen
2.
DocumentBuilderFactory instanzieren
(und konfigurieren )
3.
DocumentBuilder mittels Factory
instanzieren (und konfigurieren)
4.
Neues Document (DOM) erzeugen
5.
Mittels der Factory Elemente erzeugen und
im neuen Document einfügen.
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Neues DOM erzeugen, Java Beispiel (1/2):
public class Run
{
public static void main(String[] args)
{
try {
// Factory instanzieren
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
// Parser bzw. DocumentFactory holen
DocumentBuilder builder = factory.newDocumentBuilder();
// neues Dokument erzeugen
Document doc = builder.newDocument();
// Root Element erzeugen und dem Dokument hinzufügen
Element root = doc.createElement("catalog");
doc.appendChild(root);
...
22
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Neues DOM erzeugen, Java Beispiel (2/2):
// neues Element erzeugen und Eltern Element hinzufügen
Element cd = doc.createElement("cd");
root.appendChild(cd);
// Attribut einem Element hinzufügen
cd.setAttribute("country","USA");
// neues Element erzeugen und Eltern Element hinzufügen
Element title = doc.createElement("title");
cd.appendChild(title);
// Text Node etzeugen und Eltern Element hinzufügen
Element text = doc.createText("Empire Burlesque");
title.appendChild(text);
...
}
catch(Exception ex)
{
ex.printStackTrace();
}
23
}
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Beispiel XML des erzeugten DOM‘s:
<?xml version="1.0"?>
document
document
<catalog>
<cd country="USA">
element
element
<title>Empire
Burlesque</title>
element
element
</cd>
</catalog>
element
element
text
text
24
attribut
attribut
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Erzeugung eines DOM‘s anhand einer Datei:
25
1.
DocumentBuilderFactory Implementation
festlegen
2.
DocumentBuilderFactory instanzieren
(und konfigurieren )
3.
DocumentBuilder mittels Factory
instanzieren (und konfigurieren)
4.
Dateizugriff festlegen
5.
Datei mit dem DocumentBuilder parsen,
dies ergibt ein Document (DOM)
6.
Mittels der Factory Elemente erzeugen und
im neuen Document einfügen.
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM anhand Datei einlesen, Java Beispiel (1/2):
public class Run
{
public static void main(String[] args)
{
try {
// Factory erzeugen
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
// Parser holen
DocumentBuilder builder = factory.newDocumentBuilder();
// Dokument Parsen und DOM erzeugen
File f = new File("catalog.xml");
Document doc = builder.parse(f);
...
26
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Auf ein DOM Element zugreifen, Java Beispiel (2/2):
// Root Element holen
Element root = doc.getDocumentElement();
// erstes KindElement auslesen
Element cd = (Element) root.getFirstChild();
// Attribut eines Elementes lesen
String country = cd.getAttribute("country");
// erstes KindElement auslesen
Element title = (Element) cd.getFirstChild();
// erstes KindElement auslesen Æ Text Node
Node text = title.getFirstChild();;
// Text des Text Nodes auslesen
String value = text.getNodeValue();
...
}
catch(Exception ex)
{ ex.printStackTrace(); }
27
}
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Die wichtigsten DOM Interfaces:
Comment
Processig
Instruction
Notation
NodeList
DOM
Implement
childNodes
implementation
parentNode
Document
Type
Character
Data
Text
doctype
Node
CDATA
Section
ownerDocument
Element
attributes
Entity
Attribut
Entity
Reference
Named
NodeMap
28
Document
Fragment
Document
documentElement
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Node (1/2)
Node ist der grundlegende Basistyp. Alle wichtigen
DOM Bestandteile sind von diesem abgeleitet.
29
Methode (W3C):
Beschreibung:
getNodeName()
gibt den Namen des Nodes zurück
getNodeType()
gibt den Typ des Nodes zurück
getNodeValue()
gibt den Wert des Nodes zurück
Î nur bei CharacterData
getParentNode()
gibt den Eltern Node zurück
getOwnerDocument()
gibt das Dokument des Nodes zurück
nextSibling()
gibt den nächsten Node derselben Hierarchie zurück
Î Geschwister
previousSibling()
gibt den vorangehenden Node derselben Hierarchie
zurück Î Geschwister
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Node (2/2)
Methode (W3C):
Beschreibung:
getAttributes()
Gibt eine Map von Attributen zurück
hasChildNodes()
gibt zurück ob dieser Node Kinder hat
getChildNodes()
gibt eine Liste der Node Kinder zurück
firstChild()
gibt das erste Node Kind zurück
lastChild()
gibt das letzte Node Kind zurück
appendChild(Node)
Fügt einen Node hinzu
removeChild(nodeName)
entfernt einen Node aus der Hierarchie
replaceChild(newNode,oldNode) tauscht einen Node gegen einen
anderen aus.
insertBefore(newNode,refNode) Erlaubt das einfügen eines Nodes an
einer beliebigen Stelle
cloneNode(boolean)
30
Erzeugt ein flat- oder deep-Copy von
sich selber
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.NodeList
NodeList ist eine Ansammlung, Liste von Nodes.
NodeList ist nicht vom Typ Node.
Methode (W3C):
Beschreibung:
length()
gibt die Anzahl Nodes zurück.
item(int)
Gibt den Node einer bestimmten Position zurück. Index
startet
Java Beispiel, Iteration über eine Nodelist:
NodeList nlist = node.getChildNodes();
for(int i=0; i<nlist.getLength(); i++)
{
Node child = nlist.item(i);
}
31
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Document (1/2)
Document ist der oberste Node und beinhaltet das
gesamte Dokument
Document bildet zugleich eine Factory. Mit Ihr
werden sämtliche andere NodeTypen erzeugt.
Methode (W3C):
Beschreibung:
getDocumentElement() gibt den Root Node des Dokuments zurück
32
getDocType()
gibt die DTD oder Schema zurück
getImplementation()
gibt die DOM, JAXP Implementation zurück
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Document (2/2)
Factory Method (W3C):
Beschreibung:
createAttribute(String)
Erzeugt ein neues Attribut
createElement(String)
Erzeugt ein neues Element
createCDATA(String)
Erzeugt eine neue CDATA Sektion
createTextNode(String)
Erzeugt Text, PCDATA Sektion
createComment(String)
Erzeugt ein XML Kommentar
createDocumentFragment()
Erzeugt ein temporäres Dokument
createEntityReference(String) Erzeugt eine Referenz auf eine Entity
33
createProcessingInstruction(
String,String)
Erzeugt eine neue XML
Prozessinstruktion
getElementsByTagName(String)
Sucht einen Node nach dem Namen
importNode(Node,boolean)
Importiert Nodes eines anderen
Dokuments
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Element (1/2)
Element bildet einen XML Tag ab.
34
Methode (W3C):
Beschreibung:
getTagName()
gibt den Namen des Nodes zurück Î getNodeName()
getAttribute
(String)
gibt den Wert des Attributs mit dem Namen zurück
getAttributeNode
(String)
gibt das Attribut mit dem Namen als Objekt zurück
getElementsByTag
Name(String)
Gibt die Nodes mit dem Namen zurück Î NodeList
normalize()
fasst die Kinder Text Nodes zu einem zusammen
removeAttribute
(Node)
entfernt das angegebene Attribut
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Element (2/2)
Methode (W3C):
Beschreibung:
setAttribute
(String, String)
erzeugt ein neues Attribut mit Wert
setAttributeNode
(Node)
erzeugt ein neues Attribut mit Wert anhand des Nodes
Java Beispiel, Erzeugung eines Elements mit Attribut:
Element e = document.createElement("Element");
root.appendChild(e);
e.setAttribute("myAttribut", "myValue");
35
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Attr
Attr bildet ein Attribut ab.
Methode (W3C):
Beschreibung:
getName()
gibt den Namen des Attributs zurück
getSpecified()
prüft ob das Attribut von Anfang an existiert hat
getValue()
gibt den Wert des Attributs zurück
setValue(String)
setzt den wert eines Attributs
getOwnerElement() gibt das Element des Attributes zurück
Java Beispiel, Auslesen eines Attributs:
Attr attr = element.getAttributeNode("MyAttribut")
String value = attr.getValue();
36
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.CharacterData (1/2)
CharacterData bildet die Basisklasse um Elemente
mit Text abzubilden z.B. Text, Kommentar, CDATA
CharacterData ist selber abstrakt und kann nicht
instanziert werden ! Methoden stehen in den
Subklassen dann aber zur Verfügung
37
Methode (W3C):
Beschreibung:
appendData(String)
fügt Zeichen hinzu
deleteData(int,int)
entfernt an einer Position eine Anzahl von
Zeichen
getData()
gibt die Zeichenfolge zurück
getLength()
gibt die Anzahl Zeichen zurück
insertData(int,String) fügt an einer Position Zeichen ein
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.CharacterData (2/2)
Methode (W3C):
Beschreibung:
replaceData(int,int,
String)
tauscht an einer Position eine Anzahl Zeichen aus
setData(String)
setzt die Zeichenfolge
substringData(int,int) gibt die Zeichenfolge an der Position mit der
Länge zurück
38
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Text
Text bildet normalen Text ab (PCDATA).
Text selber ist ebenfalls ein Node und muss stets
einem Element zugeordnet werden.
Methode (W3C):
Beschreibung:
splitText(int)
Splittet den Text an der gegebenen Position und gibt
den Rest zurück.
Java Beispiel, Erzeugung eines Elementes mit Text:
Element e = document.createElement("Element");
root.appendChild(e);
Text t = document.createTextNode("This is text...");
e.appendChild(t);
39
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.CDATASection
CDATA bildet nicht „parsbaren“ Text ab. Solchen
Text kann Spezialzeichen enthalten z.B. „<“ od. „>“
CDATA selber ist ebenfalls ein Node und muss stets
einem Element zugeordnet werden.
CDATA ist von Text abgeleitet und hat keine eigenen
Methoden
Java Beispiel, Erzeugung eines Elementes mit CDATA:
Element e = document.createElement("Element");
root.appendChild(e);
CDATASection c = document.createCDATASection("special <...>");
e.appendChild(c);
40
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
DOM Interface: org.w3c.dom.Comment
Comment bildet ein XML Kommentar ab <!-- xxx -->
Comment ist von CharacterData abgeleitet und hat
keine eigenen Methoden
Java Beispiel, Erzeugung eines Kommentars:
Comment c = document.createComment("this is just a comment");
root.appendChild(c);
document.appendChild(c);
41
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
<< DOM Serialisierung >>
42
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM Serialisierung
Erzeugung von XML Dateien aus DOM:
Unter Serializierung wird die Umwandlung von
Objekten in ein schreibbares Format
verstanden (z.B. Binäre oder Text-Sequenz)
DOM ist ein Objektmodell welches in ein XML
Text Datei geschrieben bzw. serialisiert werden
kann.
root1
root1
cd
cd
title
title
43
artist
artist
<xml>
price
price
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM Serialisierung
Erzeugung von XML Dateien aus DOM:
Die Serialisierung ist noch nicht Teil des JAXP,
deshalb müssen spezifische Produkte
eingesetzt werden (nicht standardisierte API‘s)
Xerces bietet in seiner Distribution ein Package
„org.apache.xml.serialize“ an um DOM
Daten zu serialisieren z.B. in XML, HTML,Text.
1. Factory instanzieren
2. Ausgabeformatierungen festlegen
3. Serializer mittels Factory erzeugen und
Formatierungen zuweisen
4. OutputStream festlegen
5. DOM serialisieren
44
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM Serialisierung
DOM Serialisierung mittels Xerces Serializer:
Document doc = ... // DOM holen, erzeugen (z.B. Folie 22/23)
// Factory erzeugen
SerializerFactory factory =
SerializerFactory.getSerializerFactory("xml");
// Ausgabeformatierung festlegen
OutputFormat format = new OutputFormat();
format.setEncoding("iso-8859-1");
format.setIndent(4);
format.setIndenting(true);
// Serializer anhand Factory erzeugen
Serializer serializer = factory.makeSerializer(format);
// Ausgabe Stream festlegen
serializer.setOutputByteStream(System.out);
// DOM serialisieren
serializer.asDOMSerializer().serialize(doc);
45
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP
<< DOM Handhabungen >>
46
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM‘s importieren
Zwei XML Dateien zusammenführen:
DOM 2
<xml2>
<xml1>
DOM 1
<xml>
XML Dateien können nicht einfach aneinander
gereiht werden, da sie ja Baumstrukturen sind.
47
Um 2 DOM‘s zusammenzuführen muss das eine
DOM in das andere DOM importiert werden.
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM‘s importieren
XML Dateien zusammenführen:
Das importieren ist notwendig um so die
Namespaces zu berücksichtigen. Ohne dies
können Exceptions auftreten.
z.B.:
Document doc1 = builder.parse(file1);
Element root1 = doc1.getDocumentElement();
x
Document doc2 = builder.parse(file2);
Element root2 = doc2.getDocumentElement();
root2.appendChild(root1);
48
1
Exception
1
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM‘s importieren
XML Dateien zusammenführen:
Importiert wird mittels der Methode „importNode()“
dabei kann angeben werden ob auch die
Childelemente berücksichtigt werden sollen.
z.B.:
Document doc1 = builder.parse(file1);
Element root1 = doc1.getDocumentElement();
Document doc2 = builder.parse(file2);
Element root2 = doc2.getDocumentElement();
Node importedRoot1 = doc2.importNode(root1,true)
root2.appendChild(importedRoot1);
49
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM‘s importieren
XML Dateien zusammenführen:
root1
root1
root2
root2
cd
cd
title
title
artist
artist
cd
cd
price
price
title
title
artist
artist
price
price
root1
root1
cd
cd
title
title
50
artist
artist
price
price
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM‘s chopping
XML Datei splitten:
DOM 1
<xml1>
DOM 3
DOM 2
<xml2>
<xml3>
Um ein DOM zu splitten muss dessen Node
entfernt oder kopiert werden.
51
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM chopping
XML Datei splitten:
z.B. Node in ein anderen DOM verschieben:
Document doc1 = builder.parse(file1);
Element root1 = doc1.getDocumentElement();
Node cd = root1.getFirstChild();
root1.remove(cd);
Document doc2 = builder.parse(file2);
Element root2 = doc2.getDocumentElement();
Node importedCD = doc2.importNode(cd,true);
root2.appendChild(importedCD);
52
Wenn der Node entfernt wird gehört er noch immer
dem Document. Deshalb muss er danach importiert
werden wenn er weiter verwendet wird.
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM copy
XML Datei kopieren:
Nodes können kopiert werden. Hierbei kann
angegeben werden ob die Childelemente mit
berücksichtigt werden sollen oder nicht.
z.B. Node kopieren:
Document doc = builder.parse(file);
Element root = doc.getDocumentElement();
Node cd = root.getFirstChild();
Node clonedCD = cd.clone(true);
53
Beim Kopieren gehört der geclonte Node
immer noch dem Document, auch wenn es
sich nicht in dessen Struktur befindet.
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP
<< DOM Practise Tips >>
54
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM Tips
Nachteile des JAXP – DOM API (1/2):
Keine Serializierung von DOM Daten. Muss über
andere Produkte gemacht werden. (kommt aber
mit DOM Level 3)
Î Xerces bietet ein API zur Serialisierung
Zugriff auf einzelne Elemente nicht besonders
freundlich. Suchkriterien nicht vorhanden.
z.B. suchen nach Element mit Attribut Wert.
Î XML bietet hierzu XPath ist jedoch nicht Teil
von JAXP. Muss über andere Produkte gemacht
werden z.B. mit Xalan
55
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM Tips
Nachteile des JAXP – DOM API (2/2):
Aufbau von komplexen Strukturen mittels
DOM API kann sehr aufwendig werden und
kostet erheblich Ressourcen (Speicher,
Performance). Auch die Flexibilität und
Lesbarkeit des Codes lässt oft zu wünschen
übrig.
Î Nur einfache Struktur erzeugen und
danach mittels einer XSL Transformation in
komplexe Struktur überführen.
56
1
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM Tips
Weitere Tips:
Ein erzeugtes DOM Element sollte immer ein
Parent haben, ansonsten kann es später zu
Problemen führen wenn man mittels XPath auf
die Eltern Daten zugreifen will.
z.B.:
Element e = doc.createElement("Element");
parent.appendChild(e);
Node n = XPathAPI.selectSingleNode(e,"/root/Element");
57
1
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
<< JAXP und DOM
Konfiguration >>
58
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP
Was ist JAXP ?
JAXP = Java API for XML Processing
JAXP ist ein API zur XML Verarbeitung:
Parsern, Herstellung und Transformierung
von XML Daten.
JAXP besteht aus 3 Teilen:
• SAX - Simple API For XML
• DOM - Document Object Model
• XSLT - XML Stylesheet Transformation
59
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - Konfiguration
JAXP Implementationen festlegen:
Die JAXP Implementationen können auf
verschiedene Weise angegeben werden. Die
JVM versucht dabei in folgender Reihenfolge
die Konfiguration zu finden:
1. Über die System Properties
2. Über die „jaxp.properties“ im JAVA_HOME
3. Mittels dem „Jar Service Provider
Mechanism“
4. Falls nichts gefunden wurde wird jeweils die
Standard Implementation der jeweiligen
Plattform genommen.
JAVA_HOME\jre\lib\rt.jar Î Crimson
60
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - Konfiguration
JAXP Implementationen festlegen:
Die Implementation kann beim Start der JVM mittels
den SystemProperties festgelegt werden:
javax.xml.parsers.SAXParserFactory
javax.xml.parsers.DocumentBuilderFactory
Als Wert muss eine Klasse angegeben werden, die
dieses Interface unterstützt.
z.B:
java
–classpath xerces.jar
-Djavax.xml.parsers.DocumentBuilderFactory=
org.apache.xerces.jaxp.DocumentBuilderFactor
yImpl
TestDOM
Classpath mit Implementations-jar angeben &
Klassennamen inkl. Package.
61
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP - DOM
Konfiguration der DocumentBuilderFactory:
Folgende Konfigurationen können bei der Factory
gesetzt werden:
•
•
•
•
•
•
Attributes (Herstellerabhängig spez. Features)
NameSpaceAware (Namespace berücksichtigen) !!
Validation (Validierung durchführen, DTD, XSD) !!
ExpandEntityReferences (Entities auflösen)
IgnoringComments (Kommentare nicht berücksichtigen)
IgnoringElementContentWhitespace (Spaces in Element
Content nicht berücksichtigen
• Coalescing (CDATA zu Text konvertieren)
Diese Konfigurationen müssen jeweils bevor ein neuer
DocumentBuilder erstellt wird, gesetzt werden.
62
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM & Namespaces
Handhabung von Namespaces:
Namespaces werden als default ignoriert.
Deshalb muss die Factory zuerst konfiguriert
werden, falls Namespaces verwendet werden!
1
Die Aktivierung folg durch setzen eines Flags in
der DocumentBuilderFactory:
setNameSpaceAware(true)
z.B.:
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
factory.setNameSpaceAware(true);
DocumentBuilder builder = factory.newDocumentBuilder();
63
...
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM & Namespaces
Erstellen eines Elementes mit Namespace:
Um ein Element mit Namespace zu erzeugen
muss die Methode createElementNS()
aufgerufen werden.
z.B. Element mit Namespace ohne prefix erzeugen:
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
factory.setNameSpaceAware(true);
DocumentBuilder builder = factory.newDocumentBuilder();
Document doc = builder.newDocument();
Element root =
doc.createElementNS("http://myURL","root");
64
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM & Namespaces
Erstellen eines Elementes mit Namespace:
Um den Namespace später auszugeben, muss
dieser mit „setAttributeNS()“ explizit
gesetzt werden. Dabei muss der XMLNS
Namespace angegeben werden.
z.B. Element mit Namespace ohne prefix erstellen:
Element root =
doc.createElementNS("http://myURL","root");
root.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns",
"http://myURL");
z.B. XML Element mit Namespace ohne prefix:
<root xmlns="http://myURL"/>
65
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM & Namespaces
Erstellen eines Elementes mit Namespace:
z.B. Element mit Namespace mit prefix erstellen:
Element root =
doc.createElementNS("http://myURL",„my:root");
root.setAttributeNS("http://www.w3.org/2000/xmlns/", "xmlns:my",
"http://myURL");
z.B. XML Element mit Namespace mit prefix:
<my:root xmlns:my="http://myURL"/>
66
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP – DOM & Validierung
Handhabung der Validierung:
Validierung ist als default deaktiviert. Falls DTD
oder XSD zum Einsatz kommen, muss zuerst
die Factory konfiguriert werden.
Die Aktivierung folg durch setzen eines Flags in
der DocumentBuilderFactory:
setValidating(true)
z.B.:
DocumentBuilderFactory factory =
DocumentBuilderFactory.newInstance();
factory.setValidating(true);
DocumentBuilder builder = factory.newDocumentBuilder();
67
...
XML mit
Java OpenSource
(c) Mark Egloff 2003
JAXP- DOM Links
68
z
DOM: http://www.w3.org/TR/DOM-Level-3-Core/
z
SUN DOM Tutorial:
http://java.sun.com/xml/jaxp/dist/1.1/docs/tutorial/dom/index.html
z
IBM DOM Tutorial:
http://www-106.ibm.com/developerworks/edu/x-dw-xudom-i.html
z
Xerces: http://xml.apache.org/xerces2-j/index.html