Groovy, Grails und eine Twitter-Anwendung

Grooviges Gezwitscher


Grails ist ein Open-Source-Framework zur Entwicklung moderner Webapplikationen auf Basis der ­dynamisch typisierten Programmiersprache Groovy und bewährten Technologien wie dem Spring Framework, Hibernate und SiteMesh. Eine Vielzahl von Plug-ins macht es zudem möglich, wieder­kehrende Problemstellungen mit bewährten Lösungen umzusetzen.

Basierend auf der dynamischen Programmiersprache Groovy lassen sich mit Grails Anwendungen entwickeln, die von einer extrem ausdrucksstarken und auch für Java-Entwickler nach kurzer Einarbeitungszeit beherrschbaren Sprache profitieren. Durch die nahtlose Integration von Groovy in das Java-Ökosystem kann man auf bestehende Klassen und Bibliotheken zurückgreifen. Das macht den Umstieg besonders dann interessant, wenn man Investitionen in die Java-Plattform nicht so einfach über Bord werfen kann oder möchte. In diesem Artikel zeigen wir anhand einer kleinen Applikation die Vorzüge von Groovy und Grails. Als Beispiel haben wir uns das Web-2.0-Phänomen Twitter zum Vorbild genommen und werden nun den Grundstein legen, um in unserer Anwendung ein wenig zu „zwitschern“.

Entwicklungsumgebung

Grundvoraussetzung für die Entwicklung mit Grails ist ein installiertes Java JDK 1.6 oder höher, das über die Variable JAVA_HOME bekannt gemacht wurde und den PATH um den eigenen bin-Ordner erweitert. Nach dem Herunterladen und Entpacken der aktuellen Grails-Distribution (derzeit 2.0.x) von der offiziellen Grails-Webseite www.grails.org muss die Umgebungsvariable GRAILS_HOME gesetzt und auch hier der PATH um den bin-Ordner erweitert werden. Im Anschluss kann auf einer Konsole mit dem Befehl grails –version die korrekte Installation überprüft werden. Als Entwicklungsumgebung stehen je nach eigener Präferenz diverse Werkzeuge zur Verfügung, die bei der Entwicklung einer Grails-Anwendung unterstützen. Die beiden wohl am weitesten verbreiteten Entwicklungsumgebungen für Grails sind die kostenlos verfügbare SpringSource Tool Suite und das kommerzielle IntelliJ IDEA in der Ultimate Edition.

Applikation erstellen

Grails bietet für die Erzeugung einer neuen Applikation und aller dafür erforderlichen Artefakte einen einfachen Konsolenbefehl an. Mit dem Kommando grails create-app gezwitscher erzeugen wir eine neue Applikation mit dem Namen „gezwitscher“ in dem Verzeichnis, in dem wir das Kommando aufgerufen haben. Inspiriert von Ruby on Rails, legt auch Grails viel Wert auf die Berücksichtigung der Paradigmen „Convention over Configuration“ und „Don’t repeat yourself“. So gibt Grails bereits in der Verzeichnisstruktur einen einheitlichen Rahmen vor, der es Entwicklern einfach macht, sich in andere Grails-Projekte einzuarbeiten.

metzler_1.tif_fmt1.jpgAbb. 1: Verzeichnisstruktur eines Projekts

Eine Grails-Applikation besteht aus so genannten Grails-Artefakten, die je nach Typ in einem eigens dafür vorgesehenen Pfad abgelegt werden. Grails unterscheidet hierbei zwischen

  • den Fach- oder Domänenklassen (grails-app/domain)

  • der Serviceschicht (grails-app/services)

  • der Controller-Schicht (grails-app/controller)

  • den Message Bundles (grails-app/i18n)

  • den Views (grails-app/views)

  • den Tag-Bibliotheken (grails-app/taglib)

  • den Utility-Klassen (grails-app/utils) und

  • den Konfigurationsdateien (grails-app/conf)

Sehr starkes Augenmerk legt Grails auch auf das automatisierte Testen der Anwendung, und so werden von Haus aus bereits Integrationstests (test/integration) und Unit Tests (test/unit) unterstützt. Auch funktionale Tests sind über Erweiterungen einfach zu automatisieren.

An dieser Stelle haben wir bereits eine lauffähige Grails-Anwendung vorliegen, die uns mit diversen Erleichterungen bei der weiteren Entwicklung unterstützt. So können beispielsweise Abhängigkeiten zu anderen Bibliotheken über Maven Repositories aufgelöst, das bereits vorkonfigurierte Logging angepasst, das Deployment der Anwendung in einem Apache Tomcat durchgeführt oder die Internationalisierung von Anwendungstexten über bereitgestellte Message Bundles vorgenommen werden. Der aktuelle Stand der Anwendung kann nun mit dem Kommando grails run-app im Browser betrachtet werden.

Domänenobjekte modellieren

Für unsere Applikation benötigen wir vorerst drei Domänenobjekte – die Klasse User, die Daten über einen Benutzer enthält, die Klasse Status, die eine Statusnachricht eines Benutzers darstellt, sowie die Klasse Follower, die die Beziehung zwischen verschiedenen Benutzern herstellt.

Zuerst legen wir die Klasse User an. Das erfolgt über die Konsole mittels des Kommandos grails create-domain-class User. In der von Grails erzeugten Klasse können nun die fachlichen Eigenschaften modelliert werden. Wenn die Sichtbarkeit nicht explizit angeg...

Neugierig geworden? Wir haben diese Angebote für dich:

Angebote für Gewinner-Teams

Wir bieten Lizenz-Lösungen für Teams jeder Größe: Finden Sie heraus, welche Lösung am besten zu Ihnen passt.

Das Library-Modell:
IP-Zugang

Das Company-Modell:
Domain-Zugang