Scala XML

Scala XML – Einfache XML Verarbeitung Tobias Neumann | ITGAIN Consulting

XML Literale, Embedded Expressions

XML Literale
Scala hat direkte XML-Sprachunterstütung
XML Literale sind "first-class" val x = <itemNo>1234</itemNo>
Ergebnis ist vom Typ Elem val x = Elem(null,"itemNo",null,TopScope, Text(1234))

XML Element
case class Elem ( val override prefix : java.lang.String, val label : java.lang.String, val override attributes : MetaData, val override scope : NamespaceBinding, val child : Node*) extends Node

Attribute
Attribute im XML-Literal val order = <order prio="high"></order>
Attribute sind eine verkettete Liste von (Un)prexfixedAttribute val attr=new UnprefixedAttribute("prio","high",Null)
Attribute in Elem Elem(null,"order",attr,TopScope)
PrefixedAttribute für Namespaces

Namespaces
Namespaces im XML-Literal val order = <o:order xmlns:o="http://company.com"></o:order>
NamespaceBinding val scope=new NamespaceBinding("o","http://company.com", TopScope)
Namespace in Elem Elem("o","order",null,scope)

Übersicht XML Klassen
Node: Superklasse aller XML-Nodes
NodeSeq: Sequence von Nodes, jede Node erbt von NodeSeq
Elem: Elemente werden dargestellt mit Elem und Text
Elem und Text sind Case Classes  Pattern Matching
NodeSeq Node Elem

Embedded Expressions
Scala Code ist innerhalb des XML Literals ausführbar: <quantity> { 3+5 } </quantity> val quantity = 24 <order prio= { if (quantity > 10) "high" else "normal" } > <itemNo>123</itemNo> <quantity> { quantity } </quantity> </order>

Embedded Expressions
Wenn Ergebnis vom Typ Node oder NodeSeq ist, wird dieses direkt eingefügt
val l = ("1414","5") :: ("6262","3") :: ("1212","1") :: Nil
<order>
{ l.map(p => <item>
<itemNo>{p._1}</itemNo>
<quantity>{p._2}</quantity></item> ) }
</order>
 Beispiel 1

Serialisierung
Einfache Serialisierung mit Embedded Expressions
case class item(val itemNo, val quantity)
{ def toXML= { <item><itemno> { itemno } </itemNo> <quantity> { quantity } </quantity></item> }
}
 Beispiel 2

XML Laden und Speichern
XML.load
Lädt XML aus Reader, InputStream, etc.
XML.loadFile
Lädt XML direkt aus Datei
XML.save
Speichert XML in Datei
XML.saveFull
Speichert XML mit Angabe Encoding und Doctype

Pattern matching

Pattern matching
Pattern matching auf XML Literale
{} ist hier kein Ausdruck, sondern das Pattern
n match {
case <itemNo>{itemno}</itemNo> => println ("Artikelnummer: " + itemno)
case <quantity>{quantity}</quantity> => println ("Anzahl: " + quantity)
case _ =>
}
 Beipiel 3

Pattern matching
Alle Möglichkeiten des Pattern Matching
Binden von Variablen mit @
Wildcards mit _ und _*
case <order>order @ _*</order> => order.foreach(printNode)

Update/Add Nodes
Pattern matching kann gut genutzt werden für Updaten und Hinzufügen von Node
def addNode(n: Node, newNode: Node): Node = n match {
case <order>{oldNode @ _*}</order> => <order>{oldNode}{newNode}</order>
}
 Beipiel 4

XSLT-like Transformation
Pattern matching bietet XSLT-ähnliche Transformation von XML
Definition eines Templates
case <order>{x @ _*}</order> => <html> <head><title>Bestellliste</title></head> <body>{transform(x)}</body> </html>
case <item>{x @ _*}</item> => <p>{transform(x)}</p>
case <itemNo>{x @ _*}</itemNo> => <b>Artikel {x}: </b>
 Beispiel 5

Xpath-like Queries

XPath-like Queries
Die Methoden und bieten Xpath-ähnliche Abfragen auf Nodes
Ergebnis ist wieder vom Typ NodeSeq
XPath Scala Direkt unterge- / ordneter Knoten /item "item" Untergeordneter // Knoten //quantity "quantity" Attribute @ @ //@prio "@prio"

Deserialisierung
Deserisalisierung mit XPath:
def fromXML(n: Node): Item = {
new Item(n "itemNo" text, n "quantity" text)
}
val n = <item><itemNo>5</itemNo> <quantity>5</quantity><item>
val item = Item.fromXML(n)
item: Item = Item(3,5)
 Beispiel 2a

Transformation
Transformation mit XPath
def transformOrderlist(node: Node): Node = { def transform(ns: NodeSeq) : NodeSeq = for (n <- ns "item") yield <p><b>Artikel { n "itemNo" text } : </b> { n "quantity" text } mal</p> {<html><head><title>Bestellliste</title></head> <body><h1>Bestellliste:</h1> { transform(node) } </body></html>}
}
 Beispiel 6

XML-Validierung
XML.load() lädt immer die eingebundene DTD/XSD Datei
Offensichtlich wird aber nicht validiert!
Implementierung des ValidatingMarkupHandlers führt zu Fehlern beim Lesen der DTD
Work-around: Wrapping des SAX Parsers

Beispiel: Scala XML in Lift
Verwendung von XML-Literalen in Lift:
<lift:surround with="default" at="content"> <h2>Welcome to your project!</h2> <p> <lift:helloJax.hello /> </p>
</lift:surround>
class HelloJax { def hello = <span>Welcome to JAX at {new _root_.java.util.Date}</span>
}

Scala vs. Java
Code reduction
Java
DocumentBuilderFactory domFactory = DocumentBuilderFactory. newInstance();
DocumentBuilder builder = domFactory.newDocumentBuilder();
Document doc = builder.parse("order.xml");
Scala
val doc = XML.loadFile("order.xml");

Scala vs. Java
Java
XPathExpression xe = xpath.compile ("//order/item");
NodeList nodes = (NodeList) xe.evaluate(doc,XPathConstants. NODESET);
Scala
val nodes = doc "order" "item"

Fazit
Pros:
Viele Vorteile durch XML-Unterstützung auf syntaktischer Ebene
Verschiedene Techniken
Case classes/pattern matching
XPath
Cons:
XML-Validierung
Dokumentation

Literatur & Links
Scala XML (draft), Emir Burak http://burak.emir.googlepages.com/ scalaxbook.docbk.html
Programming in Scala, Martin Odersky et al
Why simple XML processing is so painful in Java?, Francois Armand http://fanf42.blogspot.com/2009/08/why-simple-xml-processing-is-so-painful.html
XSD Validation in Scala, Sean Wellington http://sean8223.blogspot.com/2009/09/xsd-validation-in-scala.html

Vielen Dank
Tobias Neumann
ITGAIN Consulting GmbH
[email_address]
www.itgain.de

Scala XML

by Tobias Neumann

Accessibility

Categories

Upload Details

Usage Rights

2 Embeds 24

Statistics

Scala XML Presentation Transcript

http://www.slideshare.net	23
http://webcache.googleusercontent.com	1