Umsetzung von Enterprise Applikationen mit Grails (Teil 1)

von Tobias Kraft

Das Framework Grails ist bereits seit einigen Jahren auf dem Markt und es stellt sich die Frage nach den Einsatzbereichen. Insbesondere ist interessant, inwiefern es sich für Applikationen im Unternehmensbereich eignet, oder ob es nur für die "kleine schnelle Lösung" seine Daseinsberechtigung hat. 

In dieser dreiteiligen Blog-Serie werden die folgenden Themen beleuchtet:

In unserem Blog haben wir schon vielfach zu technischen Themen über Grails berichtet. In diesem 1. Teil wird nochmal auf einige grundlegende Features eingegangen. 

Grails im Überblick

Bereits im Jahr 2005 startete das Projekt Grails, inspiriert im Wesentlichen durch die Konzepte von Ruby on Rails. Zu dieser Zeit war die Entwicklung von JEE-Applikationen schwergewichtig und es floss viel Arbeit in die Programmierung von Glue Code. Mit Hilfe von Spring und Neuerungen im JEE-Standard hat sich dies natürlich in den letzten Jahren massiv geändert. Als Fullstack-Webframework deckt Grails das gesamte Spektrum des Entwickelns, Testens und der Produktivsetzung einer Webapplikation ab. Es hat insbesondere das Ziel, die Komplexität bei der Erstellung von Webapplikationen zu reduzieren, basiert jedoch trotzdem auf etablierten Java-Technologien. 

Zwischenzeitlich werden in regelmäßigen Abständen jährlich Minor- und Major-Releases freigegeben. Das nächste größere Release, die Version 3.0, legt seinen Schwerpunkt auf die Modularisierung und die Verschmelzung mit Gradle als Build-System. Es soll neben Servlet-Containern auch eine bessere Integration für Frameworks wie bspw. Netty geben. 
Grails ist ein Open-Source-Projekt und steht unter der Apache Lizenz 2.0, so dass keine Lizenzkosten bei der Verwendung anfallen. Die Weiterentwicklung und Pflege wird wesentlich von der Firma Pivotal, eine ausgelagerte Tochterfirma von VMWare, vorangetrieben.

Groovy

Die Basis von Grails bildet die Sprache Groovy. Hierbei handelt es sich um eine nicht typisierte Programmiersprache, die eine JVM benötigt und es oftmals ermöglicht, Anweisungen - im Vergleich zu Java - kürzer auszudrücken. Das folgende Code-Beispiel zeigt, wie einfach Listen definiert und wie sie mit Hilfe der Groovy-Closure findAll für Collections verarbeitet werden können. Closures sind das Pendant zu den in Java8 erscheinenden Lambda-Expressions. 

Ab Version 2 von Groovy kann bei Bedarf im Code mit der Annotation @TypeChecked die Typsicherheit gewährleistet werden. Dies ist beispielsweise für öffentlich verwendete Schnittstellen interessant. 
In der Vergangenheit gab es bei Groovy öfters Kritik bzgl. der Performance. Hier wurden in den zurückliegenden Releases wesentliche Optimierungen eingearbeitet und durch explizites Setzen der ebenfalls ab Version 2 verfügbaren Annotation @CompileStatic können zusätzliche Performance-Gewinne erzielt werden.

Schlüsselkonzepte

Wesentliche Schlüsselkonzepte von Grails sind DRY (Don’t repeat yourself) und CoC (Convention over Configuration). Diese Prinzipien erlauben dem Entwickler eine stärkere Konzentration auf die Business-Logik und auch der Code wird übersichtlicher. Nachfolgend werden einige Beispiele aufgeführt: 

  • Logging kann auf Anhieb verwendet werden ohne vorherige Instanziierung
  • Zugriff auf Services von Controllern erfolgt durch Definition einer Klassen-Variablen, die den gleichen Namen wie der Service hat
  • Domain-Klassen, das Pendant zu den Entity Beans, liegen im Verzeichnis grails-app/domain. Sie werden automatisch mit der DB gemappt und es kann direkt damit gearbeitet werden, ohne dass ein EntityManager oder Ähnliches benötigt wird

Die Flexibilität geht mit CoC aber nicht verloren. Es bedeutet viel mehr, dass der Standard vordefiniert ist, man bei Bedarf jedoch auch davon abweichen kann.

Einfacher Start mit Grails

Besonders der Einstieg in Grails gestaltet sich einfach. Für den Start mit Grails wird von der Homepage die aktuelle Version heruntergeladen und entpackt. Da Grails auf der JVM aufsetzt, muss nichts als das JDK vorhanden, sowie über die Umgebungsvariable eingebunden sein. Es ist möglich, mit einem gewöhnlichen Texteditor loszulegen. Das Basisprojekt wie auch einzelne Code-Fragmente können mit der Anweisung grails und daran angehängten Optionen erstellt werden. Der Befehl grails create-domain-class com.exensio.Project erzeugt die entsprechende Domain-Klasse Project für die Interaktion mit der Persistenzschicht. Die Applikation wird mit dem Befehl grails run-app auf dem eingebetteten Tomcat-Server gestartet. Alternativ kann ebenfalls mit den später vorgestellten Plugins Jetty als Laufzeitumgebung ausgewählt werden. Während der gesamten Entwicklungszeit und auch beim Ausführen von Tests wird gegen den eingebauten Tomcat-Server entwickelt. 

Ein weiteres Feature, das den Einstieg erleichtert, ist das sogenannte Scaffolding. Über Scaffolding können aus Domain-Klassen Controller und Views für die CRUD-Funktionalitäten erzeugt werden. Dieser Ansatz eignet sich hervorragend für das Rapid Prototyping, um bspw. dem Kunden zeitnah erste Ergebnisse zeigen und besprechen zu können. Es wird zwischen dynamischen und statischen Scaffolding unterschieden. Ersteres generiert den Code der Views und Controller immer zur Laufzeit aus Templates. Die statische Methode erstellt beide Komponenten einmalig und speichert sie in den entsprechenden Dateien. Damit kann der Source-Code im Nachhinein an die eigenen Bedürfnisse angepasst werden. Ändern sich Attribute in der Domain-Klasse, so müssen diese manuell in den erzeugten Dateien nachgezogen werden. 

Bewährte Technologien

Grails setzt auf bewährte Technologien in seinem Technologiestack, wie die nachfolgende Grafik verdeutlicht. Neben der JVM ist Spring eine wesentliche Basistechnologie, die in allen Bereichen eingesetzt wird. Außer JEE-Standards und Hibernate für die Persistenz kommen mit JUnit und Ivy auch im Test- und Build-Zyklus weit verbreitete Technologien zum Einsatz.

Kurz eingegangen werden soll hier auf GORM, das die Persistenzschicht kapselt und entsprechende Funktionalitäten für einen schnellen Zugriff auf diese bereitstellt. Hibernate ist der standardmäßig konfigurierte OR-Mapper. Es ist aber auch möglich GORM mit NOSQL-Datenbanken wie MongoDB zu verwenden. 

Insbesondere das Erstellen von Datenbankabfragen ist mit GORM sehr komfortabel möglich. Über die Domain-Klasse können direkt Finder-Methoden mit bis zu drei Abfrage-Kriterien erstellt werden, wie das nachfolgende Beispiel zeigt. Ein Zweites zeigt die sogenannten Where-Queries, die Abfragen erlauben mit in Groovy-Code formulierten Bedingungen.

// Finde Methode mit zwei AND verknüpften Attributen
Book.findAllByTitleAndAuthor('Grails in Action', authorInstance)
// Where-Query
def query = Book.where{ 
  year(published) == 2013 && title =~ 'grails'
}
def results = query.list(sort: 'title')

Plugins

Ein zusätzlicher wichtiger Baustein sind Plugins, über die weitere Funktionalitäten hinzugefügt werden können. Derzeit stehen fast 800 Plugins für Grails bereit. Plugins bieten hauptsächlich Erweiterungen für folgende Bereiche:

  • Frontend (z.B. JQuery, AngularJS)
  • Integration von Drittsystemen (z.B. Suchmaschinen, BPMN-Maschinen)
  • Fachliche Funktionalitäten (z.B. Tagging, Voting)
  • Persistenzschicht (z.B. neo4j, MongoDB)
  • Nichtfunktionale Erweiterungen (z.B. Auditing zum Messen von Antwortzeiten)

Neben der Wiederverwendbarkeit sind als wesentliche Vorteile von Plugins eine einfache Installation und Möglichkeiten zur Modularisierung anzusehen.

Ausblick

Nach einem Blick aus der Vogelperspektive auf das Grails-Framework, fokusieren sich die beiden folgenden Beiträge dieser Serie auf Enterprise Applikationen.

Kategorien: GrailsGroovy

Zurück