Zwei Welten vereint - XML & Web Services Magazin - Technology | Integration

XML ist die perfekte Datenbeschreibungssprache. Hinzu kommt die plattformunabhängige Anwendung und die weite Verbreitung bzw. Akzeptanz. Was liegt also näher, als die Daten, die durch eine Datenbank verwaltet werden, durch XML zu beschreiben. Da es in den letzten Monaten viele interessante Entwicklungen im Bereich XML-Datenbanken gegeben hat, stellen sich hier im Prinzip auch keine großen Hürden in den Weg. Doch um XML-Dokumentstrukturen in einer Datenbank verwalten zu können, wird nicht jeder gleich den Austausch des Datenbanksystems in Erwägung ziehen. Die meisten großen RDBMS bieten zwar schon Ansätze einer XML-Unterstützung, meistens sind diese Lösungen aber noch nicht sehr ausgereift bzw. scheitern an der Kompatibilität.
Weshalb also nicht auf bereits bekannte und bewährte Mechanismen zur XML-Verarbeitung zurückgreifen und somit eine einheitliche Schnittstelle schaffen? DBDOM verfolgt genau diesen Weg und bietet eine DOM-Implementierung durch die Sprache SQL. DOM (Document Object Model) ist eine bekannte API zur XML-Verarbeitung. Informationen zu DOM finden Sie unter www.w3.org/DOM.
Die DOM-Spezifikation definiert hierbei Datenstrukturen und eine Reihe von Methoden, die zur Arbeit mit XML-Dokumenten genutzt werden. Sie werden sich nun sicherlich fragen, wie diese API durch die Abfragesprache SQL abgebildet werden kann. Eine Lösung hierzu bieten die Stored Procedures.
Aktuell werden von DBDOM nur zwei Datenbanksysteme unterstützt: Oracle und PostgreSQL. Für die Beispiele dieses Beitrages werden wir PostgreSQL einsetzen. Die Unterstützung von Oracle verfolgt aber den gleichen Ansatz und unterscheidet sich nicht grundlegend. Das bisher nur zwei Datenbanken unterstützt werden, lässt sich sicherlich auf den Alphastatus des Projektes zurückführen. Hier werden in Zukunft sicherlich noch weitere Unterstützungen folgen.

PostgreSQL
Die Installation eines PostgreSQL-Systems stellt sicherlich kein großes Problem dar und dürfte vielen Lesern bereits bekannt sein. Dennoch folgt zunächst eine kurze Anleitung. Die aktuelle Version von PostgreSQL beziehen Sie bitte von einem Mirror der Seite http://www.PostgreSQLql.org. Sie haben die Wahl zwischen binären RPM-Paketen und dem gepackten Sourcecode im *.tar.gz-Format.
Das Installieren der RPM-Versionen dürfte keine Probleme bereiten, entscheiden Sie sich hingegen für das Übersetzen der Quellen, ist die Installation auch in wenigen Schritten erledigt.
Wechseln Sie hiezu in das Verzeichnis, in dem der Sourcecode entpackt worden ist und starten Sie den Konfigurationsvorgang mit dem Befehl:

./configure

Wurden alle benötigten Komponenten gefunden, starten Sie anschließend den Übersetzungsvorgang mittels:

gmake

gmake install

Sie benötigen nun einen User, der Besitzer der Datenbank sein soll. Aus Sicherheitsgründen darf hier nicht der Superuser root verwendet werden. Beispielsweise kann stattdessen ein User postgres durch

adduser Postgres

angelegt werden.
Nun muss noch das Datenverzeichnis der Datenbank angelegt werden. Gewöhnlich wird das Verzeichnis bei einer Standardinstallation unter /usr/local/pgsql/data erstellt. Dieser Schritt muss zunächst als User root erfolgen:

mkdir /usr/local/pgsql/data

Anschließend können die Besitzrechte dieses Verzeichnisses auf den User der Datenbank geändert werden:

chown Postgres /usr/local/pgsql/data

su - Postgres

Sie sind nun als User postgres eingeloggt und können die Datenbank starten. Da PostgreSQL im Folgenden zum ersten Mal gestartet wird, muss das Datenverzeichnis zunächst durch den Befehl initdb initialisiert werden, bevor anschließend der Postmaster-Prozess gestartet werden kann.

/usr/local/pgsql/bin/initdb -D /usr/local/pgsql/data

/usr/local/pgsql/bin/postmaster -D /usr/local/pgsql/data &

Der Postmaster-Prozess (der im Hintergrund gestartet wird) bekommt ebenfalls durch den Parameter -D das aktuelle Datenverzeichnis übergeben. Nun sollte der Datenbankserver laufen und benutzbar sein. Wir überprüfen unsere hoffentlich erfolgreiche Installation durch das Anlegen einer neuen Datenbank:

/usr/local/pgsql/bin/createdb test

Wird keine Fehlermeldung ausgegeben, sollte es Ihnen anschließend möglich sein, mit dem Client pgsql auf die gerade erstellte Datenbank mit dem Namen test zugreifen zu können:

/usr/local/bin/pgsql test

Ist bis hierhin alles ohne Fehler verlaufen, darf ich Sie nun zu einem laufenden PostgreSQL-System beglückwünschen. Hiermit haben wir die Grundlage für die folgenden Beschreibungen geschaffen.

DBDOM
Kommen wir nun zum eigentlichen Thema dieses Artikels: DBDOM. Wie anfangs bereits beschrieben, erhalten Sie mit DBDOM eine vollständige Implementierung der DOM-API in der Sprache SQL. Hiermit wird praktisch jedes unterstützte RDBMS (bisher PostgreSQL und Oracle) zum XML-Applikationsserver. Natürlich stellt sich als erstes die Frage, warum XML unbedingt mit einer gewöhnlichen SQL-Datenbank verknüpft und verwendet werden soll. Die Speicherung von XML-Daten innerhalb Textdateien im ASCII-Format hat sich ja schon weit verbreitet. Problematisch wird die Verwendung von einfachen Dateien zur Speicherung von XML-Inhalten erst dann, wenn eine Vielzahl unterschiedlicher Benutzer gleichzeitig zugreifen wollen. Eine Datenbank ist auf dieses Szenario bereits vorbereitet und bringt hierzu verschiedene Unterstützungen mit. Somit vereint DBDOM die Vorteile einer relationalen Datenbank mit den Vorzügen der Sprache XML. Beide Techniken vereint, ergeben ein optimales Gespann für die Verarbeitung unterschiedlichster Datenmengen.
DBDOM implementiert die Funktionalität von DOM in einer sehr einfachen und effizienten Art. DBDOM gibt ein festgesetztes Datenbankschema vor, das eine Reihe von Tabellen und Stored Procedures enthält, die Datenstrukturen und Methoden der DOM-API wiederspiegeln. Die Stored Procedures sind durch eine bestehende Verbindung zur Datenbank direkt ansprechbar. Doch um die Programmierarbeit noch ein bisschen zu vereinfachen, bietet DBDOM noch einen Java-Adapter, der die JDBC-Funktionalität vollkommen kapselt. Der Adapter implementiert das Package <u>org.w3c.dom</u>, wodurch die gesamte Standard-DOM-API übernommen wird. Hiermit macht es für Sie, den Entwickler, kaum noch einen Unterschied, ob Sie mit der Standard-DOM-API arbeiten oder den Java-Adapter des DBDOM-Paketes einsetzen.
Das aktuelle DBDOM-Paket ist auf Sourceforge gehostet: http://dbdom.sourceforge.net. Nachdem nun der vorherige Abschnitt erläutert hat, wie Sie die PostgreSQL-Installation durchführen, nutzen wir diese Installation jetzt als Basis und fügen DBDOM hinzu.
Zunächst benötigen Sie das gepackte *.tar.gz-Archiv von der oben genannten Adresse. Entpacken Sie die Datei in ein Verzeichnis Ihrer Wahl. DBDOM finden Sie nun im Unterverzeichnis alpha, ein Hinweis darauf, dass das Projekt sich im Moment noch im Alphastatus befindet. Innerhalb des alpha-Verzeichnisses sollten Sie die folgenden Unterverzeichnisse finden: bindocs, html, java, news und sql. Wichtig sind hierbei dir Verzeichnisse java und sql. Unterhalb sql finden Sie je ein Unterverzeichnis für alle unterstützten Datenbanken. Wie bereits erwähnt, beschränkt sich die Unterstützung momentan auf Oracle und PostgreSQL. Innerhalb dieser Verzeichnisse befinden sich die jeweiligen Implementierungen der DOM-API durch SQL. Wenn Sie nun einen Blick in das PostgreSQL-Verzeichnis werfen, sehen Sie verschiedene Dateien mit der Endung *.pgsql. Diese Dateien implementieren die DOM-Funktionen bzw. Methoden in der Sprache PL/pgSQL.

PL/pgSQL
PostgreSQL bietet die Möglichkeit, Prozeduren und Funktionen in verschiedenen Sprachen zu erstellen. Die möglichen Sprachen gehören zu den Procedural Languages (PL). Für jede zu unterstützende PL muss ein entsprechender Handler existieren, da die Datenbank selbst keine Sprachunterstützung bietet. Um nun die *.pgsql-Skripte verwenden zu können, muss zunächst sichergestellt werden, dass unsere PostgreSQL-Datenbank den entsprechenden Sprachhandler installiert. Die Installation eines Sprachhandlers bezieht sich hierbei immer auf eine einzelne Datenbank. Das Shellskript createlang ermöglicht es auf einfache Weise, Sprachen, die bei der Standarddistribuation von PostgreSQLQL enthalten sind, zu installieren. Der Befehl:

createlang plpgsql template1

installiert den PL/pgSQL Support für die Datenbank template1. Da es sich bei template1 um die Standarddatenbank handelt, die von PostgreSQL automatisch angelegt wird, ist die Sprachunterstützung anschließend in allen untergeordneten Datenbanken verfügbar. Soll dieser Effekt vermieden werden, erstellen Sie eine eigene Datenbank und geben anstatt template1 den Namen Ihrer Datenbank bei der Sprachinstallation an.
Nach diesem kleinen Ausflug in die Welt der Procedural Languages kehren wir nun zu unserer eigentlichen Aufgabe zurück - die Installation von DBDOM in unserer PostgreSQL-Datenbank. Um nicht den gesamten Installationsvorgang in der Standarddatenbank template1 auszuführen, legen wir zunächst eine neue Datenbank in unserem Server an. Den Namen der Datenbank können Sie beliebig bestimmen - beispielsweise javamagazin. Starten Sie hierzu das Programm psql (bei laufendem Postmaster-Service). Sie werden nun direkt mit der Datenbank template1 verbunden. Erstellen Sie die Datenbank javamagazin durch das SQL-Kommando:

CREATE DATABASE javamagazin;

Vergessen Sie hierbei nicht, das Kommando durch ein Semikolon abzuschließen. Jetzt müssen Sie sich nur noch mit der neuen Datenbank verbinden:

/c javamagazin

Bevor Sie nun mit der Installation der PL/pgSQL-Skripte beginnen, müssen Sie die Sprachunterstützung für die Datenbank javamagazin vorbereiten, wie im vorherigen Abschnitt beschrieben:

createlang plpgsql javamagazin

Dieses Kommando wird natürlich direkt auf der Kommandozeile eingegeben und nicht im PostgreSQL-Client psql.
Für die anschließende Installation der Datei install-db.pgsql rufen Sie psql auf, nachdem Sie in das Verzeichnis <Pfad zu DBDOM>/alpha/sql/PostgreSQL gewechselt haben. Der Befehl

\i install-db.pgsql

führt nun alle Anweisungen der angegebenen Datei aus. Die restlichen PL/pgSQL-Skripte, die in dem Verzeichnis zu finden sind, brauchen nicht einzeln aufgerufen zu werden, da install-db.pgsql diese Schritte automatisiert.
Nachdem eine Reihe von Meldungen über hinzugefügte Tabellen und Stored Procedures ausgegeben wurden, dürfte Ihre Datenbank nun für den Einsatz von DBDOM zur Verfügung stehen. Um zu überprüfen, welche neuen Tabellen Ihrer Datenbank hinzugefügt worden sind, geben Sie am Eingabeprompt von psql \d ein. Folgende Tabellen sollten nun in Ihrer Datenbank enthalten sein:

t_arch
t_arch_type
t_attr
t_attr_name
t_characterdata
t_dbdomexception
t_document
t_documentfragment
t_documenttype
t_domexception
t_domimplementation
t_element
t_entity
t_node
t_nodetype
t_notation
t_processinginstruction
t_setting
t_tag

Hiermit sind alle wichtigen Datenstrukturen für die Repräsentation eines XML-Dokumentes gegeben. Abbildung 1 visualisiert die Zusammenhänge zwischen den wichtigsten Tabellen.

Abb. 1: Die Zusammenhänge zwischen den Tabellen

Neben den oben dargestellten Tabellen, sind der Datenbank noch eine Reihe von Stored Procedures hinzugefügt worden, die die DOM-Implementierung erst vervollständigen. Datenstrukturen alleine würden ohne passende Funktionen zur Bearbeitung keinen großen Nutzen bringen. Die Stored Procedures versuchen dabei, die DOM-API möglichst effizient nachzubilden, was im momentanen Alphastatus des DBDOM-Projektes jedoch noch keinen Anspruch auf Vollständigkeit hat. Tabelle 1 gibt Ihnen einen Überblick über die hinzugefügten Prozeduren.

Die Interfaces Text, Comment, CDATASection, DocumentType, Notation, Entity und EntityReference sind im aktuellen Projektstatus leider noch nicht implementiert. Diese Tatsache kann sich jedoch bereits im nächsten Release ändern. Wie Tabelle 1 zeigt, bietet DBDOM jedoch trotzdem eine breite Unterstützung der DOM-API. Die aufgeführten Methoden können nun direkt aus psql aufgerufen werden. Beispielsweise liefert die Eingabe von:

select getNofDocuments;

als Rückgabewert die Nummer der Dokumente. Um DBDOM komfortabel benutzen können, bietet sich ein anderer Weg an. Durch den im Projekt enthaltenen Java-Wrapper finden Sie ein Java-API vor, das die Funktionsaufrufe der Stored Procedures durch JDBC in einer DOM-ähnlichen Schnittstelle kapselt. Sie können die DBDOM-Unterstützung somit direkt aus Ihrem Java-Programm nutzen, ohne Kenntnisse der SQL- bzw. JDBC-Programmierung. In folgendem Abschnitt werden wir uns nun mit der Anwendung der Java-Schnittstelle näher beschäftigen.

DBDOM <->Java
Bevor wir nun zur praktischen Anwendung des Java-Wrappers kommen, müssen noch ein paar Anpassungen erledigt werden. Beginnen wir zunächst damit, einen Blick auf das java-Verzeichnis der DBDOM-Distribution zu werfen. Folgende Verzeichnisstruktur ist zu finden:

java/bin: In diesem Unterverzeichnis ist das jar-Archiv der kompilierten Java-Klassen des Java-Wrappers zu finden.
java/doc: Die Javadoc-Dokumentation der API.
java/src: Der Quellcode der Packages il.co.iter.dbdom.*, il.co.iter.dbdom.parsers.*, il.co.iter.dbdom.samples.*.

Zusätzlich zu den DBDOM-Klassen benötigt DBDOM noch einen externen XML-Parser, um die XML-Daten verarbeiten zu können. Zum Einsatz kommt hierbei der Open Source Parser Xerces, zu finden auf http://xml.apache.org. Neben einer C++-Implementierung des Parsers ist Xerces als Java-Programm in der aktuellen Version 1.4.* auf der Website zu finden. Die Version 2.0 enthält zahlreiche Verbesserungen, befindet sich aber noch im Beta-Stadium. Um eventuelle Probleme zu vermeiden, greifen Sie also am besten auf die stabile Version zurück. Wählen Sie die Datei Xerces-J-bin.1.4.3.tar.gz aus und entpacken Sie das Archiv in ein Verzeichnis Ihrer Wahl. Sie können natürlich auch auf Xerces-J-src.1.4.3.tar.gz und Xerces-J-tools1.4.3.tar.gz zurückgreifen und den Parser selbst übersetzen, worauf wir an dieser Stelle nicht näher eingehen wollen. Informationen finden Sie in den beiliegenden Readme-Dateien. Für welchen Weg Sie sich auch entscheiden, benötigt werden die beiden Dateien xerces.jar und xercesSample.jar, die sich in der CLASSPATH-Variable befinden müssen. xercesSample.jar wird deshalb benötigt, weil sich in diesem Archiv die Klassen des Packages ui befinden.
Da der Java-Wrapper alle Methodenaufrufe der SQL-Funktionen der Datenbank per JDBC kapselt, wird zusätzlich noch der JDBC Driver für PostgreSQL benötigt. Zu finden ist das Java-Archiv der JDBC-Treiberklassen unter <u>http://jdbc.Postgresql.org</u>. Natürlich muss auch diese Jar-Datei in Ihren CLASSPATH aufgenommen werden.
Um nun die Klassen des DBDOM Java-Wrappers verwenden zu können, fügen Sie als letzten Schritt noch die Jar-Datei dbdom-alpha-[Versionsnummer].jar aus Ihrem /DBDOM/alpha/java/bin/-Verzeichnis hinzu. Nun sollten alle vorbereiteten Schritte erledigt sein, um den Java-Wrapper zu verwenden. Um zunächst einen Überblick über die Funktionalität der Java-Klassen zu erhalten, sehen Sie sich als erstes die mitgelieferte Beispielapplikation an. Zu finden ist dieses kleine Swing-Programm in der Klasse Gui.java aus dem Package il.co.iter.dbdom.samples (enthalten in dbdom-alpha-[Versionsnummer].jar). Der Aufruf erwartet drei Parameter, optional kann ein weiterer Parameter zur Angabe des Passworts angehängt werden:

java il.co.dbdom.samples.Gui <Treiberklassen> <Connection-String> <username> [password]

Um auf eine Datenbank per JDBC zugreifen zu können benötigt die aufgerufene Klasse einige Informationen, dazu gehören

1. die Klasse des Datenbanktreibers,
2. der Connection-String zur Datenbank sowie
3. Benutzername und optional ein Passwort.

Wird kein Passwort übergeben, kommt ein leerer String als Passwort zum Einsatz. Für unsere Beispielkonfiguration gehen wir von einer PostgreSQL-Datenbank mit dem Namen javamagazin aus, die lokal ausgeführt wird.

java il.co.dbdom.samples.Gui "org.PostgreSQLql.Driver" "jdbc:PostgreSQL://localhost/javamagazin" "PostgreSQL" "geheim"

Bevor Sie die Beispielapplikation jedoch starten, müssen Sie sicherstellen, dass der Datenbankserver im Hintergrund läuft. Feststellen können Sie dies über den Befehlsaufruf:

ps aux|grep postmaster

Läuft kein Prozess mit diesem Namen, ist es zunächst erforderlich, Postmaster zu starten:

/usr/local/pgsql/bin/postmaster -i -D /usr/local/pgsql/data &

Beachten Sie hierbei, dass unbedingt die Option -i angegeben werden muss, damit das TCP/IP-Networking aktiviert wird. Andernfalls kann per JDBC nicht auf die Datenbank zugegriffen werden. Wenn alles geklappt hat, sollte nach dem Programmstart ein Fenster zum Vorschein kommen.
Das Programmfenster bleibt zunächst leer, aber unter dem Menüpunkt Documents sind bereits zwei Einträge enthalten. Dies bedeutet, dass bereits zwei XML-Dokumente in unserer Datenbankinstanz gespeichert sind. Hierbei handelt es sich um zwei Beispieldokumente, die bei der Installation von DBDOM automatisch angelegt werden. Generell werden unter dem Menü Documents alle in der Datenbank enthaltenen XML-Dokumente aufgelistet. Diese können dann direkt aus dem Menü zur Betrachtung ausgewählt werden. Die beiden Beispieldokumente tragen die Namen sampleDocument und anotherDocument. Durch die Auswahl eines zur Verfügung stehenden Dokumentes füllt sich der leere weiße Bereich des Hauptfensters durch die Baumstruktur der XML-Struktur.

Abb. 2: XML-Baumstruktur im Hauptfenster

Wie aus Abbildung 2 zu erkennen ist, besteht sampleDocument aus drei Elementen elem, anotherElem und elem3. Das erste Element besitzt hierbei eine Reihe von Attributen, die hinter ATTS aufgeführt werden. Elem3 ist ein Child-Element von anotherElem. Nachdem Sie nun einen konkreten Anwendungsfall des Java-Wrappers gesehen haben, stellt sich natürlich die Frage, wie diese Beispielanwendung realisiert ist. Hierzu beschäftigen wir uns im nächsten Abschnitt nun mit den Klassen des Wrappers.

Java-Wrapper
Um nicht direkt mit den Stored Procedures der Datenbank arbeiten zu müssen, stellt der DBDOM Java-Wrapper eine benutzerfreundliche Schnittstelle zwischen PL/pgSQL und Java her. Ein Anwendungsbeispiel haben Sie bereits im vorigen Abschnitt gesehen. Ziel der Entwicklung des Wrappers ist es, dem Programmierer eine Schnittstelle zur Verfügung zu stellen, die von der Anwendung her der DOM-API möglichst nahe kommt.
Um den Java-Wrapper in Ihrem Java-Programm verwenden zu können, müssen zunächst zwei Pakete aus dem DBDOM-Projekt importiert werden: il.co.iter.dbdom.* und il.co.iter.dbdom.parsers.*. Die wichtigsten Klassen sind unter il.co.iter.dbdom.* zu finden. Alle Funktionen, die innerhalb der Datenbank als Stored Procedures angelegt wurden, sollten hier Ihre Java-Entsprechung vorfinden. il.co.iter.dbdom.parsers.* enthält hingegen nur eine Klasse: DBDOMParser. Diese Klasse kapselt den Xerces Parser und bereitet ihn für die DBDOM-Nutzung vor. Fügen Sie also als ersten folgende zwei Import-Anweisungen Ihrem Programmcode hinzu:

import il.co.iter.dbdom.*;

import il.co.iter.dbdom.parsers.*;

Nun muss noch die in Xerces enthaltene DOM-Implementierung importiert werden:

import org.w3c.dom.*;

Da für die Verwendung des Java-Wrappers zwangsläufig eine Datenbank angesprochen werden muss, denken Sie zusätzlich noch daran, die JDBC-Klassen zu importieren:

import java.sql.*;

Bevor nun Zugriffe auf die Daten ausgeführt werden können, muss eine Verbindung bestehen. Wie Sie bereits wissen, sind hierzu einige Angaben nötig, wie Connection-String, Datenbank-Benutzer und Passwort. Diese Angaben können entweder in jedem Programm hart codiert, oder - besser - per Kommandozeilenparameter übergeben werden. Folgende Code-Ausschnitt baut eine Verbindung auf:

try

{

Class.forName("org.PostgreSQLql.Driver");

} catch (ClassNotFoundException e)

{

e.printStackTrace();

System.exit(1);

}

Connection con = null;<br></br>	try

{

con = DriverManager.getConnection("jdbc:PostgreSQLql://localhost/javamagazin", 									"PostgreSQL", "geheim");

}

catch (SQLException e)

{

e.printStackTrace();

System.exit(1);

}

Die verbindungsspezifischen Strings können natürlich auch durch die Werte argv[0]-argv[3] ersetzt werden, damit sie per Parameter übergeben werden können. Nun, nachdem die Verbindung besteht, kann die Klasse DBDOMImplementation initialisiert werden:

DBDOMImplementation dbdom = null;

try

{

dbdom = new DBDOMImplementation (con);

}

catch (Exception e)

{

e.printStackTrace();

System.exit();

}

anschließend können dann alle Dokumente der Datenbank ermittelt werden:

NamedNodeMap documents = dbdom.getDocuments();

for (int i=0; i < documents.getLength(); i++)

{

String document = ((DBDocument)document.item(i)).getDocumentName();

}

Man kann also sehen, dass DBDOMImplementation die zentrale Klasse ist, die in jedem Fall benutzt werden muss, um auf Dokumente zuzugreifen - lesend oder schreibend. Da wir an dieser Stelle aus Platzgründen keine komplette Beschreibung der API abdrucken können, verweise ich auf die umfangreiche Javadoc-Dokumentation des Paketes. Als kleiner Überblick, ist in Tabelle 2 eine Übersicht der Klassen des Packages il.co.iter.dbdom.* dargestellt.

Fazit
Leider konnte Ihnen dieser Beitrag nur eine kurze Einführung in die Verwendung und die Möglichkeiten von DBDOM geben. Ich hoffe aber trotzdem, dass dieses interessante Thema Ihr Interesse geweckt hat. DBDOM bietet einen völlig neuen Ansatz zur Kombination von XML mit RDBMSs. Besonders wichtig ist hierbei, dass auf einen festgelegten Standard wie DOM zurückgegriffen wird - wodurch sowohl die Anwendung als auch das Erlernen von DBDOM stark vereinfacht wird. Auch wenn sich das Projekt momentan noch im Alpha-Stadium befindet, lässt sich bereits erkennen welche Möglichkeiten hinter dieser Lösung verborgen sind. Bleibt nur zu wünschen, dass die Entwicklung schnell voranschreitet. Viel Spaß beim Testen.

	Der Entwickler \| dot.net magazin \| Eclipse Magazin \| Entwickler Magazin \| Java Magazin \| Linux Enterprise \| MSDN Magazin \| PHP Magazin \| VISUAL-X \| XML Magazin