Das Apache XML Projekt Cocoon und eXtensible Server Pages

Oberseminar
Dokumentenmanagement, Webdesign und
Entwicklungswerkzeuge
Das Apache XML Projekt
Cocoon und eXtensible Server Pages
Markus Minnameier
Lehrstuhl für Informatik II
Das Apache XML Projekt: Cocoon und XSP
2
Inhaltsverzeichnis
1
2
DAS APACHE XML PROJEKT................................................................................................................ 3
1.1
DIE ZIELE DES APACHE XML PROJEKTS ................................................................................................... 3
1.2
ENTWICKLUNG DES APACHE XML PROJEKTS ........................................................................................... 3
1.3
DIE EINZELNEN TEILPROJEKTE................................................................................................................... 4
COCOON ..................................................................................................................................................... 5
2.1
DAS COCOON WEB-MODELL ..................................................................................................................... 6
2.2
FUNKTIONSWEISE VON COCOON ................................................................................................................ 7
2.3
COCOON PROCESSING INSTRUCTIONS (PI) ................................................................................................. 9
2.4
BROWSER-ABHÄNGIGE FORMATIERUNG .................................................................................................... 9
COCOON CACHE SYSTEM .................................................................................................................................. 10
2.6
3
2.6.1
XML ............................................................................................................................................... 10
2.6.2
XSL ................................................................................................................................................ 11
EXTENSIBLE SERVER PAGES (XSP) ................................................................................................. 12
3.1
4
VERWENDETE TECHNOLOGIEN ................................................................................................................ 10
WICHTIGE XSP-TAGS .............................................................................................................................. 13
3.1.1
<xsp:page> ................................................................................................................................... 13
3.1.2
<xsp:structure> und <xsp:include> ............................................................................................. 13
3.1.3
<xsp:logic> und <xsp:content> ................................................................................................... 14
3.1.4
<xsp:expr> .................................................................................................................................... 14
3.2
XSP-BIBLIOTHEKEN ................................................................................................................................ 15
3.3
BEISPIEL FÜR TRENNUNG VON LOGIK UND INHALT ................................................................................. 15
AUSBLICK................................................................................................................................................. 17
ANHANG ............................................................................................................................................................. 18
NOTIZ.XML ........................................................................................................................................................ 18
NOTIZ-XSP.XSL .................................................................................................................................................. 18
NOTIZ.XSP .......................................................................................................................................................... 19
NOTIZ2HTML.XSL............................................................................................................................................... 20
BIBLIOGRAPHIE .............................................................................................................................................. 22
Das Apache XML Projekt: Cocoon und XSP
3
1 Das Apache XML Projekt
1.1 Die Ziele des Apache XML Projekts
Als im Februar 1999 das Apache XML Projekt ins Leben gerufen wurde, hatte man drei
Zielrichtungen im Auge [1]:
•
Die Erstellung von hochwertigen XML-Lösungen, die kommerziellen Produkten in nichts
nachstehen.
•
Die Ermöglichung von Feedback an standardisierenden Organisationen (wie z.B. IETF
und W3C) aus der Sicht von Entwicklern.
•
Eine Austauschplattform für alle Aktivitäten innerhalb des Apache Projekts, die mit
XML zu tun haben.
Diese Ziele entstanden aus der einfachen Überlegung den Apache Webserver XML-fähig zu
machen.
1.2 Entwicklung des Apache XML Projekts
Das Apache XML Projekt wurde im Februar 1999 ins Leben gerufen und entstand mit dem
Teilprojekt Cocoon, das im Rahmen des Java Apache Projekt entwickelt wurde. Mit der
Gründung eines eigenständigen Open Source Projektes trug man der stetig wachsenden
Nachfrage nach XML- und XSL-Tools Rechnung. Mittlerweile umfasst das Apache XML
Projekt acht Teilprojekte. Es wird von Edd Dumbill als Meilenstein in der XML und Open
Source Entwicklung betrachtet [3]. Denn verschiedene kommerzielle Firmen wie SUN und
IBM leisteten einen entscheidenden Beitrag bei der Entstehung, indem sie beispielsweise ihre
Source Codes für die XML Parser und XSLT Prozessoren zur Verfügung stellten.
Das Apache XML Projekt: Cocoon und XSP
4
1.3 Die einzelnen Teilprojekte
Mittlerweile ist das Projekt auf acht Teilprojekte angewachsen, die hier nur sehr knapp
umrissen werden:
•
Xerces
Ein XML Parser, der in Java und C++ zur Verfügung steht.
•
Xalan:
Ein XSLT Stylesheet Prozessor, der ebenfalls in Java und C++ existiert.
•
Cocoon
Ein auf XML basierendes Web Publishing Framework in Java.
•
FOP
John Taubers‘ FOP für XSL Formatting Objects (FO) in Java.
•
Xang
Dient zur schnellen Entwicklung von Dynamic Server Pages in JavaScript.
•
SOAP
Simple Object Access Protocol.
•
Batik
Ein auf Java basierendes Toolkit für Skalierbare Vektor Grafiken (SVG).
•
Crimson
Ein weiterer XML Parser.
Das Apache XML Projekt: Cocoon und XSP
5
2 Cocoon
„Cocoon ist ein Publishing Framework Servlet, daß mittels seines modularen Reaktorkonzepts ein XMLQuelldokument je nach anfragendem Client in ein beliebiges Zielformat transformiert“ [1].
In den folgenden Kapiteln wird hauptsächlich das Teilprojekt Cocoon näher betrachtet.
Cocoon, das zur Zeit in der Version 1.8 vorliegt. kann man sozusagen als Herzstück des
Apache XML Projekts betrachten.
Wichtige Merkmale von Cocoon sind die 100%-ige Realisierung in Java und der modulare
Aufbau. Cocoon ist somit auf vielen Plattformen einsetzbar, auf denen eine Servlet Engine
läuft, denn Cocoon ist eigentlich ein Servlet und somit Bestandteil eines Servers. Durch den
modularen Aufbau und der Verwendung von Standardschnittstellen lassen sich leicht einzelne
Komponenten austauschen. Voraussetzung ist nur, dass diese Komponenten wiederum zu
100% in Java erstellt sind. Auch weitergehende Anwendungen sind somit realisierbar.
Abbildung 1: Vereinfachtes Verarbeitungsmodell von Cocoon. [5]
Abbildung 1 zeigt ein vereinfachtes Verarbeitungsmodell von Cocoon. Das Servlet erstellt
anhand der Eingabeparameter beispielsweise eine HTML-Seite. Hierzu wird ein XMLDokument in mehreren Schritten aufbereitet. Mit Hilfe eines XML-Parsers wird das
Dokument in eine interne Baumstruktur, Document Object Model (DOM), überführt. Diese
wird wiederum von einem XSLT Prozessor weiterverarbeitet und eine Ausgabe (z.B. in
HTML) erstellt.
Das Apache XML Projekt: Cocoon und XSP
6
Als XML-Parser können der Apache Xerces (Standard) oder auch der Sun ProjectX eingesetzt
werden. Als XSLT-Prozessoren sind Apache Xalan (Standard) oder James Clarks XT
denkbar. James Taubers FOP kann zur PDF Erzeugung eingesetzt werden
2.1 Das Cocoon Web-Modell
Cocoon verarbeitet Dokumente unter Trennung seiner Komponenten Inhalt (Text und Grafik),
logischer Struktur (Gliederungen) und Darstellung (bspw. für Drucker oder Bildschirm).
Dieses Cocoon Web Modell ermöglicht sozusagen eine „echte“ Rollenverteilung, wie sie z.B.
auch in professionellen Redaktionssystem möglich ist.
Abbildung 2: Das Cocoon Web-Modell. [6]
Um eine echte Trennung von Logik und Inhalt zu erreichen, wurde im Rahmen von Cocoon
die Extensible Server Pages (XSP) entwickelt. Dies bedeutet einen klaren Vorteil z.B.
gegenüber HTML und JSP, wo eine Trennung der zwei Ebenen kaum möglich ist.
Durch das Cocoon-Modell wird also die Entwicklung von Web-Inhalten in drei verschiedene
Ebenen unterteilt:
•
XML Creation: Die XML-Datei wird vom Autor generiert. Er benötigt keinerlei
Kenntnisse über die Weiterverarbeitung des Dokumentes.
•
XML Processing: In dieser Ebene wird die XML Datei weiterverarbeitet. Mittels XSP
wird die Logik vom Inhalt getrennt.
•
XML Rendering: Das erzeugte Dokument wird mittels XSL Stylesheets aufbereitet und
entsprechend der Anforderung formatiert (z.B. HTML, PDF, XML, WML, XHTML).
Das Apache XML Projekt: Cocoon und XSP
7
2.2 Funktionsweise von Cocoon
Abbildung 3: Verschiedene Prozessoren, die auf DOM-Daten arbeiten. [5]
Cocoon bietet einen Rahmen, um in einer Verarbeitungskette verschiedene Prozessoren
einzusetzen, ähnlich einer ‚Pipe‘ in UNIX-Shells (s. Abbildung 3). Über sogenannte
Processing Instructions wird Cocoon mitgeteilt, welcher Prozessor im nächsten Schritt das
Dokument oder besser den DOM Baum bearbeiten soll. Sind alle Processing Instructions
abgearbeitet wird das Dokument an den Formatter weitergeschickt.
In Abbildung 4 wird die Struktur von Cocoon noch einmal präziser dargestellt.
Das Apache XML Projekt: Cocoon und XSP
8
Abbildung 4: Funktionsweise von Cocoon. [1]
•
Request
Der Request enthält alle für die Verarbeitung der Anfrage wichtigen Informationen
(welche URI, Typ des Browser, welcher Producer soll aktiviert werden).
•
Producer
ein Producer bearbeitet den eingegangenen Request und liefert als Ergebnis ein XMLDokument, dessen Inhalt abhängig vom entsprechenden Producer ist.
•
Reactor
Der Reactor bestimmt auf Basis von XML Processing Instructions, welcher Processor das
XML-Dokument weiterverarbeiten soll. Nachdem die Verarbeitung abgelaufen ist, ist es
die Aufgabe des Reactors, das überarbeitete Dokument an den vorgegebenen Formatter
weiterzuleiten.
•
Formatter
Ein Formatter formt das XML-Dokument in einen für Browser/Client verarbeitbaren
Datenstrom um (MIME Typ setzen, ausführbarer Code).
•
Response
Der Response fasst das erzeugte Dokumentes mit weiteren Eigenschaften wie Länge,
MIME Typ usw. zusammen und schließt den Verarbeitungsprozess ab.
•
Loader
Der Loader übergibt Dokumente mit zusätzlichen Processing Instructions an den
Producer und gliedert diese wieder in die Verarbeitungskette ein. Ansonsten werden diese
an die Response weitergeleitet.
•
Processor
•
XSLT-Prozessor: wendet XSLT-Transformationen auf das Eingabedokument an.
Das Apache XML Projekt: Cocoon und XSP
9
•
XSP-Prozessor: verarbeitet XSP-Seiten.
•
SQL-Prozessor: wickelt SQL-Datenbankabfragen mittels einfacher Tag-Sprache ab.
Das zurückgegebene Resultset ist ein XML-Dokument.
•
LDAP-Prozessor: ermöglicht den Zugriff auf LDAP-Verzeichnisse. Liefert ein
XML-Dokument zurück.
2.3 Cocoon Processing Instructions (PI)
Der Reactor benötigt PI für die Auswahl des richtigen Processors oder Formatters. Dabei
kennt Cocoon zwei Verarbeitungsdirektiven:
Zum einen für die Auswahl des Processor: <?cocoon-process type="xxx"?>
Andererseits für den Formatter:
<?cocoon-format
type="yyy"?>
<?xml version="1.0"?>
<?cocoon-process type="xslt"?>
<?xml-stylesheet href="hello.xsl" type="text/xsl"?>
<page>
<title>Hello World!</title>
<content>
<paragraph>Meine erste Cocoon Seite!</paragraph>
</content>
Beispiel 1: Cocoon Processing Instruction für den XSLT-Prozessor.
2.4 Browser-abhängige Formatierung
In den Stylesheet Anweisungen kann auch Pseudoattribut media definiert werden. Cocoon
erkennt beim Aufruf über die HTTP-Zeile User-Agent den Browsertyp.
Folgende
vordefinierte
Bezeichnungen
für
Browser/Client-Typen
beispielsweise schon voreingestellt:
explorer
beliebiger Microsoft Internet Explorer (MSIE)
opera
Opera Browser
lynx
Lynx Browser
java
jede beliebige Java Klasse, die mittels URL zugreift
sind
in
Cocoon
Das Apache XML Projekt: Cocoon und XSP
wap
Nokia WAP Toolkit
netscape
jede beliebige Netscape Version (Mozilla)
10
<?xml version="1.0"?>
<?cocoon-process type="xslt"?>
<?xml-stylesheet href="hello.xsl" type="text/xsl"?>
<?xml-stylesheet href="hello-lynx.xsl" type="text/xsl" media="lynx"?>
...
Beispiel 2: Bei Lynx Browser wird ‚hello-lynx.xsl‘ als XSL-Datei verwendet.
2.5 Cocoon Cache System
Die Performance und Speichernutzung sind bei der Verarbeitung kritische Momente. Sowohl
das Parsen und Verarbeiten wie auch das Transformieren und Formatieren von XMLDokumenten ist sehr ressourcenintensiv. Deswegen wurde sehr auf eine effektive
Cacheverwaltung bei der Entwicklung von Cocoon geachtet. Das Cachesystem kann
statischen und dynamischen Inhalt speichern und beinhaltet auch eine Persistent Object
Storage, d.h. ressourcenintensive Dokumente überleben die JVM.
2.6 Verwendete Technologien
In diesem Kapitel werden kurz zwei Basistechnologien für Cocoon angerissen: XML und
XSL. Die dritte grundlegende Technologie XSP wird im dritten Kapitel ausführlich
behandelt.
2.6.1
XML
Dies ist eine Syntax für hierarchische Dokumente und zum Strukturieren von Informationen
bzw. Dokumenten geeignet. Im Rahmen dieser Arbeit wird nicht auf näher auf XML
eingegangen.
Das Apache XML Projekt: Cocoon und XSP
11
<?xml version="1.0"?>
<?xml-stylesheet href="hello.xsl" type="text/xsl"?>
<page>
<title>Hello World!</title>
<content>
<paragraph>Meine erste Cocoon Seite!</paragraph>
</content>
</page>
Beispiel 3: Ein XML-Dokument.
2.6.2
XSL
XSL ist ein Sprache, also eine XML Document Type Definition (DTD), welche es ermöglicht
XML-Dokumente in ein beliebiges Zielformat zu transformieren. Es können aber genauso die
Elemente umstrukturiert oder verschiedene Sichten bzw. Layoutvarianten ermöglicht werden.
So unterscheidet man zwischen XSLT, eine Sprache um XML in XML, HTML, XHTML,
WAP usw. zu transformieren und XSL:FO (XSL:Formatting Objects), die 2D Layout von
Text beschreibt. Dabei kann es sich um Printmedien wie z.B. einen Drucker als auch um
Digitalmedien wie z.B. PDF’s handeln. XSL-Dateien werden über folgende Anweisung in die
XML-Datei eingebunden:
...
<?xml-stylesheet href="hello.xsl" type="text/xsl"?>
...
...
<xsl:template match="page">
<html>
<head>
<title><xsl:value-of select="title"/></title>
</head>
<body bgcolor="#ffffff">
<xsl:apply-templates/>
</body>
</html>
</xsl:template>
...
Beispiel 4: Auszug aus der Datei ‚hello.xsl‘.
Das Apache XML Projekt: Cocoon und XSP
12
3 eXtensible Server Pages (XSP)
„Eine XSP Seite ist ein Cocoon XML Dokument, das auf Tags basierende Anweisungen enthält,
die spezifizieren wie ein dynamischer Inhalt beim Aufrufzeitpunkt generiert werden soll.“ [1]
Die Idee von XSP ist nicht neu innerhalb von Seiten Programm-Code unterzubringen (s. PHP,
JSP). XSP wurde - wie schon häufiger erwähnt - im Rahmen von Cocoon entwickelt, um die
Trennung von Logik und Inhalt zu ermöglichen. XSP‘s sind XML-Dokumente und somit
wohlgeformte XML-Dokumente, aber nicht unbedingt gültige.
Als Beispiel für eine XSP-Datei dient ein kleines Programm, das anhand der Uhrzeit erkennt,
ob es beim Aufruf ‚Guten Morgen‘ oder ‚Guten Tag‘ ausgeben soll. Die wichtigsten XSPTags sind in den folgenden Beispielen blau markiert.
<?xml version="1.0"?>
<?cocoon-process type="xsp"?>
<?xml-stylesheet href="sample.xsl" type="text/xsl"?>
<xsp:page language="java" xmlns:xsp="http://www.apache.org/1999/XSP/Core">
<xsp:structure>
<xsp:include>java.text.SimpleDateFormat</xsp:include>
</xsp:structure>
...
<p>Guten
<xsp:logic>
String timeOfDay = (new SimpleDateFormat("aa“)).format(new Date());
if (timeOfDay.equals("AM")) {
<xsp:content>Morgen</xsp:content>
} else {
<xsp:content>Tag</xsp:content>
}
</xsp:logic>
</p>
...
</xsp:page>
Beispiel 5: XSP-Logik zum Auswerten der Tageszeit im Rahmen einer XML-Datei.
Das Apache XML Projekt: Cocoon und XSP
13
3.1 Wichtige XSP-Tags
3.1.1
<xsp:page>
Das Wurzelelement einer XSP-Instanz ist immer <xsp:page>. Mit dem Attribut language
wird die Programmiersprache festgelegt. Zur Zeit ist Java der Standard und die einzige
Möglichkeit, es soll aber in Zukunft jede Programmiersprache unterstützt werden.
Zusätzlich wird im Wurzelelement der eindeutige Namensraum definiert, es können aber auch
weitere Namensraumangaben ergänzt werden.
<?xml version="1.0"?>
<?cocoon-process type="xsp"?>
<?cocoon-process type="xslt"?>
<?xml-stylesheet href="sample.xsl" type="text/xsl"?>
<xsp:page language="java" xmlns:xsp="http://www.apache.org/1999/XSP/Core">
...
</xsp:page>
Beispiel 6: Wurzelelement <xsp:page>.
3.1.2
<xsp:structure> und <xsp:include>
<xsp:structure> nimmt Elemente vom Typ <xsp:include> auf, die dazu dienen in
einer sprachunabhängigen Weise, Sprachbibliotheken zu laden. Einige wichtige Java Pakete
werden automatisch geladen.
<xsp:page language="java" mlns:xsp="http://www.apache.org/1999/XSP/Core">
<xsp:structure>
<xsp:include>java.text.SimpleDateFormat</xsp:include>
</xsp:structure>
...
</xsp:page>
Beispiel 7: <xsp:structure> und <xsp:logic>
Das Apache XML Projekt: Cocoon und XSP
3.1.3
14
<xsp:logic> und <xsp:content>
Im Bereich von <xsp:logic> wird der eigentliche Programmiercode der XSP-Seite
eingefügt. Dieser Inhalt wird später in ausführbaren Code umgewandelt. PI‘s der obersten
Ebene bleiben bei der Verarbeitung durch den XSP-Prozessor erhalten. Beliebige JavaKonstrukte sind einfügbar, so sind auch SQL-Abfragen möglich.
Der Tag <xsp:content> bettet Inhalt in <xsp:logic> ein.
<xsp:page language="java" xmlns:xsp="http://www.apache.org/1999/XSP/Core">
...
<xsp:logic>
String
timeOfDay
=
(new
SimpleDateFormat("aa“)).format(new
Date());
if (timeOfDay.equals("AM")) {
<xsp:content>Morgen</xsp:content>
} else {
<xsp:content>Tag</xsp:content>
}
</xsp:logic>
...
</xsp:page>
Beispiel 8: <xsp:logic> und <xsp:content>.
3.1.4 <xsp:expr>
Über das <xsp:expr>-Tag kann der Entwickler Expressions, also Ausdrücke in das
Zieldokument einfügen. Der Wert des enthaltenen Ausdrucks wird berechnet und als TextKnoten in das resultierende Dokument eingefügt (bzw. in die DOM-Struktur).
<xsp:page language="java" xmlns:xsp="http://www.apache.org/1999/XSP/Core">
...
<xsp:logic>
int value = 3 + 4;
String text = "Ergebnis = “ + value;
</xsp:logic>
<xsp:expr>text</xsp:expr>
...
</xsp:page>
Beispiel 9: <xsp:expr>.
Das Apache XML Projekt: Cocoon und XSP
15
3.2 XSP-Bibliotheken
Mittels Tag-Bibliotheken lässt sich die Anwendungslogik vor dem Inhaltshersteller
verstecken. Für den Autor genügt es zu wissen, welche Tags es gibt und mit welchen
Attributen ihr Verhalten gesteuert wird.Tag-Bibliotheken können Java-Klassen oder auch
XSL-Stylesheets
sein.
Eingebunden
werden
die
Tag-Bibliotheken
über
Namensraumdeklaration im <xsp:page> -Element. Mittlerweile existieren eine Reihe von
Taglibs, die auch standardmäßig mitgeliefert werden. So gibt es beispielsweise eine SQL<?xml version="1.0"?>
<?cocoon-process type="xsp"?>
<?cocoon-process type="xslt"?>
<?xml-stylesheet href="sample.xsl" type="text/xsl"?>
<xsp:page language="java"
xmlns:xsp="http://www.apache.org/1999/XSP/Core"
xmlns:example="http://www.plenix.com/DTD/XSP/Example">
<page title="Time of Day">
<p>
To the best of my knowledge, it's now
<example:time-of-day format="yy/MM/dd hh:mm:ss aa"/>
</p>
..
</page>
</xsp:page>
Beispiel 10: Hier wird mittels der Namensraumangabe ‚example‘ eine XSP-Taglib eingebunden.
Taglib für Datenbankabfragen oder eine PF-Taglib zum einfacheren Formatieren von HTMLFormularen. Interessanter ist auf jeden Fall die Möglichkeit diese Taglibs auszubauen oder
einfach neue selbst zu definieren.
3.3 Beispiel für Trennung von Logik und Inhalt
Im folgenden soll anhand eines simplen Beispiels die Trennung von Logik und Inhalt
verdeutlicht werden. Die Quellcodes zu den einzelnen genannten Dateien sind im Anhang
aufgelistet. Es sollen Notizen verarbeitet werden, die aus einem Titel, einem Autor, einem
Datum sowie einem oder mehreren Absätzen bestehen. Innerhalb der Absätze können
Textstellen als wichtig markiert werden. Dynamisch soll bei der Anzeige des Dokumentes
Das Apache XML Projekt: Cocoon und XSP
16
(mittels XSLT nach HTML) die noch verbleibenden Tage bis zu dem angegebenen Datum
berechnet werden. Der Autor bindet mittels einer PI ein Stylesheet in das erstellte Dokument
‚notiz.xml‘ ein. Über diese PI wird der XSLT-Prozessor aufgerufen und das Stylesheet
‚notiz-xsp.xsl‘ generiert aus der Notiz eine XSP-Datei, mit der vorgeschriebenen Wurzel
<xsp:page>. Eingebettet in die Wurzel befindet sich die Programmierlogik. Normalerweise
taucht die XSP-Datei ‚notiz.xsp‘ nicht auf, außer sie wird explizit erzeugt. Zwei neu
eingefügte PI‘s teilen Cocoon mit, wie das Dokument weiter bearbeitet werden soll. Als
nächstes wird die Programmierlogik ausgewertet und mittels der XSL-Datei ‚notiz2html.xsl‘
zu einem HTML-Dokument formatiert.
In Abbildung 5 sind schematisch die einzelnen Verarbeitungsschritte nochmals aufgezeigt.
Abbildung 5: Schematische Übersicht über die einzelnen Verarbeitungsschritte.
Das Apache XML Projekt: Cocoon und XSP
17
4 Ausblick
Es konnte im Rahmen dieser Arbeit nur ein kleiner Ausschnitt der Leistungsfähigkeit von
Cocoon 1.8 vorgestellt werden. Cocoon besitzt viele Stärken, wie die leichte Portierbarkeit
durch eine Implementierung in Java, die Verwendung von W3C-Standards oder die Trennung
von Inhalt, Logik und Darstellung. Einzige Voraussetzung ist eine Servlet Engine der 2.
Generation, um es auf zahlreichen Servern zum Laufen zu bringen. Cocoon besitzt aber auch
Schwächen. Denn als mit der Entwicklung von Cocoon begonnen wurde, waren viele heutige
Standards noch in der Entwurfsphase und es war nicht abzusehen, in welche Richtung die
Entwicklung gehen wird. So ergeben sich viele Restriktionen in Cocoon 1.x, aber auch
Schwächen bei Speicherplatzbedarf und Laufzeit. Deshalb hat man mit einem zweiten
Entwicklungszweig (Cocoon 2) begonnen. Dabei sollen Fehler und Restriktionen eliminiert
und der Speicherbedarf verringert werden, als auch eine erhöhte Geschwindigkeit und
Modularität erzielt werden. Es müssen durch eine Umstellung von DOM-basierte auf Eventbasierte (SAX-Parser) Verarbeitung von XML-Dokumenten auch keine kompletten
Dokumente mehr weitergereicht werden.
Das wichtigste Ziel bleibt aber weiterhin die Vereinfachung und Technik des WebsiteManagements durch eine Verringerung der Anzahl an „contracts“ (siehe Abbildung 5). So
wird in Cocoon 2, das sich derzeit im Alphastadium (alpha 3) befindet, eine Sitemap
eingeführt. Der Ablauf von Verarbeitungsschritten muss also nicht mehr in die
Verarbeitungsschritte hineincodiert werden.
Abbildung 6: Cocoon versucht die Anzahl an ‚contracts‘ (schwarze Verbindungslinien) zu
verringern. [1]
Diese Neuerungen sind vielversprechend und Cocoon wird sicherlich in Zukunft immer mehr
eine Alternative zu JSP und HTML darstellen.
Das Apache XML Projekt: Cocoon und XSP
18
Anhang
notiz.xml
<?xml version="1.0" encoding="ISO-8859-1"?>
<?cocoon-process type="xslt"?>
<?xml-stylesheet href="notiz-xsp.xsl" type="text/xsl"?>
<notiz>
<titel>Termine</titel>
<autor>Weihnachtsmann</autor>
<datum>24.12.2001</datum>
<absatz>Nicht vergessen:
<wichtig>Geschenke austeilen</wichtig>
</absatz>
<absatz> ... </absatz>
</notiz>
notiz-xsp.xsl
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform"
xmlns:xsp="http://www.apache.org/1999/XSP/Core">
<!-- ================================================ -->
<!-- Default-Template: Kopieren der Elemente -->
<xsl:template match="*|@*|comment()|text()">
<xsl:copy>
<xsl:apply-templates select="*|@*|comment()|text()"/>
</xsl:copy>
</xsl:template>
<!-- ================================================ -->
<!-- Template fuer 'datum': Einfuegen von XSP-Logic -->
<xsl:template match="datum">
<datum>
<xsl:value-of select="text()"/>
</datum>
<restzeit>
<xsp:logic>
Date jetzt = new Date();
DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT,
Locale.GERMANY);
String terminS = "<xsl:value-of select="text()"/>";
Date termin = new Date();
termin = df.parse(terminS);
long tage = (termin.getTime() - jetzt.getTime())/1000/60/60/24;
</xsp:logic>
<xsp:expr>tage</xsp:expr>
<xsl:text> Tagen</xsl:text>
</restzeit>
</xsl:template>
Das Apache XML Projekt: Cocoon und XSP
<!-- ================================================ -->
<!-- Template fuer Root-Element 'notiz' -->
<xsl:template match="notiz">
<!-- Ausgeben der PIs fuer weitere Verarbeitung: Erst XSP, dann XSLT -->
<xsl:processing-instruction name="cocoon-process">type="xsp"
</xsl:processing-instruction>
<xsl:processing-instruction name="cocoon-process">type="xslt"
</xsl:processing-instruction>
<xsl:processing-instruction name="xml-stylesheet">
href="notiz2html.xsl" type="text/xsl"</xsl:processing-instruction>
<!-- Ausgeben des neuen Root-Elements 'xsp:page' -->
<xsp:page language="java" xmlns:xsp="http://www.apache.org/1999/XSP/Core">
<!-- Laden der benoetigten Java-Bibliotheken -->
<xsp:structure>
<xsp:include>java.util.Date</xsp:include>
<xsp:include>java.text.DateFormat</xsp:include>
</xsp:structure>
<!-- Element 'notiz', dass nach der XSP-Verarbeitung erzeugt wird-->
<notiz>
<xsl:apply-templates/>
</notiz>
</xsp:page>
</xsl:template>
</xsl:stylesheet>
notiz.xsp
<?xml version="1.0" encoding="ISO-8859-1"?>
<?cocoon-process type="xsp"?>
<?cocoon-process type="xslt">
<?xml-stylesheet href="notiz2html.xsl" type="text/xsl"?>
<xsp:page language="java" xlmns="http://www.apache.org/1999/XSP/Core">
<xsp:structure>
<xsp:include>java.util.Date</xsp:include>
<xsp:include>java.text.DateFormat</xsp:include>
</xsp:structure>
<notiz>
<titel>Termine</titel>
<autor>Weihnachtsmann</autor>
<datum>24.12.2001</datum>
<restzeit>
<xsp:logic>
Date jetzt = new Date();
DateFormat df = DateFormat.getDateInstance(DateFormat.SHORT,
Locale.GERMANY);
String terminS ="24.12.2001";
Date termin = new date();
termin = df.parse(terminS);
long tage = (termin.getTime() - jetzt.getTime()) / 1000 / 60 / 60 / 24;
</xsp:logic>
<xsp:expr>tage</xsp:expr>
Tagen
</restzeit>
<absatz>Nicht vergessen:
<wichtig>Geschenke austeilen</wichtig>
</absatz>
<absatz> ... </absatz>
</notiz>
</xsp:page>
19
Das Apache XML Projekt: Cocoon und XSP
notiz2html.xsl
<?xml version="1.0" encoding="ISO-8859-1"?>
<xsl:stylesheet
xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<!-- ================================== -->
<!-- Template fuer Root-Element 'notiz' -->
<xsl:template match="notiz">
<xsl:processing-instruction name="cocoon-format">
type="text/html"
</xsl:processing-instruction>
<html>
<head><title>Notiz</title></head>
<body>
<p align="center"><table>
<xsl:apply-templates/>
</table>
</p>
</body>
</html>
</xsl:template>
<!-- ================================== -->
<!-- Template fuer Elementtyp 'titel' -->
<xsl:template match="titel">
<tr>
<th colspan="2">
<xsl:apply-templates/>
</th>
</tr>
</xsl:template>
<!-- ================================== -->
<!-- Template fuer Elementtyp 'autor' -->
<xsl:template match="autor">
<tr>
<td align="right">von</td>
<td>
<xsl:apply-templates/>
</td>
</tr>
</xsl:template>
<!-- ================================== -->
<!-- Template fuer Elementtyp 'datum' -->
<xsl:template match="datum">
<tr>
<td align="right">für den</td>
<td>
<xsl:apply-templates/>
</td>
</tr>
</xsl:template>
<!-- ===================================== -->
<!-- Template fuer Elementtyp 'restzeit' -->
<xsl:template match="restzeit">
<tr>
<td align="right">in</td>
<td>
<xsl:apply-templates/>
</td>
20
Das Apache XML Projekt: Cocoon und XSP
</tr>
</xsl:template>
<!-- =================================== -->
<!-- Template fuer Elementtyp 'absatz' -->
<xsl:template match="absatz">
<tr>
<td align="right"></td>
<td>
<p><xsl:apply-templates/></p>
</td>
</tr>
</xsl:template>
<!-- ==================================== -->
<!-- Template fuer Elementtyp 'wichtig' -->
<xsl:template match="wichtig">
<b><xsl:apply-templates/></b>
</xsl:template>
</xsl:stylesheet>
21
Das Apache XML Projekt: Cocoon und XSP
22
Bibliographie
[1]
Apache XML Project: http://xml.apache.org/.
[2]
Behme, Henning; Mintert, Stefan: ‚XML in der Praxis.‘, Addison-Wesley, 2000².
[3]
Dumbill, Edd: ‚Apache XML Project Launches.‘,
http://www.xml.com/pub/a/1999/11/apache/index.html.
[4]
McLaughlin, Brett: ‚Java and XML.‘, O’Reilly, 2000.
[5]
Mintert, Stefan; Menge, Rainald: ‚XML verpuppt. Aufbereitung mit Cocoon und
Extensible Server Pages.‘, c’t 10/00, S. 222-227.
[6]
Reichel, Volker: ‚X auf dem Server. Cocoon eine Alternative zu Java Server Pages?‘,
Java Magazin 08/2000, S. 91-99.
[7]
Reichel, Volker: ‚Eingesponnen. Webpublishing mit Cocoon 1.8: XSP-Dokumente
und andere Komponenten.‘, Der Entwickler 1/2001, S. 91-97.