Child pages
  • Java-Entwicklung mit Groovy und Grails
Skip to end of metadata
Go to start of metadata

Grundlegende Informationen

Grails ist ein Framework zur Erstellung von Webanwendungen. Es ist an Ruby on Rails angelehnt, setzt allerdings auf der Programmiersprache Groovy auf und läuft deshalb unter der Java Virtual Machine. Es bietet Konzepte wie Scaffolding, automatische Validatoren und einfache Internationalisierung. Grails baut auf mehreren etablierten Frameworks wie Spring, Hibernate und SiteMesh auf und verbindet diese mit der Skriptsprache Groovy.

  • Hohe Produktivität durch "Convention over configuration"
  • Weniger Komplexität durch Standalone-Framework: Für Neulinge ein toller Start ohne Java-Kenntnisse zu erfordern. Leicht zu lernen.
  • Nach dem Vorbild von Ruby on Rails entwickelt: "Don't repeat yourself."
  • Der für Java typische "boilerplate code" wird dem User erspart. Viel wird dynamisch zur Verfügung gestellt (setter, finder, ...).
  • Verwendung der etablierten Java-Technologien Hibernate und Spring, aber viel einfacher und konsistente Oberfläche.
  • Sehr guter AJAX-support
  • Richtige Balance zwischen Konsistenz (Einfachheit) und mächtigen Funktionen

Mehr allgemeine Informationen finden sich im deutschen und englischen Artikel auf Wikipedia.

Zielgruppen von Grails

  • Java-Entwickler auf der Suche nach einer integrierten Entwicklungsumgebung für webbasierte Anwendungen.
  • Entwickler ohne Java-Erfahrungen, die nach einer einfachen, schnellen und professionellen Möglichkeit für Web-Applikationen suchen.

Präsentation

Diese Präsentation als PDF-Dokument herunterladen (grails-praesentation.pdf)

Bewertung der Programmiersprache

Vorteile 

  • Das Entwicklungsframework Grails ist stark an Ruby on Rails angelehnt und ermöglicht agile Software-Entwicklung und Rapid Prototyping.
  • Grails ermöglicht schnelle Entwicklungszeiten und schlanken Programmcode.
  • Ein bedeutender Vorteil von Grails ist die Wahlmöglichkeit zwischen der dynamisch typisierten Skriptsprache Groovy auf der einen und der statisch typisierten Hochsprache Java auf der anderen Seite.
  • Diese Wahlmöglichkeit wird dadurch ergänzt, dass man sich nicht für die eine oder die andere Seite entscheiden muss, sondern auf Klassen-/Modulebene entscheiden kann, ob man in Java oder Groovy programmiert. So können zum Beispiel moderne Frameworks wie Spring, Hibernate, JSF (JavaServer Faces), GWT und Grails in einem Projekt gemeinsam zum Einsatz kommen und die gleiche Geschäftslogik verwenden.
  • Grails bietet einen guten Support und viele Vorbereitungen für die Internationalisierung Ihrer Web-Applikation. Für den mehrsprachigen Betrieb sind damit vorab schon viele Vorkehrungen getroffen.
  • Es gibt eine ausgereifte und bequeme Template-Engine (GSP, GroovyServer Pages).
  • Über die sogenannte Scaffolding-Komponente in Grails können vorgefertigte Masken, Listen und Tabellen verwendet werden, mit der Möglichkeit, diese im Nachhinein noch anzupassen.
  • Alle Entwicklungsbibliotheken der Java-Welt sind in Grails integrierbar.
  • Die Integration von Groovy und Grails in Entwickler-Werkzeuge ist mittlerweile einigermaßen brauchbar, so dass man auf in Java gewohnte Entwicklungs-Unterstützungen, wie Fehleranzeige, Code-Completition und Refactoring ebenfalls zurückgreifen kann.
  • Das Wechseln von Ausgabeformaten (HTML, XML, JSON) für bestimmte Seiten ist sehr einfach lösbar.
  • Seit Version 1.2 können abhängige Java-Bibliotheken bequem per Maven und Ivy über eine eigene Groovy-Konfigurationsdatei in die Anwendung integriert werden.

Nachteile und Einschränkungen

  • Das Dynamic Scaffolding in Grails reicht meist nur für einfachste Listen aus und muss meist angepasst werden, was natürlich einen Mehraufwand bedeutet.
  • Als Java-Programmierer fällt die typenlose Programmierung in Groovy oft schwer. Statt "def Variable" wird dann doch oft statisch typisiert: "String Variable".
  • Gerade, wenn man von einer anderen Programmiersprache auf Java umsteigt, reicht es nicht aus, Groovy und Grails kennen zu lernen. Viele Dinge kann und sollte man aus der klassischen Java-Welt integrieren. Daher muss man auch die komplette Java-Welt ansehen, um hochwertige und effiziente Lösungen zu erschaffen.
  • Grails ist eine Mischung, die aus vielen Java-Bibliotheken zusammen gebaut wurde. Die Dokumentation ist noch nicht so umfangreich, so dass man häufig auch in den Dokumentationen der anderen Frameworks nachlesen muss. Die Gesamtzusammenhänge von Beginn an zu verstehen ist daher häufig nicht ganz einfach.
  • Oft ist es nicht einfach, die komplette "Grails-Magie" zu überblicken: Welches Verhalten wird zur Laufzeit erst bereitgestellt? Die Entwicklertools unterstützen dabei aktuell noch recht wenig.
  • "Coding by convention" bedingt, dass man alle Konventionen gut kennt.
  • Die Eclipse-Integration von Groovy bzw. Grails ist noch nicht ganz ausgereift. Die Entwicklung in Java ist besser unterstützt.
  • Applikationen, ab einer gewissen Größe, die besonderen Wert auf Skalierbarkeit und Wiederverwendbarkeit der Geschäftlogik legen, können in Grails Grenzen finden. Hier sollte man darüber nachdenken, komplexere, mächtigere Frameworks einzusetzen (Bsp.: JSF)
  • Grails ist relativ jung. Daraus entsteht die Herausforderung, dass sich einige Komponenten (wie z.B. die Entwicklerunterstützung in IDEs) noch in der Entwicklung befinden. Dadurch können Mehraufwände für höhere Einarbeitungszeiten aufgrund fehlender Dokumentation oder auch Fehlersuche in den Komponenten selbst entstehen.

Einsatz von Groovy und Grails bei //SEIBERT/MEDIA 

Die Historie

  • Skriptsprachen kennen wir gut. Das Unternehmen arbeitet seit 1996 im Web. Damals gab es eigentlich nur Perl als ernsthafte Programmiersprache im Web. Noch bis 2008 / 2009 haben wir sehr viel und intensiv mit Perl entwickelt. Auch heute betreiben wir noch große und umfangreiche Bestandssysteme in Perl. Das Know-how über den professionellen Einsatz von Skriptsprachen macht sich bei der Einführung von Grails deutlich positiv bemerkbar.
  • Wir sind vertraut mit der Einführung neuer Frameworks und haben Experten, die professionelle und umfangreiche Hilfestellungen bei der Einführung bieten können.
  • Wir haben bereits mehrere mittelgroße Applikationen mit Grails implementiert. Dabei wurde Grails teilweise durch nativen Java-Code ergänzt (Persistenz direkt in Hibernate).
  • Wir können mehrere tausend Entwicklungsstunden mit Grails an Erfahrungsschatz vorweisen.

Unsere Erfahrungen und Tipps

  • Wir setzen Grails ein, wenn in kurzer Zeit, schnelle Ergebnisse wichtig sind und eine agile Entwicklung angestrebt wird.
  • Für sehr wichtige, große und robuste Bereiche einer Applikation verwenden wir trotzdem etablierte Java-Komponenten wie Spring, Hibernate oder auch mächtigere Frameworks (JavaServer Faces, GWT).
  • Wir raten generell davon ab, die Möglichkeit einer dynamischen Typisierung in Grails zu verwenden, weil Sie die Komplexität der Software schnell erhöhen und die Fehleranfälligkeit steigern. Natürlich muss das aber im Einzelfall geprüft und entschieden werden.
  • In unserer Projekterfahrung ist Grails performant und schnell gewesen. Wir haben in bisherigen Projekten keine Performance-Herausforderungen gehabt.
  • In den ersten Grails-Projekten, die wir abgewickelt haben, mussten wir hohe Einarbeitungs- und Lernkosten zahlen. Das hat sich gelohnt, wurde zu Beginn aber insbesondere betriebswirtschaftlich deutlich unterschätzt.
  • Die laufenden Projekte und Ergebnisse, die wir mit Grails entwickelt haben, laufen sehr stabil. So gab es nur einen einzigen Fehlerbericht innerhalb eines Jahres in einer in Produktion befindlichen Datenaustauschplattform, die in Grails entwickelt wurde.
  • Wenn wir Projekte planen, dann setzen wir Grails für kleine und mittlere Anwendungen ein, bei denen es hauptsächlich auf schnelle Entwicklungszeit ankommt und weniger auf Skalierbarkeit und Ausbaubarkeit zu großen Plattformen.
  • Für Rich-Internet-Applications (RIA) empfehlen wir eher den Einsatz von Google Web Toolkit (GWT), da hier die Arbeit der Browser-Programmierung (Javascript, Ajax) durch das Framwork abgenommen wird.
  • Ein Weblog-Artikel über Grails: Grails: Kurze Entwicklungszeiten und nahtlose Java-Integration (Vodcast)
  • Projektreferenzbeschreibung in unserem Weblog "Plattform zum sicheren Datenaustausch für BodeHewitt entwickelt" und in unserer Referenzdatenbank .
  • Wir haben darüber hinaus eine sehr umfangreiche Applikation, den Universal TimeTracker für Jira und Projectile entwickelt.

Weiterführende Informationen

Gründe, warum Sie mit //SEIBERT/MEDIA Grails-Projekte umsetzen sollten

  • Wir haben Erfahrung in der Web-Entwicklung seit 1996.
  • Mit 70 Mitarbeitern und über 30 Entwicklern verfügen wir über ein leistungsfähiges Team für Ihre Web-Software.
  • Wir haben schon sehr früh mit den Entwicklung von Grails begonnen und kleine und größere Projektreferenzen vorzuweisen.
  • Wir leben aktiv Scrum und agiles Projektmanagement mit Software von Atlassian (Jira, Confluence) und können Grails daher sehr gut im Rapid Prototyping mit Ihnen einsetzen.

Erfahren Sie mehr über unsere Dienstleistungen auf unserer Grails-Spezialseite.

Groovy und Grails