Grundlagen

XSLT (XSL Transformation) ist eine Programmiersprache, die dazu verwendet wird, eine XML-Datei in ein anderes Dokument zu transformieren. XSLT ist dabei selbst eine Sprache, die auf XML basiert und ein Teil von XSL (eXtensible Stylesheet Language), den Stylesheet-Sprachen der XML-Familie.

Da XSLT XML basierend ist, ist Ihnen der allgemeine Syntax bereits von XML bekannt. In diesem Thema lernen Sie daher nur die Elemente und Attribute von XSLT kennen, für was diese verwendet werden und wie diese funktionieren. Für die Adressierung von Knoten wird die Sprache XPath eingesetzt. Die Abfragesprache XPath haben Sie bereits im vorherigen Kapitel kennengelernt.

Für den Transformationsvorgang werden Programme, die sogenannten XSLT-Prozessoren, benötigt. XSLT-Prozessoren können aus dem Internet bezogen werden. Zudem sind die meisten Browser in der Lage, eine XSL-Transformation durchzuführen.

Funktionsweise

Eine XSLT-Datei enthält ein Skript, welches angibt, wie ein bestimmter Baum in einen anderen Baum transformiert (also „übersetzt“) werden soll. Typischerweise wird dabei ein XML-Dokument in ein HTML-Dokument (meistens also zur direkten Darstellung im Browser) übersetzt. Es ist jedoch auch möglich, ein XML-Dokument in ein anderes XML-Dokument (z. B. zur Umsetzung in eine andere Baumstruktur oder zum Filtern von Inhalten) oder ein XML-Dokument in ein anderes XML basierendes Dokument zu transformieren.

Ein XSLT-Skript kann für mehrere XML-Dokumente eingesetzt werden (so wie auch eine CSS-Datei in mehreren HTML-Dokumenten eingesetzt werden kann). Um eine Verknüpfung herzustellen, muss im XML-Dokument ein Link zum Stylesheet-Dokument angegeben werden. Die Notation erfolgt dabei als Verarbeitungshinweis mit dem Zusatz -stylesheet. Als Attribute werden dort href (Pfad zur Datei) und type (MIME-Typ des Stylesheets, für XSLT text/xsl oder auch application/xslt+xml) angegeben.

<?xml-stylesheet href="stylesheet.xsl" type="text/xsl" ?>

XSLT-Skripte werden in Dateien mit der Erweiterung .xsl oder .xslt gespeichert. Den Aufbau solcher Skripte beschreiben wir im Abschnitt Grundaufbau genauer.

Um mit Hilfe einer XML- und XSLT-Datei eine weitere Datei zu erzeugen, wird ein Programm (das sogenannte Transformationsprogramm bzw. meistens als XSLT-Prozessor bezeichnet) benötigt. Dieses Programm übersetzt die XML-Datei in eine andere Datei, wobei die XSLT-Datei als Vorlage für den Transformationsvorgang verwendet wird. Zu den bekanntesten XSLT-Prozessoren gehören unter anderem Saxon und Xalan. Des Weiteren enthalten die meisten gängigen Browser einen XSLT-Prozessor. Dieser ist jedoch im Regelfall auf die Transformation in HTML begrenzt.

Der XSLT-Prozessor Xalan wird von der Apache Software Foundation entwickelt und ist in zwei unterschiedlichen Varianten verfügbar: Xalan-C (für C++) und Xalan-J (für Java). Von beiden Varianten sind sowohl Quellcode als auch vorkompilierte Versionen verfügbar. Für die Beispiele in diesem Kapitel gibt es immer zwei Ansichten: eine XML- und eine HTML-Ansicht. Die XML-Ansicht zeigt, sofern Ihr Browser einen XSLT-Prozessor enthält, die vom Browser transformierte Ausgabe, andernfalls wird Ihnen der XML-Baum (Quellcode) angezeigt. Die HTML-Ansicht zeigt eine HTML-Datei. Diese Datei wurde mit dem XSLT-Prozessor Xalan-J erstellt. Xalan-J wird über die Kommandozeile aufgerufen. Dabei übergeben Sie i. d. R. folgende Parameter: -IN (eingehende XML-Datei), -XSL (XSL-Datei) und -OUT (ausgehende HTML-/XML-Datei). Der folgende Code zeigt, mit welchem Kommando die HTML-Datei des ersten Beispiels (Werte ausgeben) mittels Xalan-J erstellt wurde:

java -jar xalan.jar -IN werte-ausgeben.xml -XSL werte-ausgeben.xsl -OUT werte-ausgeben.html

Grundaufbau

Jede XSLT-Datei beginnt in der Regel mit einer XML-Deklaration. Diese ist jedoch, wie bei anderen XML-Dokumenten auch, optional. Das Wurzelelement bei XSLT ist stylesheet. Innerhalb dieses Elements wird nun das version-Attribut mit dem Wert 1.0 angegeben. Zwar gibt es schon eine Version 2.0, jedoch wird diese kaum verwendet. Dies liegt dabei vor allem an der mangelnden Unterstützung. Als weiteres Attribut im stylesheet-Element wird xmlns notiert, um einen Namensraum zu spezifizieren. Hier hat es sich eingebürgert, als Präfix xls zu verwenden. Als URI für den Namensraum von XSLT wird http://www.w3.org/1999/XSL/Transform verwendet. Die Elemente die für das resultierende Dokument verwendet werden, werden i. d. R. ohne Namensraum angegeben. Innerhalb des Wurzelelements werden ein oder mehrere Templates notiert. Diese stellen den Hauptbestandteil des Dokuments dar. Die Notation und Funktionsweise von Templates erklären wir jedoch später.

<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    
</xsl:stylesheet>

Werte ausgeben

Nun wollen wir uns aber auch mal dem ersten Beispiel widmen: Wie bereits oben erwähnt, besteht eine XSLT-Datei im Wesentlichen aus Templates, also Schablonen bzw. Vorlagen. Wie diese genau funktionieren bzw. wie man diese verwendet, möchten wir im nächsten Punkt genauer erklären. Als erstes wollen wir Ihnen jedoch zeigen, wie Sie einen Wert aus einer XML-Datei ausgeben. Um einen Wert im Ausgabebaum zu platzieren, benötigen wir das Element value-of. Ein wichtiges Attribut des value-of-Elements ist select. Mit dem select-Attribut wird der auszugebende Wert mit Hilfe eines XPath-Ausdrucks selektiert.

Im folgenden Beispiel werden die Elemente titel und text aus dem XML-Dokument als Inhalte der HTML-Elemente h1 (Überschrift der 1. Ebene) und p (Absatz) platziert und somit für den Benutzer dargestellt. Das in diesem Beispiel verwendete XSLT-Element template wird als Vorlage benötigt und ist erforderlich. Dessen Bedeutung erklären wir jedoch erst im nächsten Abschnitt.

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<?xml-stylesheet href="werte-ausgeben.xsl" type="text/xsl" ?>

<artikel>
    <titel>Grundlagen von XSLT</titel>
    <text>Hier lernen Sie die Grundlagen von XSLT ...</text>
</artikel>

XSLT-Code:

<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
        <html>
            <head>
                <title>Werte ausgeben - XSLT Code-Beispiel</title>
                
                <meta charset="utf-8" />
                
                <meta name="robots" content="noindex,nofollow" />
                <meta name="publisher" content="Homepage-Webhilfe" />
            </head>
            
            <body>
                <article>
                    <h1><xsl:value-of select="/artikel/titel" /></h1>
                    <p><xsl:value-of select="/artikel/text" /></p>
                </article>
            </body>
        </html>
    </xsl:template>
</xsl:stylesheet>

Übrigens: Es ist natürlich auch möglich, innerhalb des select-Attributs eine XPath-Funktion aufzurufen, um somit z. B. nur einen Teil einer Zeichenkette auszugeben.

Templates

In XSLT gibt es ein sogenanntes Template-System, d. h. es gibt Transformationsregeln, welche zu einem Regelsatz (dem Template oder auch als Schablone oder Vorlage bezeichnet) zusammengefasst werden. Von solchen Regelsätzen gibt es innerhalb eines XSLT-Dokuments im Normalfall mehrere. In dem Beispiel von oben (Werte ausgeben) gab es nur ein Template. Regelsätze können auf zwei verschiedene Arten genutzt werden: Anwendung und Aufruf. Bei einer Template-Anwendung wird ein Template immer dann angewendet, wenn ein bestimmter XPath-Ausdruck zutrifft. Bei Template-Aufrufen muss das gewünschte Template explizit aufgerufen werden.

Eine Schablone zeichnet sich durch das Element template aus. Im Element muss nun das Attribut match (für Template-Anwendungen) oder name (für Template-Aufrufe) angegeben werden. Als erstes wollen wir uns der Template-Anwendung widmen, d. h. wir benötigen das Attribut match. Im Attribut match wird ein Knotentest (im XPath-Syntax) angegeben, um somit das Template auf bestimmte Knoten oder einen bestimmten Pfad zu begrenzen. In der Regel besitzt jedes XSLT-Stylesheet über ein Template, welches sich auf Wurzelknoten bezieht (match="/"). Bei HTML-Dokumenten wird dort dann meist der Grundaufbau einer HTML-Seite notiert. Um nun innerhalb eines Templates weitere Templates anzuwenden, benötigen wir das leere Element apply-templates. Optional kann das Attribut select angegeben werden, um nur Templates, welche auf einen bestimmten Knotentest bzw. Pfad zutreffen, anzuwenden. Mit Hilfe dieser Template-Technik können Sie sich Schritt für Schritt durch das Dokument durcharbeiten, um somit die Transformation durchzuführen.

Im folgenden Beispiel verwenden wir die gleiche XML-Struktur wie beim vorherigen Beispiel, jedoch verfügt unser Stylesheet nun über 3 weitere Templates. Innerhalb des „Wurzel-Templates“ (match="/") haben wir den HTML-Grundaufbau notiert. Im body-Element wird nun über apply-templates ein weiteres Template angewendet. In diesem Fall handelt es sich um das Template, welches das Wurzelelement selektiert (match="artikel"). Innerhalb dieses Templates wird das HTML-Element article notiert. Des Weiteren wird hier erneut das apply-templates-Element verwendet, wodurch die beiden anderen Templates (match="titel" und match="text") angewendet werden (in der Reihenfolge, wie diese im XML-Dokument angegeben sind).

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<?xml-stylesheet href="templates-anwenden.xsl" type="text/xsl" ?>

<artikel>
    <titel>Grundlagen von XSLT</titel>
    <text>Hier lernen Sie die Grundlagen von XSLT ...</text>
</artikel>

XSLT-Code:

<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
        <html>
            <head>
                <title>Templates anwenden - XSLT Code-Beispiel</title>
                
                <meta charset="utf-8" />
                
                <meta name="robots" content="noindex,nofollow" />
                <meta name="publisher" content="Homepage-Webhilfe" />
            </head>
            
            <body>
                <xsl:apply-templates />
            </body>
        </html>
    </xsl:template>
    
    <xsl:template match="artikel">
        <article>
            <xsl:apply-templates />
        </article>
    </xsl:template>
    
    <xsl:template match="titel">
        <h1><xsl:value-of select="." /></h1>
    </xsl:template>
    
    <xsl:template match="text">
        <p><xsl:value-of select="." /></p>
    </xsl:template>
</xsl:stylesheet>

Wie bereits oben erwähnt, ist es auch möglich, ein Template zu definieren, um dies später einfach nur aufzurufen. Diese Möglichkeit wird jedoch normalerweise nicht für die „normale“ Abarbeitung eines XML-Dokuments verwendet, sondern lediglich, um bestimmte „Standard-Schablonen“ zu definieren, die innerhalb des Ergebnisbaums, unabhängig von der XML-Struktur und u. U. auch mehrmals, benötigt werden. Im Beispiel unten wird diese „Regel“ gebrochen, jedoch bleibt dadurch das Beispiel leicht nachvollziehbar. Ein Template, welches für den Aufruf gedacht ist, muss über das Attribut name verfügen. Hier können Sie einen beliebigen, jedoch eindeutigen Namen angeben. Mit dem Element call-template können Sie nun ein solches Template aufrufen. Hierfür muss im name-Attribut der Name des Templates angegeben werden.

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<?xml-stylesheet href="templates-aufrufen.xsl" type="text/xsl" ?>

<artikel>
    <titel>Grundlagen von XSLT</titel>
    <text>Hier lernen Sie die Grundlagen von XSLT ...</text>
</artikel>

XSLT-Code:

<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
        <html>
            <head>
                <title>Templates aufrufen - XSLT Code-Beispiel</title>
                
                <meta charset="utf-8" />
                
                <meta name="robots" content="noindex,nofollow" />
                <meta name="publisher" content="Homepage-Webhilfe" />
            </head>
            
            <body>
                <xsl:call-template name="Artikel" />
            </body>
        </html>
    </xsl:template>
    
    <xsl:template name="Artikel">
        <article>
            <h1><xsl:value-of select="/artikel/titel" /></h1>
            <p><xsl:value-of select="/artikel/text" /></p>
        </article>
    </xsl:template>
</xsl:stylesheet>

Übrigens: Alle 3 Beispiele (Werte ausgeben, Templates anwenden und Templates aufrufen) erzeugen die gleiche Ausgabe.

Variablen

In XSLT haben Sie die Möglichkeit, in einer Variablen einen Wert (z. B. einen Text) zu speichern. Verwendet werden Variablen im Allgemeinen immer dann, wenn ein Wert mehrmals benötigt wird (um somit den mehrmaligen Zugriff auf XML-Datei zu vermeiden). Eine Variable wird über das XSLT-Element variable definiert. Das Attribut name legt dabei einen eindeutigen Namen für die Variable fest. Wird die Variable innerhalb eines template-Elements notiert, so handelt es sich um eine lokale Variable und ist auch nur innerhalb der Schablone verfügbar. Variablen die außerhalb von template-Elementen notiert sind, gelten als globale Variablen und sind im kompletten Stylesheet verfügbar. Als Wert des Attributs select können Sie einen XPath-Ausdruck angeben, um somit der Variable einen Wert aus der XML-Datei zuzuweisen. Wird das Attribut select weggelassen, so müssen Sie das Element zweiteilig (und nicht wie sonst einteilig) angeben und zwischen den Tags den Wert der Variable notieren. Es kann sich dabei um eine Konstante (also einen „festen“ Wert) oder einen variablen Wert resultierend aus einer Bedingung (dazu später mehr) handeln. Um innerhalb eines select-Attributs (also dem Attribut, welches Sie kennengelernt haben, um Knoten zu selektieren) oder anderen dafür vorgesehenen Attributen auf die Variable zuzugreifen, notieren Sie das Dollar-Zeichen ($) gefolgt von dem definierten Variablennamen.

XML-Code:

<?xml version="1.0" encoding="UTF-8" standalone="yes" ?>
<?xml-stylesheet href="variablen.xsl" type="text/xsl" ?>

<text>
    Hier steht ein Text, welcher jedoch nur als Platzhalter fungiert.
</text>

XSLT-Code:

<?xml version="1.0" encoding="UTF-8" ?>

<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
    <xsl:template match="/">
        <html>
            <head>
                <title>Variablen - XSLT Code-Beispiel</title>
                
                <meta charset="utf-8" />
                
                <meta name="robots" content="noindex,nofollow" />
                <meta name="publisher" content="Homepage-Webhilfe" />
            </head>
            
            <body>
                <xsl:variable name="inhalt" select="/text" />
                <p><xsl:value-of select="$inhalt" /></p>
            </body>
        </html>
    </xsl:template>
</xsl:stylesheet>