Groovy – kurz & gut

Von Jörg Staudemeyer

Groovy ist eine dynamische Programmiersprache für die JVM, die unter Java-Entwicklern immer beliebter wird. Groovy erweitert Java um spannende neue Features, die von Sprachen wie Python und Ruby inspiriert sind, und greift gleichzeitig auf die Stärken von Java zurück. Dieses verständliche Buch richtet sich an Java-Entwickler, die einen schnellen Einstieg in die Arbeit mit Groovy suchen. Es macht Sie mit den konzeptionellen Grundlagen der Sprache, ihrer Syntax sowie den Besonderheiten im Vergleich zu Java vertraut.

• Sprache: Deutsch
• Herausgeber: O'Reilly Media
• Erscheinungsdatum: 24. Juli 2014
• ISBN: 9783955616045

Buchvorschau

Liste.

Kapitel 1. Grundlagen

Wer mit Groovy arbeiten will, sollte sich etwas mit den Grundlagen der Sprache auseinandersetzen. Dazu gehören die wichtigsten Designprinzipien der Sprache, die man verstanden haben muss, um richtig mit ihr umgehen zu können. Des Weiteren zeigen wir, wie man Groovy richtig installiert und welche Möglichkeiten es gibt, sie zu benutzen.

Groovy ist (nicht) Java

Groovy ist eng mit Java verbunden. Die Syntax der Sprache basiert auf der Syntax von Java, der produzierte Bytecode ist ganz normaler Java-Bytecode, Groovy- und Java-Klassen sind vollständig untereinander interoperabel, und es gelten die gleichen Konventionen für die Programmierung. Trotz aller Ähnlichkeiten unterscheiden sich die beiden Sprachen aber erheblich in ihrem Sprachumfang und ihren internen Mechanismen.

Script- und Compilersprache

Genau wie Java kompiliert Groovy jedes Programm, bevor es ausgeführt werden kann, zu Bytecode für die virtuelle Maschine von Java. Insofern unterscheidet sich Groovy von dezidierten Scriptsprachen wie JavaScript und Ruby, die den Quellcode direkt interpretieren. Trotzdem lässt sich Groovy in vielerlei Hinsicht wie eine Scriptsprache verwenden, denn anders als bei Java kann das Kompilieren auch unmittelbar zur Laufzeit stattfinden. Nehmen Sie einfach einen Quelltext und starten Sie ihn. An der kurzen Wartezeit können Sie vielleicht den Unterschied zur Scriptausführung erkennen, aber ansonsten bleibt der Kompiliervorgang unsichtbar. Es bleibt Ihnen aber unbenommen, Groovy-Programme in Klassendateien zu kompilieren und wie jedes andere Java-Programm zu starten.

Die Syntax: Java mit vielen Erweiterungen

Die Syntax von Groovy ist eine fast vollständige Obermenge der Syntax von Java 7. In vielen Fällen können Java-Quelldateien eins zu eins als Groovy-Programme übernommen werden. Allerdings unterscheidet sich die Semantik der Sprache nicht unerheblich, deshalb kann es vorkommen, dass derselbe Code sich als Groovy-Programm anders verhält als das Original in Java.

So sind in Groovy einige Ungereimtheiten beseitigt worden, die aus der Frühzeit von Java stammen und heute eher ein Ärgernis darstellen. Beispielsweise gibt es in Groovy keine primitiven Typen wie int, char und boolean. Zwar können Sie diese Typen auch in Groovy verwenden, dabei wird jedoch jeder Wert als ein Objekt behandelt, das Methoden und Felder haben kann. Sogar ein Ausdruck wie null.toString() ist erlaubt.

Groovy bietet gegenüber Java aber auch diverse zusätzliche sprachliche Möglichkeiten, daher wird umgekehrt ein in Groovy geschriebener Programmcode in der Regel nicht ohne größere Umbauten unter Java laufen können. Wenn man sich verstärkt der Groovytypischen Sprachmuster bedient, ist sogar die Verwandtschaft der beiden Sprachen bisweilen nur noch schwer zu erkennen.

Sehen wir uns folgendes Mini-Programm an:

import java.util.Date;

import java.text.SimpleDateFormat;

 

public class HelloJava {

  public static void main(String[] args) {

    Date d = new Date();

    SimpleDateFormat f =

      new SimpleDateFormat(EEEE);

    System.out.println

      (Hallo Java! Heute ist +f.format(d)+.);

  }

}

Dieses Programm können Sie ebenso gut als Java-Programm wie als Groovy-Programm kompilieren und laufen lassen. Es begrüßt Sie mit dem aktuellen Wochentag:

Hallo Java! Heute ist Donnerstag.

In Groovy könnte man es aber auch einfach so schreiben:

d = new Date()

println

  (Hallo Groovy! Heute ist ${d.format('EEEE')}.)

Und das ist in Java sicher nicht kompilierbar.

Zu den neuen Features, die Groovy dem von Java bekannten Sprachumfang hinzufügt, gehören unter anderem:

Closures (anonyme Funktionen)

Traits (eine Mischung aus Interfaces und abstrakten Klassen, seit Groovy 2.3)

kompakte Initialisierer für Listen und Maps

Strings mit Interpolation (eingebetteten Werten)

zusätzliche und implementierbare Operatoren

mächtigere Switch-Case-Anweisungen

Wenn der Groovy-Compiler ein Quellprogramm verarbeitet, entsteht eine ganz normale Java-Klasse. Der generierte Bytecode sieht zwar effektiv anders aus, als wenn er aus einer gleichartigen Java-Klasse stammen würde, er ist aber vollständig mit normalen Java-Klassen interoperabel. Und das bedeutet, dass Sie die ganze Vielfalt vorhandener Java-APIs und -Frameworks in aller Regel nahtlos auch mit Groovy verwenden können.

Dynamik und optionale Typisierung

Ein fundamentaler Unterschied zwischen Groovy und Java besteht in der Art und Weise, wie ein Methodenaufruf ausgeführt wird. Der Java-Compiler identifiziert die aufzurufende Methode zur Compile-Zeit anhand ihres Namens sowie der Anzahl und der deklarierten Typen ihrer Argumente und vermerkt sie direkt im Bytecode. Der Groovy-Compiler fügt stattdessen in den Bytecode den Aufruf einer Framework-Methode ein, die erst bei der Ausführung anhand der aktuellen Argumenttypen feststellt, welche Methode konkret aufgerufen werden soll.

Das Vorgehen von Groovy ist zur Laufzeit – trotz hochgradiger Optimierung – ziemlich aufwendig und zeitraubend, bietet aber die Voraussetzung für allerlei Zaubereien, die den eigentlichen Reiz von Groovy ausmachen und auf die wir in späteren Kapiteln näher eingehen.

Wenn eine aufzurufende Methode erst zur Laufzeit identifiziert wird, muss man auch erst zur Laufzeit wissen, was für einen Typ das Objekt hat, an dem die Methode aufgerufen werden soll. Aus diesem Grund müssen wir in Groovy die Typen von Variablen, Methodenparametern und -rückgabewerten auch nicht unbedingt deklarieren. Man kann daher eine Variable, eine Methode oder einen Parameter untypisiert lassen, indem man anstelle des Typs das Schlüsselwort def angibt. Optionale Typisierung bedeutet aber andererseits, dass Sie durchaus auch Typen spezifizieren können, und diese werden zur Laufzeit ebenso streng gehandhabt wie in Java. So können Sie beispielsweise einer typisierten Variablen nur einen Wert zuweisen, der ihrem Typ entspricht, also der vom selben oder einem abgeleiteten Typ ist (wobei Groovy allerdings bei Bedarf manche Typen automatisch umwandelt, so beispielsweise Zahlen in Strings).

Dynamische Methodenauflösung und optionale Typisierung machen Groovy zu einer sehr flexiblen Sprache, führen aber andererseits dazu, dass manche Fehler, wie etwa der Aufruf einer nicht existierenden Methode, erst zur Laufzeit gefunden werden können. Um schmerzliche Laufzeitfehler zu vermeiden, sollten Groovy-Programme immer mit Typprüfungen an kritischen Stellen versehen werden. In größeren Groovy-basierten Projekten sind darüber hinaus umfangreiche Unit-Tests unumgänglich, um unangenehme Überraschungen im Produktivbetrieb zu vermeiden.

Ein Vorteil dieser Dynamik besteht in der Möglichkeit, den Funktionsumfang von Objekten zur Laufzeit zu erweitern. Groovy nutzt dies in vielfältiger Weise, indem es die Klassen der Java-Standardbibliothek mit zusätzlicher bequem nutzbarer Funktionalität versieht und Ihnen die Möglichkeit gibt, fremden Klassen neue Methoden zuzuweisen oder sogar Klassen zu entwickeln, die auf Aufrufe von Methoden mit beliebigen Namen reagieren können.

Einen zusätzlichen Grad an Flexibilität fügt Groovy durch die Möglichkeit der sogenannten AST-Transformationen hinzu. Darunter sind Umformungen des abstrakten Syntaxbaums (AST = Abstract Syntax Tree) zu verstehen, mit denen man das beim Kompilieren aus dem Quellcode generierte Programm verändern kann. AST-Transformationen stellen ein extrem mächtiges Werkzeug dar, erfordern aber intime Kenntnisse der internen Mechanismen des Groovy-Compilers und überschreiten daher den Rahmen dieses Buchs.

Massiv erweiterte Laufzeitumgebung

Die ohnehin recht umfangreiche Java-Laufzeitbibliothek kann auch von Groovy-Programmen völlig nahtlos benutzt werden. Zusätzlich bringt Groovy eine eigene Bibliothek mit, durch die neben der ohnehin vorhandenen Fülle des vom JDK Gebotenen eine Vielzahl weiterer Funktionen verfügbar gemacht wird. Diese Erweiterungen umfassen unter anderem folgende Bereiche:

Erweiterungen der Standard-APIs von Java um zusätzliche Funktionen zur Nutzung von Groovy-Sprachfeatures wie den Closures, zur Vereinheitlichung der APIs und Vereinfachung ihrer Anwendung.

Diverse zusätzliche APIs für Text-Templates, Servlets, XML, dynamische Builder usw.

Einbindung von Fremdbibliotheken wie JUnit, Log4j und Ant.

Die Laufzeitbibliothek von Groovy ist inzwischen derart angewachsen, dass sie für manche Zwecke zu unhandlich geworden ist, z. B. wenn man Groovy nur als einfache Scriptsprache in Java-Anwendungen einbauen möchte. Aus diesem Grund wird die Groovy-Laufzeitbibliothek in verschiedene kleinere Blöcke aufgeteilt, die nach Bedarf in den Klassenpfad aufgenommen werden können und dann nur die wirklich benötigte Funktionalität bereitstellen. Da die Idee, die APIs auf verschiedene JARs aufzuteilen, beim Entwurf der Bibliotheken offenbar noch keine besondere Rolle gespielt hat, ist dies ein komplizierter Prozess, der wohl noch einige Zeit andauern wird.

Mit Groovy arbeiten

Bevor Sie mit Groovy programmieren können, müssen Sie einige Vorbereitungen treffen. Dieser Abschnitt erklärt, wie Sie Groovy installieren, wie Sie ein erstes Programm erstellen und welche Werkzeuge Sie ergänzend einsetzen können.

Groovy installieren

Die Installation von Groovy ist recht einfach: herunterladen, auspacken, Umgebungsvariablen setzen. Hier zeigen wir es Ihnen Schritt für Schritt.

Voraussetzung: Java-Laufzeitumgebung

Wenn Sie mit Groovy arbeiten wollen – egal ob Sie etwas programmieren oder nur vorhandene Programme ausführen möchten –, benötigen Sie auf dem Rechner eine Java-Laufzeitumgebung mindestens in der Version 1.5 (Java 5). Das JDK wird nicht benötigt, es sei denn, Sie möchten Groovy- und Java-Quellen zusammen kompilieren. Ansonsten bringt Groovy seinen eigenen Compiler mit.

Außerdem sollte die Umgebungsvariable JAVA_HOME auf das Wurzelverzeichnis der zu verwendenden Java-Installation gesetzt sein.

Wenn Sie bereits Java 8 installiert haben, brauchen Sie die neueste Groovy-Version (2.3), da es mit älteren Versionen Kompatibilitätsprobleme gibt. Allerdings sollten Sie Groovy 2.3 nicht mehr mit Java-Versionen vor 6 verwenden.

Wenn Sie das neue invokedynamic-Feature von Java nutzen möchten, durch das dynamische Programmiersprachen wie Groovy besonders unterstützt werden, müssen Sie Java ab Version 7 benutzen (siehe Referenzteil, Abschnitt Tools und Optionen).

Herunterladen und entpacken

Die eigentliche Installation ist sehr einfach. Unter Windows muss dazu kein Installationsprogramm benutzt werden, und es entstehen auch keine unerwünschten Eintragungen in der Registry.

Laden Sie Groovy von der Downloadseite http://groovy.codehaus.org/Download herunter. Holen Sie sich das Binary Release oder das Combined binary/source/documentation bundle der neuesten Version und entpacken Sie es in einem geeigneten Verzeichnis. Achten Sie darauf, dass es keine Leerzeichen im Verzeichnispfad gibt.

Setzen Sie die Systemumgebungsvariable GROOVY_HOME auf das Wurzelverzeichnis der Groovy-Installation (typischerweise so etwas wie groovy-X.X.X, also das Verzeichnis, in dem sich die Datei NOTICE.txt befindet).

Ergänzen Sie die Umgebungsvariable PATH um %GROOVY_HOME%\bin (unter Windows) bzw. $GROOVY_HOME/bin (unter Linux oder Mac OS X).

Ob Groovy korrekt installiert worden ist, können Sie in einem Konsolenfenster mit dem Befehl groovy -v kontrollieren:

> groovy -v

 

Groovy Version: 2.3.2 JVM: 1.8.0 Vendor: Oracle Corporation OS: Windows 8

Alternative Installationsmöglichkeiten

Unter Windows können Sie auch den Windows-Installer verwenden, der alle oben beschriebenen Schritte automatisch ausführt und bei Bedarf zusätzlich diverse Groovy-basierte Pakete (auch Groovy-Module genannt) wie Gaelyk, Griffon, Spock usw. installiert. Der Windows-Installer ist aber meistens erst etwas später verfügbar als die oben genannten Binärpakete für die manuelle Installation.

Eine Alternative für Linux, Mac OS X und andere Unix-ähnliche Systeme stellt der Groovy enVironment Manager (GVM) dar, mit dem sich neben Groovy auch andere, überwiegend Groovy-basierte Anwendungen installieren lassen. Sie können ihn mit folgendem bash-Befehl installieren.

$ curl -s get.gvmtool.net | bash

Die aktuelle Groovy-Version bekommen Sie dann ganz einfach mit dem Befehl

$ gvm install groovy

Weitere Informationen zum GVM finden Sie im Web unter http://gvmtool.net/.

Verzeichnisse der Groovy-Installation

Nachdem Sie Groovy installiert haben, finden Sie unterhalb des Installationsverzeichnisses die folgenden Unterverzeichnisse (abhängig von der Art und Weise der Installation kann die Verzeichnisstruktur auch abweichen).

bin

Hier liegen verschiedene Dienstprogramme von Groovy in der Form von Shell-Scripts für Unix und Batch-Dateien für Windows, mit denen der Groovy-Compiler, Groovy-Scripts und andere Tools ausgeführt werden können. Eine Übersicht der Tools und ihrer Optionen finden Sie im Referenzteil (Abschnitt Tools und Optionen).

conf

In diesem Verzeichnis befinden sich die Konfigurationsdatei groovy-starter.conf, die festlegt, welche Laufzeitbibliotheken standardmäßig beim Aufruf von Groovy geladen werden, und unter Umständen weitere Konfigurationsdateien von Groovy-Erweiterungen.

docs

Ablageort für die Dokumentationen, sofern sie mit heruntergeladen wurden. Dazu gehören die JavaDoc- bzw. GroovyDoc-Dateien zur Beschreibung der Groovy-eigenen APIs und des sogenannten Groovy Development Kit (GDK, siehe Kapitel 6) im Unterverzeichnis html. Außerdem finden Sie unter pdf einen Abzug der gesamten Groovy-Website in Form einer PDF-Datei.

embeddable

Hier befinden sich zwei JAR-Dateien, die für die Integration von Groovy-Programmen in Java benötigt werden (siehe Kapitel 3).

lib und indy

Hier findet sich eine lange Reihe von Java-Bibliotheken, die überwiegend bei der Entwicklung von Groovy selbst benötigt werden. Normalerweise benutzen Sie besser eine der JAR-Dateien im Verzeichnis embeddable. Die JARs im Verzeichnis indy kommen nur zur Anwendung, wenn Groovy unter Java 7 oder höher mit der invokedynamic-Option verwendet wird (siehe Kapitel 3).

src

Das sind die kompletten Quellprogramme zu Groovy, sofern sie mit heruntergeladen worden sind.

Das Arbeitsverzeichnis

Neben den bei der Installation angelegten Verzeichnissen für die Groovy-eigenen Programme und Daten gibt es noch ein benutzerspezifisches Verzeichnis namens .groovy, das im systemspezifischen Benutzerverzeichnis liegt und das für temporäre Daten genutzt wird. Dort können Sie auch Bibliotheken ablegen, die Groovy standardmäßig in den Klassenpfad aufnehmen soll (siehe Kapitel 2, Abschnitt Klassenpfade).

Programme schreiben und starten

Nachdem Sie Groovy erfolgreich installiert haben, stehen Ihnen verschiedene Möglichkeiten zur Verfügung, um Groovy-Programme zu erzeugen und zu starten. Die wichtigsten von ihnen sollen hier kurz vorgestellt werden.

Dabei nehmen wir als Beispiel an, wir hätten eine Groovy-Quelldatei mit dem Namen HelloGroovy.groovy und folgendem Inhalt:

d = new Date()

println Hallo Groovy! Heute ist ${d.format('EEEE')}.

Dies gibt eine Begrüßung und das aktuelle Datum auf der Konsole aus:

Hallo Groovy! Heute ist Donnerstag.

Groovy-Compiler

Zunächst können Sie das Programm genau so, wie Sie es von Java gewohnt sind, zu einer Java-Klasse kompilieren:

> groovyc HelloGroovy.groovy

Dabei entsteht eine Java-Klassendatei HelloGroovy.class, die ganz normal mit der JVM ausgeführt werden kann. Allerdings wird die Groovy-Laufzeitumgebung benötigt, daher muss der Klassenpfad entsprechend gesetzt werden:

> set CLASSPATH=.;%GROOVY_HOME%\embeddable\groovy-all-2.3.2.jar > java HelloGroovy

Groovy-Starter

Sie können sich aber auch das explizite Kompilieren sparen und den Quellcode gleich mit dem groovy-Befehl ausführen lassen. In diesem Fall wird das Programm zwar ebenfalls vor der Ausführung kompiliert, aber das geschieht nur intern im Arbeitsspeicher, und es wird keine Klassendatei erzeugt:

> groovy HelloGroovy.groovy

Wenn die Dateiendung .groovy, .gvy, .gy oder .gsh lautet, braucht sie nicht angegeben zu werden. Groovy stellt automatisch fest, ob eine Datei mit einer dieser Endungen vorhanden ist, und startet sie.

Der groovy-Befehl bietet noch eine Reihe weiterer Möglichkeiten, z. B. kann er auch Scripts direkt über das Netzwerk empfangen und abarbeiten. Mehr dazu finden Sie im Referenzteil, Abschnitt Tools und Optionen.

Groovy-Shell

Die Groovy-Shell ermöglicht interaktives Arbeiten auf Befehlszeilenebene. Man startet sie mit dem Befehl groovysh.

> groovysh

 

 

Groovy Shell (2.3.2, JVM: 1.7.0_21)

Type 'help' or '\h' for help.

-----------------------------------------------------------

groovy:000>

Hier kann man Groovy-Anweisungen zeilenweise eingeben. Die Groovy-Shell sammelt die Zeilen so lange, bis eine syntaktisch vollständige Anweisung zusammengekommen ist, kompiliert diese und führt sie aus. Danach erscheinen etwaige Textausgaben des Programms sowie zum Abschluss, kenntlich gemacht durch ===>, der Ergebniswert bzw. null, wenn es keinen Ergebniswert gibt.

groovy:000> d = new Date()

 

===> Thu May 27 18:50:04 CEST 2014

groovy:000> println ( groovy:001> Hallo Groovy! Heute ist ${d.format('EEEE')}. groovy:002> )