 |
|
|
Einleitung
Neu in XSLT/XPath 2.0
Vorteile des Umstiegs auf XSLT/XPath 2.0
Wie bei jeder 2.0 Release, enthält die Version 2.0 von XSLT und XPath Funktionen, die in den 1.0 Spezifikationen noch nicht vorhanden waren. Außerdem gibt es in Release 2.0 auch hinsichtlich der Sprachen viele neue und gleichzeitige prägnantere, effizientere, flexiblere und erheblich leistungsstärkere Features.
XPath 2.0 wurde gemeinsam von der W3C XSL- und der XQuery-Arbeitsgruppe ausgearbeitet. XQuery ist eigentlich eine Erweiterung von XPath 2.0.
XPath 2.0 wird sowohl mit XSLT 2.0 als auch mit XQuery 1.0 verwendet. Während XSLT weiterhin vornehmlich zum Transformieren von XML-Daten eingesetzt wird, soll XQuery der Standard bei der Abfrage von XML-Dokumenten werden. Zwar verwenden sowohl XQuery als auch XSLT 2.0 XPath 2.0 als Path-Sprache, doch haben die XQuery-Extensionen zu XPath 2.0 für XSLT-Developer keine praktische Bedeutung. XPath 2.0 und XSLT 2.0 sind untrennbar verbunden und jederzeit einsetzbar.
Altova ist der erste Anbieter in dieser Sparte, der eine native, produktionsreife Implementierung der umfangreichen neuen XSLT 2.0 und XPath 2.0-Spezifikationen in allen seinen XML-Entwicklungstools und seinem Content-Editiertool für Unternehmensanwender bietet. Somit können Sie nun die führenden XML-Tools für die standardkonforme Arbeit mit XSLT 2.0 und XPath 2.0 verwenden und so alle Möglichkeiten der XML-Standards zur Gänze ausschöpfen. Dieses Material ist für Developer gedacht, die mit XPath und XSLT vertraut sind. Nähere Informationen über die Vorteile der Verwendung von XSLT 2.0 für Unternehmen und Developer finden Sie im Analysebericht von InfoTrends/CAP Ventures mit dem Titel: "XSLT 2.0: Understanding the Development and Business Benefits."
Beachten Sie bitte, dass XSLT 2.0 und XPath 2.0 zwar so konzipiert sind, dass Sie mit der entsprechenden 1.0 Version rückwärts kompatibel sind. Die Verwendung der neuen Features von XPath 2.0 mit XSLT 1.0 wird jedoch im Allgemeinen nicht unterstützt.
Die wichtigsten Verbesserungen an XSLT 2.0 und XPath 2.0 sind hier aufgelistet und weiter unten beschrieben. - Rückgabe von Nodesequenzen
- Unterstützung von XML-Schema-Datentypen
- Abschaffung von Result Tree Fragments (RTFs)
- Unterstützung von Node-Gruppierung
- Aggregationsfunktionen
- "For"-Schleifen
- Unterstützung von bedingten Ausdrücken
- Unterstützung von Regular Expressions
- Mehrere Ausgabedokumente
- XHTML-Ausgabe
- Benutzerdefinierte Funktionen
- Neue Funktionen und Operatoren
Nodesequenzen
XPath 1.0 Ausdrücke geben ein node-set zurück, wobei es sich um eine nicht geordnete Sammlung von Datenelementen handelt. In XPath 2.0 gibt jeder XPath Ausdruck eine Sequenz zurück. Hierbei handelt es sich um eine geordnete Gruppe von atomaren Werten oder Nodes. Die Sequenzen sind nicht verschachtelt und können doppelte Datenelemente, eine weitere Verbesserung im Vergleich zu XPath 1.0, enthalten. Sie können sogar in XPath 2.0 selbst eine Sequenz erstellen. Ein einfacher Ausdruck kann eine Gruppe von Werten erzeugen, z.B:
( 'this', 'that', 'the other' ), ( 'this', 'these' )
Mit diesem Ausdruck werden zwei Sequenzen erstellt und zu einer verbunden - eine einfache Aufgabe, die in XPath 1.0 nahezu unmöglich ist.
Unterstützung von Schema-Datentypen
XPath 2.0 bietet weit bessere Datentypunterstützung. Während in XPath 1.0 alles als String verarbeitet wird, kombiniert XPath 2.0 die Möglichkeiten von XML und XML-Schema mit der Unterstützung für XML Schema-Datentypen. XPath 1.0 unterstützte vier Arten von Ausdrücken, doch mit der Unterstützung von primitiven Typen aus XML Schema stehen Ihnen nun in der Version 2.0 19 weitere simple Types zur Auswahl zur Verfügung, die Sie diese genau an die Anforderungen Ihrer Applikation adaptieren können. Probieren Sie diesen Ausdruck im XMLSpy XPath Evaluator:
xs:token( "city" ) instance of xs:string
Wie Sie sehen werden, ist die Antwort (ein xs:boolean) true, da ein xs:token ein Typ ist, der in der Hierarchie der XML-Schemadatentypen von xs:string abgeleitet ist.
Konvertierung von RTFs in node-sets
Result Tree Fragments (RTFs) stellten eine große Einschränkung von XSLT 1.0 dar. Um Datenelemente in temporären Strukturhierarchien verarbeiten zu können, wurden mühsame Umgehungslösungen oder proprietäre Erweiterungen benötigt. In XSLT 2.0 gibt es keine RTFs mehr. xsl:variable gibt ein true node-set (Sequenz) zurück, mit dem Sie genau wie mit jeder anderen Sequenz arbeiten können. Wie Sie außerdem in diesem kurzen Beispiel sehen, können Sie durch Variablen, die temporäre Strukturhierarchien enthalten, so navigieren als enthielten Sie ein Dokument-Root-Element.
<xsl:template match="/">
<xsl:variable name="temp">
<xsl:element name="a">
<xsl:element name="b">first</xsl:element>
<xsl:element name="b">second</xsl:element>
</xsl:element>
</xsl:variable>
<result>
<xsl:value-of select="$temp/b[2]"/>
</result>
</xsl:template>
Das Ergebnis dieser Transformation ist ein einziger Node mit dem Wert “second”. Wie Sie sehen, ist die Variable “$temp” im Gegensatz zu XPath 1.0 ein vollständig durchgängiger Nodebaum.
Node-Gruppierung
XSLT 2.0 bietet integrierte Unterstützung für Gruppierungen, eine Aufgabe, die in XSLT 1.0 extrem schwierig und fehleranfällig war. In XSLT 2.0 gibt es nun xsl:for-each-group, welches ihnen gestattet, eine Sammlung von Nodes zu gruppieren (z.B. eine Adressenliste nach Ländern). Das xsl:for-each-group Element unterstützt drei Attribute: group-by, group-adjacent und group-starting-with. Mit Hilfe der current-group() Funktion können Sie auf eine Gruppe Bezug nehmen, nachdem Sie diese definiert haben. Zusammengehörige Daten können nun einfach gruppiert werden, um verschiedene XML-Datenansichten zu erzeugen.
Nehmen wir als einfaches Beispiel eine Tabelle zur Behebung von Problemen, die Symptome, Ursachen und Lösungen enthält:
<table>
<title>troubleshooting</title>
<tr>
<td name="symptom">wet</td>
<td name="symptom">muddy</td>
<td name="cause">raining</td>
<td name="solution">get hat</td>
<td name="solution">wear boots</td>
</tr>
<tr>
<td name="symptom">hungry</td>
<td name="cause">lunch time</td>
<td name="solution">eat lunch</td>
</tr>
<table>
Vielleicht möchten Sie ein XML-Dokument erstellen, das die Elemente jeder Kategorie so gruppiert, dass jede Kategorie der Wert eines Elements wird und dass alle Werte für diese Kategorie in einem zweiten Element Teile einer kommagetrennten Liste werden. Mit XSLT 2.0 könnten Sie im Handumdrehen folgende Vorlage erstellen:
<xsl:template match="/">
<sets>
<xsl:for-each select="table/tr">
<xsl:for-each-group select="td" group-by="@name">
<a>
<xsl:value-of select="@name"/>
</a>
<b>
<xsl:value-of select="current-group()"
separator=", "/>
</b>
</xsl:for-each-group>
</xsl:for-each>
</sets>
</xsl:template>
Das Ergebnis würde folgendermaßen aussehen:
<sets>
<a>cause</a>
<b>raining</b>
<a>solution</a>
<b>get hat, wear boots</b>
<a>symptom</a>
<b>wet, muddy</b>
<a>cause</a>
<b>lunch time</b>
<a>solution</a>
<b>eat lunch</b>
<a>symptom</a>
<b>hungry</b>
</sets>
Aggregation
Die XPath 2.0 Aggregationsfunktionen min ( ), max ( ), avg ( ), usw. lassen sich mit den Gruppierungsfunktionen in XSLT 2.0 kombinieren, sodass Sie Funktionen an Daten in Gruppen anwenden können. Mit diesen beiden Features haben Sie nun noch mehr Möglichkeiten für die Darstellung strukturierter Daten in XML. (Ein Beispiel dafür, wie diese Funktionen verwendet werden, finden Sie im Codebeispiel unter Mehrere Ausgabedokumente.) "For"-Schleifen, bedingte Ausdrücke, Regular Expressions
XPath 1.0 wurde als kryptisch und schwierig zu erlernen kritisiert. Im Gegensatz dazu ist XPath 2.0 dank Erweiterungen wie der Unterstützung von for-Schleifen, bedingten Ausdrücken und Regular Expressions eine echte Programmiersprache. Programmierer sind mit diesen gebräuchlichen Programmierkonstrukten vertraut, dies gewährleistet daher eine flache Lernkurve für XSLT/XPath 2.0, schnelleres Schreiben von Code und damit eine größere Produktivität.
Viele XPath-User werden es zu schätzen wissen, dass sie nun die Möglichkeit haben, eine Variable zu erstellen, die den Wert jedes Mitglieds einer Sequenz nacheinander in eine for-Schleife setzt. Angenommen Sie möchten z.B. wissen, ob die oben verwendete Datentabelle many oder few Elemente enthält. Mit dem folgenden XPath-Ausdruck erhalten Sie die Antwort:
for $row in //tr
return
if ( count( $row/td ) > 3 )
then "many"
else "few"
Mehrere Ausgabedokumente
In XSLT 1.0 konnte der XSLT-Prozessor in einem Durchgang nur ein Ausgabedokument erzeugen. In XSLT 2.0 lassen sich in einem einzigen Durchgang mehrere Dokumente anhand eines Stylesheets erzeugen, ohne dass dafür proprietäre Erweiterungen und separates Skripting erforderlich wären oder Batchverarbeitungen in anderen Sprachen durchgeführt werden müssen. Zusätzlich dazu bietet XSLT 2.0 verbesserte Unterstützung für mehrere Input-Dokumente (inkl. nicht-XML-Input-Dokumente u. v. m.).
Wenn Sie in der obigen Tabelle zu jedem <td> ein "incidents"-Attribut hinzufügen, können Sie Ihre Vorlage durch Verwendung des xsl:result-document Elements so adaptieren, dass Sie sowohl ein detailliertes Dokument als auch ein Übersichtsdokument erhalten:
<xsl:template match="/">
<xsl:result-document href="output1.xml">
<sets>
<xsl:for-each select="table/tr">
<xsl:for-each-group select="td" group-by="@name">
<a><xsl:value-of select="@name"/> (<xsl:value-of
select="count ( current-group() )"/>) </a>
<b>
<xsl:value-of select="current-group()" separator=", "/>
<xsl:if test="count( current-group() ) > 1">
(average: <xsl:value-of select="avg
( current-group()/@incidents ) "/>)
</xsl:if>
</b>
</xsl:for-each-group>
</xsl:for-each>
</sets>
</xsl:result-document>
<xsl:result-document href="output2.xml">
<summary>
<xsl:for-each select="table/tr">
<xsl:for-each-group select="td" group-by="@name">
<row>
<xsl:value-of select="@name"/> has <xsl:value-of
select="count ( current-group() )"/>
<xsl:choose>
<xsl:when test="count( current-group() ) > 1"> items,
each occurring an average of <xsl:value-of select="avg
( current-group()/@incidents ) "/> times.</xsl:when>
<xsl:otherwise> item that occurs <xsl:value-of select="avg
( current-group()/@incidents ) "/> times. </xsl:otherwise>
</xsl:choose>
</row>
</xsl:for-each-group>
</xsl:for-each>
</summary>
</xsl:result-document>
</xsl:template>
Nach Ausführung könnte das Ergebnis folgendermaßen aussehen:
<sets>
<a>cause (1) </a>
<b>raining</b>
<a>solution (5) </a>
<b>get hat, wear boots, use windshield wipers, use headlights,
other (average: 2.2)</b>
<a>symptom (4) </a>
<b>wet, muddy, slippery, poor visibility (average: 2.75)</b>
<a>cause (1) </a>
<b>lunch time</b>
<a>solution (1) </a>
<b>eat lunch</b>
<a>symptom (1) </a>
<b>hungry</b>
</sets>
und
<summary>
<row>cause has 1 item that occurs 11 times. </row>
<row>solution has 5 items, each occurring an average of 2.2 times.</row>
<row>symptom has 4 items, each occurring an average of 2.75 times.</row>
<row>cause has 1 item that occurs 8 times. </row>
<row>solution has 1 item that occurs 8 times. </row>
<row>symptom has 1 item that occurs 8 times. </row>
</summary>
Zusätzlich zur Ausgabe mehrerer Dokumente bietet XSLT 2.0 verbesserte Unterstützung für mehrere Input-Dokumente (inkl. nicht-XML-Input-Dokumente u. v. m.).
XHTML-Ausgabe
XSLT 1.0 gestattet die Ausgabe in XML, HTML und Text. In Version 2.0 wird nun auch die Ausgabe in XHTML unterstützt. Benutzerdefinierte Funktionen
Mit Hilfe der xsl:function Deklaration in XSLT 2.0 können Sie XSLT-Funktionen für die Verwendung in XPath 2.0 Ausdrücken definieren. xsl:function deklariert den Namen, die Parameter und die Implementierung einer benutzerdefinierten Funktion, die in einem bestimmten Stylesheet in einem XPath-Ausdruck verwendet wird.
Um eine Vorlage zu erstellen, die dieses XSLT-Element enthält:
<xsl:value-of select=" a:nextNumber( 1 )"/>
müssten Sie mit Hilfe von xsl:function a:nextNumber als benutzerdefinierte XPath-Funktion definieren. Nachdem Sie a:nextNumber definiert haben, ist die Funktion an allen Stellen im Stylesheet, die die Definition enthalten, für XPath-Ausdrücke verfügbar.
<xsl:function name="a:nextNumber">
<xsl:param name="number" as="xs:integer"/>
<xsl:choose>
<xsl:when test="$number = 1">
<xsl:sequence select="string('Two')"/>
</xsl:when>
<xsl:when test="$number = 2">
<xsl:sequence select="string('Three')"/>
</xsl:when>
</xsl:choose>
</xsl:function>
Das Ergebnis des Aufrufs dieser Funktion wäre, dass das Wort "Two" zu einem Textnode im Ergebnisbaum hinzugefügt würde.
Neue Funktionen und Operatoren
XPath 2.0 unterstützt eine enorme Anzahl von neuen Funktionen und Operatoren, unter anderem: - every – überprüft, ob alle (im Gegensatz zu einem beliebigen) Node ein Kriterium erfüllt
- intersect – eine einfachere Methode, um zu überprüfen, ob ein Node in einem node-set enthalten ist
- except – wählt alle Nodes eines node-set aus mit Ausnahme von XYZ
- Und vieles mehr
Um Ihnen einen Eindruck davon zu vermitteln, wie einfach und elegant XPath 2.0 Lösungen sein können, hier ein kurzes Beispiel für die Verwendung des except Operators: Wir verwenden wieder die Problembehebungstabelle oben und wenden die folgende Anweisung mit Hilfe des XMLSpy XPath Evaluators an:
//td except //td[@name = 'cause']
Als Ergebnis erhalten wir ohne weiteres Zutun eine Liste aller Symptome und Lösungen in der Datei.
Bitte beachten Sie: Die obige Liste ist bei weitem nicht vollständig. XSLT 2.0 und XPath 2.0 bieten unzählige neue Features und Verbesserungen. Ein vollständige Liste der wichtigsten Features von XSLT 2.0 finden Sie im XSL Transformations (XSLT) Version 2.0 W3C Working Draft. Die Features von XPath 2.0 sind im XML Path Language (XPath) 2.0 W3C Working Draft beschrieben.
Der XSLT 2.0 Working Draft wurde seit Ende 2003 nur wenig verändert. Dies lässt darauf schließen, dass er nun vor dem Abschluss steht und es bis zur endgültige Empfehlung nur mehr geringfügige Änderungen geben wird.
Zwar wird XPath 2.0 auch mit XQuery verwendet, doch ist die dafür erforderliche Datenbankunterstützung für XQuery noch nicht ganz spruchreif. Im Gegensatz dazu ist für XSLT 2.0 keine Unterstützung durch Backend-Technologien erforderlich, sodass es bereits heute zusammen mit XPath 2.0 verwendet werden kann. Altova bietet bereits jetzt marktreife Unterstützung für XSLT 2.0 und XPath 2.0 in seinem preisgekrönten XSLT-Prozessor, der in alle Altova-Produkte (siehe unten) integriert ist und auch separat lizenzgebührenfrei erhältlich ist. Der Altova XSLT 2.0 Prozessor gestattet Ihnen, bei XSLT/XPath 2.0 von der Experimentierphase zur Implementierung in praktischen Applikationen überzugehen. Wenn Sie sich bereits jetzt mit XPath 2.0 und XSLT 2.0 vertraut machen, eignen Sie sich zusätzlich das Know-how für XQuery-Entwicklungen von morgen an.
Die Vorteile von XSLT/XPath 2.0 für Entwickler und Unternehmer sind zu bedeutend, um ignoriert werden zu können. XSLT 2.0 ist rückwärts kompatibel mit XSLT 1.0, sodass Sie die Funktionen von XSLT/XPath 2.0 mit wenigen Ausnahmen in Ihren bestehenden XSLT Stylesheets einsetzen können, ohne normalerweise Änderungen vornehmen zu müssen.
Ein weiterer Vorteil ist die flache Lernkurve für diese neuen Spezifikationen. Sie können auf Ihren bestehenden XSLT-, XPath- und XML Schema-Kenntnissen aufbauen, die den neuen XSLT/XPath 2.0 Datentyperweiterungen zugrunde liegen. Mit Version 2.0 wird XPath zu einer echten Programmiersprache. Die Erweiterungen zu beiden Sprachen basieren auf bekannten und bewährten Programmiersprachenkonstrukten, die Ihnen sofort vertraut sein werden.
In Version 2.0 von XSLT und XPath sind nun wichtige Funktionen verfügbar, die in Version 1.0 fehlten. In der Vergangenheit wurden diese Funktionen mittels proprietärer Erweiterungen hinzugefügt, doch dieses führte zu Kompatibilitätsproblemen und zwang Entwickler dazu, nur einen bestimmten XSLT-Prozessor zu verwenden. Die Funktionen, die den XSLT/XPath 2.0 Standards gemäß implementiert wurden, machen diese proprietären Erweiterungen nun überflüssig, wodurch die Kompatibilität erheblich verbessert wird. Stylesheets sind nun vollständig übertragbar. Dasselbe Stylesheet kann mit mehreren Prozessoren auf mehreren Plattformen verwendet werden. So ist mit XSLT 2.0 ein Ende des XLST-Prozessorkriegs in Sicht, so wie XHTML vor einigen Jahren das Ende des Browser-Kriegs bedeutete.
Dank der neuen Features in Version 2.0 wird die Entwicklung nun einfacher und effizienter, wodurch Sie produktiver arbeiten können und bessere Applikationen in kürzerer Zeit entwickeln können.
Erste produktionsreife Implementierung in dieser Sparte
Einer der zwingendsten Gründe überhaupt, noch heute auf XSLT 2.0 und XPath 2.0 umzusteigen ist, dass Altova jetzt eine marktreife standardkonforme Implementierung bietet. Altova XMLSpy ist die Standard-XML-Entwicklungsumgebung und mehr als 2 Millionen User weltweit vertrauen auf die XML-Development-Tools von Altova.
Die marktreife Implementierung dieser Tools ist dem preisgekrönten XSLT-Prozessor zu verdanken, der vor kurzem vom XML Journal zum besten XSLT-Prozessor gekürt wurde. Die Altova Tools unterstützen alle Aspekte der XSLT/XPath 2.0 Entwicklung, vom visuellen Stylesheet Design in StyleVision® 2008 über Datenmapping in MapForce® 2008 bis zum Editieren, Debuggen und Testen in XMLSpy® 2008.
Nähere Informationen zur Altova-Unterstützung von XSLT 2.0 und XPath 2.0 finden Sie auf den entsprechenden Seiten unseres Developer-Portals:
XSLT
XPath
Um gleich jetzt mit XSLT 2.0 und XPath 2.0 arbeiten zu können, laden Sie unsere kostenlose 30-Tage-Testversion des Altova Altova® MissionKit™ 2008 herunter. Holen Sie sich mit dem Altova® MissionKit™ 2008 bis zu 8 Software Tools zum Preis von 2! Der MissionKit enthält die intelligenten Applikationsentwicklungs- und Datenmanagementtools von Altova für Software-Architekten und XML-Entwickler.
|
|
|
|
