Unproduktiv war gestern!

Einführung und Überblick in die Webentwicklung mit Ruby on Rails
Kommentare

„Sustainable productivity for web-application development“, zu Deutsch so viel wie „nachhaltige/tragfähige Produktivität bei der Entwicklung von Webanwendungen“ nennt David Heinemeier Hansson das Motto seines Frameworks Ruby on Rails. Vermutlich daher erfreut sich das Framework seit einigen Monaten bei PHP- und JEE-Entwicklern großer Beliebtheit. Wer sich einige Zeit mit Ruby on Rails beschäftigt hat, kommt so einfach nicht mehr los. Der folgende Artikel bietet einen Überblick und beschreibt die zugrunde liegenden Konzepte.

Ruby on Rails ist ein Framework für die Entwicklung von datenbankbasierten Webanwendungen in der Sprache Ruby. Rails basiert auf einer MVC-Architektur und bietet Unterstützung für den Versand von E-Mails, die Anbindung an Web Services, AJAX und mehr. Webanwendungen auf Basis von Rails kommen im Vergleich zu anderen mit wenig Code und ohne umfangreiche Konfiguration aus. Die einfache Testbarkeit der Anwendungen wurde von vornherein berücksichtigt, wodurch deren Wartbarkeit und Langlebigkeit gefördert wird. Den Großteil seiner Fähigkeiten verdankt Rails der Sprache Ruby (siehe Kasten „Ruby“), die auch unabhängig von Rails und der Webentwicklung einen tieferen Blick wert ist. (Eine Einführung findet sich hier.) Insgesamt befreit Rails den Entwickler von technischen Details und stärkt die Konzentration auf das Wesentliche, nämlich die Umsetzung der Geschäftslogik, und führt damit zu einer Steigerung der Produktivität.

Ruby Ruby ist eine objektorientierte, dynamisch typisierte Sprache, ähnlich Smalltalk. Ruby wurde bereits 1995 von Yukihiro Matsumoto entwickelt und liegt mittlerweile in der Version 1.8.2 vor. Alles in Ruby ist ein Objekt, es gibt keine primitiven Typen, wie z.B. in Java. Ruby bietet u.a. Garbage Collection, Exceptions, Reguläre Ausdrücke, Introspektion, die Erweiterung von Klassen zur Laufzeit, Code-Blöcke als Parameter für Iteratoren und Methoden. Neben Klassen ist die Definition von Modulen möglich, die globale (Hilfs-) Methoden definieren. Module können in Klassen eingebunden werden, wodurch die Methoden der Module zu Methoden der Klasse werden. Die Syntax ist befreit von unnötigem Ballast und wirkt dadurch einfach. Parameter von Methoden können, müssen aber nicht, in Klammern gesetzt werden. Anweisungen brauchen nicht mit einem Semikolen enden, sofern sie auf eine Zeile angegeben sind. Rückgabewerte in Methoden müssen nicht explizit angegeben werden, da automatisch das Ergebnis der letzten Anweisung zurückgeliefert wird. Das klingt chaotisch, stellt sich in der Praxis aber als unproblematisch und eher hilfreich heraus. Ruby ist einfach zu erlernen und ermöglicht eine effiziente Entwicklung von Programmen, die lesbar und leicht verständlich sind. Weitere Informationen finden sich auf der Ruby Homepage. Ein Tutorial findet sich hier.
Modelle

Ruby on Rails basiert auf einer MVC-Architektur und bietet für jede Komponente ein Sub-Framework. Genau genommen ist Rails selbst ein Meta-Framework, quasi die Klammer um eine Reihe von einzelnen Frameworks, die auch unabhängig voneinander genutzt werden können. Persistierbare Geschäftsobjekte werden in Rails als Modelle bezeichnet und mithilfe des Frameworks Active Record entwickelt. Dieses stellt die Verbindung zwischen Datenbank und Geschäftsobjekten her. Ein Modell wird durch eine Ruby-Klasse repräsentiert, die von der Framework-Klasse ActionRecord::Base erbt (Listing 1).

Listing 1
---------------------------------------------------
# RAILS_ROOT/app/models/book.rb
class Book  "Wirdemann, Baustert"

Die Modelle entsprechen dadurch dem Active-Record-Muster, d.h. ein Modell ist immer mit genau einer Datenbanktabelle verbunden und eine Instanz der Modellklasse somit mit genau einer Spalte in der Tabelle. Die Zuordnung zwischen Modell und Datenbanktabelle erfolgt dabei ohne Konfiguration über eine Konvention. Der Tabellenname (zum Beispiel books) ist immer der pluralisierte Name des Modells (z.B. Book). Dazu führt das Framework intern ein Dictionary, das auch um deutsche Namen erweitert werden kann. Ein erstes Beispiel für eines der grundlegenden Prinzipien von Rails, nämlich „Konvention über Konfiguration“. Über die Verbindung zur Tabelle hat das Framework Zugriff auf die Attribute und stellt hierfür automatisch Getter- und Setter-Methoden im Modell zur Verfügung (Listing 1). Ein Beispiel für ein weiteres Prinzip von Rails, nämlich DRY („Don’t repeat yourself“).

Assoziationen zwischen Modellen werden einfach und aussagekräftig durch Klassenmethoden, wie z.B. has_many oder belongs_to ausgedrückt. Das Listing 2 zeigt z.B. die Modelle Book und Chapter, die ein Buch und ein enthaltenes Kapitel repräsentieren. (In Ruby können Klammern weggelassen werden und für Strings werden häufig so genannte Symbole verwendet. Die Angabe von has_many in Listing 2 ist eine für Ruby typische Schreibweise für has_many(„chapters“)). Neben einem entsprechenden Fremdschlüssel in der Datenbanktabelle (z.B. book_id in chapters) reicht dies Rails, um die Verbindung von Modellen zu kennen und auch hier automatisch entsprechende Zugriffsmethoden für Instanzen zur Verfügung zu stellen (Listing 2).

Listing 2
---------------------------------------------------------
# RAILS_ROOT/app/models/book.rb
class Book 

Über Active Record stehen jedem Modell außerdem bereits eine Reihe von Methoden für den Zugriff auf die Attribute der Tabelle zur Verfügung. Listing 3 zeigt z.B. dem Einsatz der find-Methode.

Listing 3
------------------------------------------------------------
# Buch erzeugen und speichern
b = Book.new(:title => "Rapid Web Development")
b.save

# Buch laden
book  = Book.find(:first)
books = Book.find(:all, conditions => ["title like '%?%'", "Web"])
books = Book.find_by_sql("select title from . ")
.
Unsere Redaktion empfiehlt:

Relevante Beiträge

Meinungen zu diesem Beitrag

X
- Gib Deinen Standort ein -
- or -