Entwicklung einer Webanwendung auf Basis von Ruby on Rails

Tamino on Rails

Guido Laures

Ruby und das damit oft eingesetzte Web Application Framework Rails finden vor allem in der Open Source Community immer mehr Verbreitung. Das attraktive an Rails ist die besonders für einfach Anwendungen hohe Entwicklungsproduktivität durch reduzierten Codierungsaufwand. Die Lernkurve beim Einstieg in dieses Framework ist wesentlich flacher als bei den meisten anderen Web-Frameworks (z.B. Java Servlets).
Derzeit wird Rails als Frontend-Technologie für verschiedene relationale Datenbanken angeboten. Jedoch finden auch XML-basierte Datenbanken im Zuge der Verbreitung von Web Services immer mehr Anwendungsgebiete. Der Artikel zeigt anhand des XML-Servers Tamino der Software AG, wie Entwickler mit Ruby eine saubere Zugriffsschicht für Query-Operationen auf XML-Daten implementieren. Es wird eine Web Applikation auf Basis von Ruby on Rails entwickelt, die als Backend keine relationale sondern eine XML-Datenbank verwendet.

Zum Verständnis der Welt von Ruby on Rails ist es zunächst wichtig die Sprache Ruby von dem Web Framework Rails zu unterscheiden. Ruby ist eine 1995 von Yukihiro Matsumoto entwickelte Programmiersprache. Die für den Entwurf der Sprache grundlegenden Konzepte wurden zum Teil von anderen Sprachen wie Smalltalk, Python, Perl oder auch Lisp entliehen und zu einer neuen Sprache vereint. Hierbei wurde vor allem auf Einfachheit bei gleichzeitiger Beibehaltung von Eleganz Wert gelegt. Ruby ist eine vollständig objekt-orientierte Skriptsprache. Alles in Ruby ist ein Objekt – ohne Ausnahmen.

Interpreter für Ruby sind auf allen gängigen Plattformen als Open Source Implementierung verfügbar. Hierbei wurde auch auf im Unternehmensumfeld anwendungskritische Features wie OS-unabhängiges Multi-Threading und einem eingebauten Garbage Collector Wert gelegt. Eine Reihe von Werkzeugen rundet das Angebot um Ruby ab und lässt kaum Wünsche offen. Der Debugger ist bereits eingebaut und dank der Skripteigenschaften von Ruby sehr leicht verwendbar. Die interaktive Ruby Shell (irb) hilft beim interaktiven Ausprobieren von Skripten und ein Profiler sowie ein JavaDoc-ähnliches Dokumentationswerkzeug runden das Angebot ab.

Trotz der allseits anerkannten Eleganz der Sprache fristete Ruby lange Zeit ein Schattendasein und kam nur sehr sporadisch vor allem im System-Administrationsumfeld zum Einsatz. Dies änderte sich schlagartig mit der Verfügbarkeit von Rails vor einigen Jahren.

Rails ist ein aus einer Auftragsarbeit entstandenes Ruby-Framework zur Erstellung von web-basierten Anwendungen auf Basis von relationalen Datenbanken. Mittlerweile gibt es eine große Menge von Erweiterungen für das Framework, die dessen Einsatzgebiete Stück für Stück erweitern. Es ist ebenso wie die grundlegende Sprache Ruby als Open Source Implementierung verfügbar und funktioniert auf praktisch allen Plattformen, auf denen auch ein Ruby Interpreter verfügbar ist.

Der Erfolg von Rails und dessen stark wachsende Verbreitung verdankt das Framework seiner auf die praktische Anwendung ausgerichteten Konzepte. Der Einstieg in Rails ist wesentlich einfacher als bei anderen Frameworks. Ein Grund dafür ist der Wegfall von komplizierten Konfigurationen durch das Prinzip „Konvention geht vor Konfiguration“. Rails geht in sehr vielen Fällen, bei denen der Entwickler keine explizite Konfiguration angegeben hat, von klar definierten Annahmen aus. Sofern man diese kennt, kann man sie zum Einsparen von expliziten Konfigurationen und damit wertvoller Zeit für sich zu Nutze machen.

Von Haus aus kommt Rails mit einer Unterstützung für eine Reihe von relationalen Datenbanken. Zudem ist auch die Unterstützung für AJAX-basierte HTTP-Requests (XMLHttpRequest) Bestandteil des Frameworks, was die Integration von AJAX-Frameworks in Rails Applikationen erheblich erleichtert. Ein ebenfalls interessantes Prinzip ist die eingebaute Unterstützung für Unit-Tests, die durch Ihre einfache Anwendbarkeit dem Entwickler das Erstellen von Tests nicht nur erleichtert sondern es in geradezu freudvolle Arbeit verwandelt.

Was Rails bisher fehlte, war eine Unterstützung für XML-basierte Datensätze. Hier will der Rails-Adapter Tamino on Rails mit Hilfe einer XQuery-basierten ActiveResource-Implementierung Abhilfe schaffen. Tamino on Rails ist ein auf der liberalen Apache-Lizenz basierendes Projekt, das die Software AG an die Entwicklergemeinde verschenkt hat. Es ist derzeit nur für die Sofwtare AG-eigene Datenbank Tamino getestet, sollte aber auch für andere XQuery-fähige Datenquellen verwendbar sein. Im Folgenden wollen wir die grundsätzliche Verwendung von Tamino on Rails anhand einer rudimentären Anwendung zur Verwaltung von Adressen exemplarisch erläutern.

Abb. 1: Das in der Beispielanwendung verwendete Datenbank-Schema

Gehen wir davon aus, dass in der Tamino-Datenbank Adressdatensätze mit dem in Abbildung 1 dargestellten Schema gehalten werden. Ein Datensatz in dieser Datenbank hätte dann das in Listing 1 exemplarisch dargestellte Format.

Listing 1: Ein Beispieldatensatz----------
GuidoLaures
Uhlandstraße12Darmstadt

Die einzige Konfiguration, die wir für unsere Beispielanwendung vornehmen müssen, ist die Definition der Parameter, die für den Zugriff auf die Datenbank notwendig sind. Diese nimmt man in einer Ruby-Datei mit dem Namen config/environment.rb vor. Listing 2 zeigt die notwendige Konfiguration, die an dieser Stelle wohl nicht weiter erläutert werden muss.

Listing 2: Konfiguration der Tamino-Datenbank in config/environments.rb ----------
# Configure Connection to Tamino XML Server here
TAMINO = TaminoApi.new(
    "localhost",       
    "80",         
    "welcome_4_4_1",       
    "username",           
    "password"            
    )

Rails verfolgt in seiner Architektur einen klaren Model-View-Control Ansatz, der sich sogar bis in die vorgeschriebene Verzeichnisstruktur eines Rails-Projektes durchzieht. Wir werden nun die für die zu realisierende Anwendung notwendigen Artefakte dieser drei Bereiche erarbeiten.

Listing 3: Das Model der Beispielanwendung (model/person.rb) ----------
class Person 

Das Modell unserer Beispielanwendung ist mit vier Codezeilen beschrieben (Listing 3). Hier kommt uns die dynamische Typisierung der Sprache Ruby zu Gute. Im Gegensatz zu statisch getypten Sprachen kann ein Objekt in Ruby zur Laufzeit neue Eigenschaften bekommen. Somit ist es nicht notwendig, alle Eigenschaften eines Objektes schon zur Design-Zeit explizit zu machen. Allein mit den in Listing 3 dargestellten Code-Block können wir jetzt schon mit den Daten in unserer Datenbank arbeiten. Öffnet man mithilfe des Befehls ruby scripts/console eine Ruby Konsole, so kann man mithilfe des Befehls Person.find(:all) alle Elemente vom Typ <person> in einer Konsole ausgeben lassen. Doch damit nicht genug: Es ist auch möglich, XPath-Abfragen durchzuführen. So gibt beispielweise

Person.find(:first, :condition=>"name/firstName='Guido'")

den ersten gefunden Datensatz aus, der als Vornamen „Guido“ hat. Neben diesen Abfragen ist auch die Manipulation der Daten über die Kommandozeile möglich. Folgender Befehlsblock ändert den Namen „Guido“ des ersten gefundenen Datensatzes mit diesem Namen in „Johann“.

p = Person.find(:first, :condition=>"name/firstName='Guido'")
  p.name.firstName = 'Johann'
  p.save!

Bedenkt man, dass zur Erstellung der Konsolen-Anwendung nur vier Zeilen Code und eine simple Konfiguration notwendig waren, werden die Vorteile von Ruby offensichtlich. Um diese Anwendung Web-fähig zu machen, fehlen uns nun noch View und Controller. Der View wird wie in anderen Skriptsprachen, die im Webumfeld zum Einsatz kommen (z.B. PHP, JSP), durch dynamische Sprachelemente im HTML-Code definiert.

Listing 4 zeigt den HTML Code, der zur Darstellung einer Person benötigt wird. Ebenso wie in der Console-Anwendung nutzen wir hier die dynamischen Eigenschaften von Ruby aus und greifen auf die Skripting-Variable @person so zu, als hätte sie die Eigenschaften name und address deklariert.

Listing 4: Darstellung einer Person in einer Webseite (view/show.rhtml) ----------

Showing person:

Firstname:
Lastname:
Street name:
Street number:
City:

Der Controller unserer Anwendung kümmert sich darum, die in Tamino hinterlegten Daten zu dieser Person anzufordern und verfügbar zu machen. Dies ist durch die von Tamino on Rails bereitgestellten Funktionen sehr einfach.

Listing 5: Ausschnitt aus dem Controller der Beispielanwendung ----------
class PersonController 

Durch die in Listing 5 vorgenommene Deklaration ist es bereits möglich, mittels eines Browsers Datensätze anzeigen zu lassen. Hierzu starten wir den im Rails-Paket mitgeführten Web Server über den Befehl ruby script/server und öffnen einen Browser mit der Adresse http://localhost:3000/person/show/1. Dies öffnet den View aus Listing 4 (show) mit dem Tamino Objekt mit der ino:id=1. Im Browser erscheint die in Abbildung 2 gezeigte HTML-Seite.

Abb. 2: Anzeige eines Datensatzes anhand der ino:id

Auf diese Art und Weise kann eine gesamte Anwendung entwickelt werden, die neben der Anzeige von Daten auch deren Manipulation, Erstellung und Löschung vornehmen kann. Eine solche Anwendung ist im 1.0 Beta Release von Tamino on Rails enthalten.

Fazit

Die Erstellung einer Web-Anwendung auf Basis von Tamino-Daten wird durch die Verfügbarkeit des Rails Adapters Tamino on Rails erheblich vereinfacht. Zudem ist damit zu rechnen, dass im Rahmen des für die Weiterentwicklung des Frameworks verantwortlichen Open Source Projektes (siehe Web Ressourcen) Erweiterungen entwickelt und der Community bereitgestellt werden.

Geschrieben von
Guido Laures
Kommentare

Schreibe einen Kommentar

Deine E-Mail-Adresse wird nicht veröffentlicht.