Anwendungsbeispiele

Einige Beispiele zur täglichen Anwendung und aus vergangenen Tagen
  • Einen XSLT Prozessor hat jeder Browser eingebaut.
    Es gab mal eine Zeit, in der es sehr populär war, Webseiten vom Server als XML auszuliefern. XML erlaubt die semantische Auszeichung des Inhalts, und die strikte Trennung des Inhalts von Layout und Design. Wesentlich besser als dies mit HTML und CSS jemals möglich wäre.

    Ich denke, u.a. wegen dem exzessiven Einsatz von Javascript (auch inline), hat sich diese Idee nie vollständig durchgesetzt. Schliesslich wurde  XHTML spezifiziert und jetzt gibt es HTML5...

  • XML wird im Browser on-the-fly nach HTML konvertiert und als Webseite formatiert dargestellt.
    Alles was man dazu tun muss, ist es im XML ganz zu Anfang eine sog. Processing Instruction einzufügen, welche ein XSLT Stylesheet referenziert. Der Broswer führt dann automatisch eine XSLT Transformation aus, bevor die HTML Repräsentation dargestellt wird.

    Betrachten wir das folgende einfache XML Beispiel:


    <?xml version="1.0" encoding="UTF-8"?>
    <document>
        <title>Das ultimative Zwei-Kapitel Dokument</title>
        <chapter>
            <title>Kapitel 1</title>
            <intro>In Kapitel 1 wird kurz gesagt was Sache ist.</intro>
            <content>Um es kurz zu machen, wie der Hase läuft steht in Kapitel 2.</content>
        </chapter>
        <chapter>
            <title>Kapitel 2</title>
            <intro>Hier wird erklärt, wie der Hase läuft.</intro>
            <content>Im Prinzip ist es ganz einfach.</content>
        </chapter>
    </document>

    Ohne XSLT Stylesheet Zuweisung wird der Browser eine Datei mit diesem Inhalt als eingerücktes XML anzeigen - oder die Tags einfach ignorieren und den Textinhalt in einer Zeile darstellen.

    Fügt man eine Processing Instruction am Anfang ein, wird ein XSLT Stylesheet vom Browser herangezogen und vor der Darstellung im Browser wird die so deklarierte XML Transformation ausgeführt:

     

    <?xml version="1.0" encoding="UTF-8"?>
    <?xml-stylesheet type="text/xsl" href="formatiermich.xsl" ?>
    <document>
       
    <title>Das ultimative Zwei-Kapitel Dokument</title>
       
    <chapter>

     

    [...]

    Jetzt kann man das XML einfach im Browser öffnen und alles wird schön formatiert - je nachdem welche Regeln in formatiermich.xsl gesetzt sind - angezeigt:


    <?xml version="1.0" encoding="iso-8859-1"?>
    <xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
       
        <xsl:template match="/">
            <html>
                <xsl:apply-templates/>
            </html>
        </xsl:template>
       
        <xsl:template match="document">
            <body>
                <xsl:apply-templates/>
            </body>
        </xsl:template>
       
        <xsl:template match="document/title">
            <h1>
                <xsl:apply-templates/>
            </h1>
        </xsl:template>
       
        <xsl:template match="chapter">
            <div class="chapter">
                <xsl:apply-templates/>
            </div>
        </xsl:template>
       
        <xsl:template match="chapter/title">
            <h2>
                <xsl:apply-templates/>
            </h2>
        </xsl:template>
       
        <xsl:template match="chapter/intro">
            <div class="intro">
                <i>
                    <xsl:apply-templates/>
                </i>
            </div>
        </xsl:template>
       
        <xsl:template match="chapter/content">
            <p>
                <xsl:apply-templates/>
            </p>
        </xsl:template>    
    </xsl:stylesheet>

    Die Processing Instruction hat keinen Einfluss auf den XML Inhalt und wird in einer anderen Eingabeverarbeitung nicht herangezogen.
  • Auch eine serverseitige Konvertierung ist gebräuchlich. Ein Beispiel aus vergangenen Tagen:
    WAP-Seiten für unterschiedliche Handy-Modelle.
    Damals hatten die Handys sehr unterschiedliche Displaygrößen. Handybrowser konnten noch nicht ausreichend Javascript und die Skalierung der WAP-Seite für das jeweilige Handy passierte nicht im Handy, sondern vor der Auslieferung auf der Serverseite. Dazu wurde eine XML Quelle mittels verschiedener XSLT Stylesheets in unterschiedliche WML WAP Repräsentationen transformiert.

    So würde das Zwei-Kapitel Beispiel von oben im WML Format aussehen (recht einfach gehalten):

     

    <?xml version="1.0" encoding="UTF-8"?>
    <!DOCTYPE wml PUBLIC "-//WAPFORUM//DTD WML 1.1//EN" "http://www.wapforum.org/DTD/wml_1.1.xml">
    <wml>
        <head>    
            <meta name="title" content="Das ultimative Zwei-Kapitel Dokument"/>
        </head>
        <card id="chapter1" title="Kapitel 1">
            <p><i>In Kapitel 1 wird kurz gesagt was Sache ist.</i></p>
            <p>Um es kurz zu machen, wie der Hase läuft steht in Kapitel 2.</p>
        </card>
        <card id="chapter2" title="Kapitel 2">
            <p><i>Hier wird erklärt, wie der Hase läuft.</i></p>
            <p>Im Prinzip ist es ganz einfach.</p>
        </card>
    </wml>

    Eine XSLT Transformation, die die XML Daten von oben in diese WML Darstellung überführt, könnte z.B. so implementiert werden:

    <?xml version="1.0" encoding="UTF-8"?>
    <xsl:stylesheet xmlns:xsl="http://www.w3.org/1999/XSL/Transform" version="1.0">
       
        <xsl:output
            doctype-public="-//WAPFORUM//DTD WML 1.2//EN"
            doctype-system="http://www.wapforum.org/DTD/wml12.dtd"
            indent="yes"/>
       
        <xsl:template match="document">
            <wml>
                <xsl:apply-templates/>
            </wml>
        </xsl:template>
       
        <xsl:template match="document/title">
            <head>
                <meta name="title">
                    <xsl:attribute name="content">
                        <xsl:value-of select="."/>
                    </xsl:attribute>
                </meta>
            </head>
        </xsl:template>
       
        <xsl:template match="chapter">
            <card id="{concat('chapter',count(preceding-sibling::chapter)+1)}">
                <xsl:attribute name="title">
                    <xsl:value-of select="title"/>
                </xsl:attribute>
                <xsl:apply-templates select="*[not(self::title)]"/>
            </card>
        </xsl:template>
       
        <xsl:template match="node()|@*">
            <xsl:copy>
                <xsl:apply-templates select="node()|@*"/>
            </xsl:copy>
        </xsl:template>
       
        <xsl:template match="processing-instruction()"/>
       
        <xsl:template match="intro">
            <p>
                <i>
                    <xsl:apply-templates/>
                </i>
            </p>
        </xsl:template>

        <xsl:template match="content">
            <p>
                <xsl:apply-templates/>
            </p>
        </xsl:template>    
    </xsl:stylesheet>

    Weiterführender Link: www.data2type.de/[...]

  • Aus einer XML Quelle können auch leicht weitere Format erzeugt werden, bspw. ePub.
    EPub ist das Standardformat für eBooks und neben Tags zur Formatierung für den Content, gibt es bspw. auch Anweisungen zum Erzeugen des Inhaltsverzeichnisses oder anderer Navigationsstrukturen.

    Weitere gängige Formate sind neben dem oben gezeigten veralteten WML Format, elektronische Ausgabe-Formate wie: CHM, EclipseHelp, JavaHelp, ePub, ..., Print-Ausgabe Formate, wie PDF oder Adobe Framemaker,  oder XML Standard Austauschformate, wie DITA, S1000D, PI-MOD oder TEI.


  • Kryptische XML Log-, Daten- oder Konfigurationsfiles können leicht mit XSLT menschenlesbar formatiert werden
    Ein Arbeitskollege im neuen Job kam kürzlich auf mich zu, ob ich um eine Möglichkeit wüsste, wie man sein kryptisches Datenfile für einen Übersetzungsdienst menschenlesbar formatieren könnte - XSLT to the Rescue:

    <?xml version="1.0" encoding="UTF-8"?>
    <?xml-stylesheet type="text/xsl" href="de.xsl"?>
    <jcr:root xmlns:sling="http://sling.apache.org/jcr/sling/1.0"
              xmlns:jcr="http://www.jcp.org/jcr/1.0"
              xmlns:mix="http://www.jcp.org/jcr/mix/1.0"
              xmlns:nt="http://www.jcp.org/jcr/nt/1.0"
        jcr:language="de"
        jcr:mixinTypes="[mix:language]"
        jcr:primaryType="sling:Folder">
        <b_manual
            jcr:primaryType="sling:MessageEntry"
            sling:message="Bedienungsanleitung"/>
        <b_warning
            jcr:primaryType="sling:MessageEntry"
            sling:message="Warnung"/>
        <b_danger
            jcr:primaryType="sling:MessageEntry"
            sling:message="Vorsicht"/>
        <b_note
            jcr:primaryType="sling:MessageEntry"
            sling:message="Notiz"/>
        <b_notice
            jcr:primaryType="sling:MessageEntry"
            sling:message="Hinweis"/>
    [...]


    Mit einem eingehängten XSLT Stylesheet de.xsl wird so ein XML Datenfile schön formatiert als Tabelle angezeigt:


    <?xml version="1.0" encoding="iso-8859-1"?>
    <xsl:stylesheet version="1.0"
        xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
        xmlns:jcr="http://www.jcp.org/jcr/1.0"
        xmlns:sling="http://sling.apache.org/jcr/sling/1.0">
        
        <xsl:template match="jcr:root">
            <html>
                <table border="1" cellpadding="5" cellspacing="5">
                    <xsl:apply-templates/>
                </table>
            </html>
        </xsl:template>
        
        <xsl:template match="*">
            <tr>
                <td>
                    <xsl:value-of select="concat(count(preceding::*[@sling:message]) + 1,'.')"/>
                </td>
                <td>
                    <xsl:value-of select="name()"/>
                </td>
                <td contenteditable="true">
                    <xsl:value-of select="@sling:message"/>
                </td>
            </tr>
        </xsl:template>

    </xsl:stylesheet>


    Hängt man an dieses Beispiel noch ein bisschen Javascript Logik und macht die Felder für die Übersetzungen mittels des HTML5 contenteditable Attributs editierbar, dann bräuchte man nur noch eine Rücktransformation HTML nach XML und hätte schon einen kleinen webbasierten XML Editor gebaut. Genau nach diesem Prinzip funktionieren einige aktuelle XML Editoren.

  • SVG Images z.B. Balkendiagramme aus XML Daten erzeugen
    Nachdem eine SVG Grafik im XML Format vorliegt kann diese auch direkt aus XML Daten mittels XSLT erzeugt werden.
    Über das HTML5 <svg> Element kann so eine erzeugte Grafik inline in das ebenfalls durch das XSLT generierte HTML Dokument eingebunden werden.


    Betrachten wir unser Beispiel von oben, erweitert um drei neue <block> Elemente:

    <?xml version="1.0" encoding="UTF-8"?>
    <?xml-stylesheet type="text/xsl" href="chart.xsl" ?>
    <document>
        <title>Das ultimative Zwei-Kapitel Dokument</title>
        <chapter>
            <title>Kapitel 1</title>
            <intro>In Kapitel 1 wird kurz gesagt was Sache ist.</intro>
            <content>Um es kurz zu machen, wie der Hase läuft steht in Kapitel 2.</content>
        </chapter>
        <chapter>
            <title>Kapitel 2</title>
            <intro>Hier wird erklärt, wie der Hase läuft.</intro>
            <content>Im Prinzip ist es ganz einfach. Betrachten wir doch drei gelbe Blöcke:</content>
            <block/>
            <block/>
            <block/>
        </chapter>
    </document>

    Wenn wir das XSLT Stylesheet von oben noch um eine Regel für das neue <block> Element ergänzen, so wie hier:

        <xsl:template match="block">
           
    <svg style="background-color:yellow" width="30" height="30"
            xmlns:xlink="http://www.w3.org/1999/xlink"
            xmlns="http://www.w3.org/2000/svg"/>
           
    <br/><br/>
       
    </xsl:template>

    Dann erhalten wir drei schön formatierte gelbe SVG Blöcke:



    Weiterführender Link

Nachtrag: Knotentyp Visualisierung im Apache Jackrabbit Projekt