Groovy ist eine dynamische Programmiersprache für die Java Virtual Machine. Sie lehnt sich syntaktisch an Java an, verfolgt aber ein anderes Sprachkonzept und bietet eine Fülle zusätzlicher Möglichkeiten. Sie hat sich seit der Freigabe der Version 1.0 im Jahr 2007 stetig weiterentwickelt und zunehmend Beachtung in der Entwicklergemeinde gefunden. Inzwischen dürfte sie fester Bestandteil des Werkzeugkastens vieler Java-Programmierer sein. Mit dazu beigetragen hat sicher die Existenz zahlreicher Entwicklungstools und plattformen, die auf Groovy aufsetzen oder die Sprache zumindest integrieren (unter http://groovy.codehaus.org/Related+Projects findet man eine beeindruckende Liste). Alle großen Java-IDEs bieten leistungsfähige Unterstützung für die Groovy-Programmierung.
Groovy – kurz & gut soll Ihnen einen schnellen Einstieg in die Arbeit mit Groovy als Programmiersprache und Entwicklungsplattform ermöglichen. Es behandelt die Themen kurz und knapp und verzichtet auf lange Beispielprogramme. Es wendet sich an Entwickler, die mit der Java-Welt vertraut sind, durch die Verwendung von Tools und Plattformen – oder auf anderen Wegen – mit Groovy in Berührung geraten sind und nun einen Überblick darüber gewinnen möchten, ohne dicke Bücher wälzen zu müssen.
Groovy versteht sich in vielerlei Hinsicht weniger als Alternative zu Java, vielmehr sieht es sich als Ergänzung. Deswegen, und weil diese Sprachen generell viel miteinander zu tun haben, setzen wir voraus, dass sich die Leser dieses Buchs bereits mit Java und seiner Funktionsweise auskennen. Wenn Sie diesbezüglich noch Lücken verspüren, lassen sich diese beispielsweise mithilfe des empfehlenswerten Buchs Java-Programmierung – Das Handbuch zu Java 8 von Guido Krüger und Heiko Hansen (O’Reilly Verlag) so weit füllen, dass Sie den Ausführungen in diesem Buch ohne Schwierigkeiten folgen können.
Grundlage dieses Buchs sind die Groovy-Versionen 2.2 und 2.3.
Für weitere Informationen zu Groovy stehen Ihnen verschiedene Informationsquellen zur Verfügung, von denen hier die wichtigsten aufgeführt sein sollen (alle englischsprachig):
Die zur Groovy-Installation gehörenden Dokumentationsdateien, leider teilweise lückenhaft.
Die Dokumentationsseite des Groovy-Projekts unter http://groovy.codehaus.org/Documentation/. Sie enthält viele Informationen, ist aber etwas chaotisch organisiert und nicht immer in jeder Hinsicht auf dem neuesten Stand. Eine neue, besser strukturierte und pflegbare Dokumentationsseite ist noch in Arbeit, kann aber von der Groovy-Downloadseite heruntergeladen werden.
Das Buch Groovy in Action von Dierk König et al. (Manning). Ein sehr umfassendes, hoch gelobtes Werk, an dem verschiedene Projektbeteiligte mitgearbeitet haben und das zum Teil auch Randthemen ausführlich beleuchtet. Die erste Auflage von 2007 (deutsche Übersetzung: Groovy im Einsatz) ist weitgehend veraltet, eine Neuauflage wurde mehrmals verschoben und ist derzeit für August 2014 angekündigt.
Es gibt einige halbwegs aktuelle englischsprachige Bücher, mit deren Hilfe man etwas tiefer einsteigen oder Einzelfragen klären kann, darunter Programming Groovy 2 von Venkat Subramaniam (The Pragmatic Programmers) und Groovy 2 Cookbook von Andrey Adamovich und Luciano Fiandesio (Packt Publishing).
Soweit bekannt, gibt es momentan (abgesehen von Groovy – kurz & gut) keine aktuellen deutschsprachigen Bücher zu Groovy. Alle im Handel verfügbaren Werke beziehen sich auf 1.*-Versionen der Sprache und sind nur noch eingeschränkt nutzbar.
Unter http://www.groovyblogs.org/ ist ein Blog-Aggregator zu finden, der Nachrichten aus verschiedenen Groovy-bezogenen Blogsites zusammenfasst.
Es gibt verschiedene Mailinglisten zu Groovy. Die für Nutzer interessanteste ist user@groovy.codehaus.org. Um sich für eine Liste anzumelden, muss man zuerst seine Mailadresse unter http://xircles.codehaus.org/manage_email registrieren. Danach geht man am besten zu http://xircles.codehaus.org/projects/groovy/lists und abonniert dort die gewünschte Liste.
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 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.
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 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.
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.
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.
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.
Die Installation von Groovy ist recht einfach: herunterladen, auspacken, Umgebungsvariablen setzen. Hier zeigen wir es Ihnen Schritt für Schritt.
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).
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
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/.
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).
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).
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.
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.
Hier befinden sich zwei JAR-Dateien, die für die Integration von Groovy-Programmen in Java benötigt werden (siehe Kapitel 3).
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).
Das sind die kompletten Quellprogramme zu Groovy, sofern sie mit heruntergeladen worden sind.
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).
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.
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
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.
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> ) Hallo Groovy! Heute ist Donnerstag. ===> null groovy:000>
Danach kann man die nächste Anweisung eingeben. Vor jeder Zeile wird ein Prompt in der Form groovy:NNN>
ausgegeben; an der Nummer sehen Sie, ob Sie sich in der ersten oder in einer Folgezeile einer Anweisung befinden.
Variablen, denen Werte zugewiesen worden sind, ohne dass sie zuvor deklariert wurden (wie hier die Variable d
), werden von einer Anweisung zur nächsten weitergegeben. Es handelt sich hier um Scriptvariablen im Binding (mehr dazu in Kapitel 3). Mit dem Befehl :show variables
können Sie sich den aktuellen Inhalt des Bindings ansehen.
groovy:000> :show variables
Variables:
d = Fri Jan 10 18:50:04 CET 2014
__$swapInit = method __$swapInit()
this$dist$invoke$3 = method this$dist$invoke$3()
this$dist$set$3 = method this$dist$set$3()
this$dist$get$3 = method this$dist$get$3()
_ = null
In älteren Groovy-Versionen wird der Befehl show variables
ohne voranstehenden Doppelpunkt geschrieben.
Mit :exit
oder kurz :x
(bis Groovy 2.2 exit
oder \x
) können Sie die Groovy-Shell verlassen.
Es gibt in der Groovy-Shell noch eine Reihe weiterer Befehle; im Referenzteil im Abschnitt Tools und Optionen sind sie einzeln erläutert.
Der Befehl groovyConsole
startet eine in Groovy und Java geschriebene Bearbeitungs- und Ausführungsumgebung für Groovy-Scripts, die mit Syntax-Highlighting und sonstiger Funktionsvielfalt schon als kleine Softwareentwicklungsumgebung gelten kann. Das Anwendungsfenster umfasst zwei untereinander angeordnete Textbereiche. Im oberen können Sie ein beliebig langes Groovy-Script eingeben. Wenn Sie es mit der Menüanwahl ACTIONS → RUN, dem Button Execute Groovy Script oder einer der Tastenkombinationen Strg+R oder Strg+Enter starten, erscheinen im unteren Textbereich der Scripttext, wie er in groovysh
aussehen würde, eventuelle Ausgaben des Scripts sowie zum Abschluss auch wieder das Ergebnis des zuletzt ausgeführten Scriptbefehls. Abbildung 1.1 zeigt die Groovy-Konsole mit einem kurzen Script.
Die Groovy-Konsole verfügt noch über eine Reihe weiterer Möglichkeiten, die unter anderem bei der Fehlersuche oder bei der Entwicklung von AST-Transformationen hilfreich sein können. Mehr dazu finden Sie im Referenzteil im Abschnitt Tools und Optionen.
Wenn Sie mit einem Browser auf das Internet zugreifen können, brauchen Sie noch nicht einmal Groovy zu installieren, um Groovy-Programme zu schreiben und auszuprobieren. Unter http://groovyconsole.appspot.com/ können Sie Scripts direkt im Browser schreiben und auf dem Server ausführen lassen. Natürlich sind die Möglichkeiten hier etwas eingeschränkt, z. B. können Sie nicht auf lokale Dateien und sonstige Ressourcen zugreifen. Zum Experimentieren mit der Syntax dürfte es aber genügen. Abbildung 1.2
Die Webkonsole ist übrigens selbst eine Groovy-Anwendung, die mithilfe des Gaelyk-Frameworks in Groovy () realisiert worden ist und in der Google-Cloud läuft.
Alle bedeutenden integrierten Java-Entwicklungsumgebungen bieten sehr gute Unterstützung für Groovy mit Syntax-Highlighting, Codevervollständigung, Refactoring, gemeinsames Kompilieren von Java- und Groovy-Code usw.
NetBeansGroovy and GrailsAll
IntelliJ IDEA
Eclipsehttp://dist.springsource.org/release/GRECLIPSE/e4.3/Groovy Grails Tool Suitehttp://spring.io/tools/ggts
Abbildung 1.342.t
Umgekehrt kann die IDE nicht den Aufruf unbekannter Methoden oder Properties als Fehler markieren, denn diese könnten ja dynamisch hinzugefügt worden sein. Solche Stellen sollten jedoch markiert werden, damit man potenzielle Schreibfehler erkennt. Eclipse und IntelliJ IDEA lösen das Dilemma, indem sie die Aufrufe unbekannter Methoden und Properties durch einfache Unterstreichung kennzeichnen.
Wenn Sie mit Groovy umfangreichere Anwendungen schreiben, werden Sie ein Build-Tool wie Ant, Maven oder Gradle einsetzen. Auch das ist mit Groovy möglich.
Zum Groovy-Paket gehören einige fertige Ant-Tasks, mit denen Sie Groovy-Programme ausführen, kompilieren oder dokumentieren können. Der Task zum Ausführen eines Groovy-Programms wird beispielsweise folgendermaßen im Ant-Script definiert:
<taskdef name="groovy" classname="org.codehaus.groovy.ant.Groovy" classpathref="${groovy.classpath}"/>
groovy.classpath
groovy-all-x.x.x.jar
Mehr über die Ant-Tasks von Groovy erfahren Sie unter http://groovy.codehaus.org/The+groovy+Ant+Task.
AntBuilder
An die Stelle von Ant ist in den meisten Java-Projekten das Build-Tool Maven getreten. Daher gibt es auch für Maven ein Groovy-Compiler-Plug-in, das unter http://docs.codehaus.org/display/GROOVY/Groovy-Eclipse+compiler+plugin+for+Maven zu finden ist.
Das Build-Tool Gradle, das neuerdings wiederum Maven den Rang streitig macht, verfügt von Hause aus über ein Groovy-Plug-in. Das ist natürlich kein Wunder, denn Gradle benutzt Groovy selbst als Scriptsprache und eröffnet dadurch eine Fülle neuer Möglichkeiten, die mit XML-Konfigurationsdateien wie bei Ant und Maven nicht erreichbar sind. Mehr dazu erfahren Sie unter http://www.gradle.org/docs/current/userguide/groovy_plugin.html.
Wenn Sie mit einem der bekannten Build-Tools arbeiten, können Sie die Groovy-Bibliotheken auch aus dem Maven-Repository laden. Hierfür gibt es verschiedene Optionen; für die Version 2.3.2 der Gesamtbibliothek (groovy-all.jar) verwenden Sie unter Maven den folgenden Dependency-Deskriptor:
<dependency> <groupId>org.codehaus.groovy</groupId> <artifactId>groovy-all</artifactId> <version>2.3.2</version> </dependency>
<dependency org="org.codehaus.groovy" name="groovy-all" rev="2.3.2"/>
'org.codehaus.groovy:groovy-all:2.3.2'
Die Groovy-Laufzeitumgebung