Groovy: kurz & gut

Inhaltsverzeichnis
Groovy: kurz & gut

Groovy: kurz & gut

Jörg Staudemeyer

Einleitung

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):

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> )
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.

Groovy-Konsole

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
Abbildung 1.1 Die Groovy-Konsole

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.

Groovy-Webkonsole

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 Groovy-Webkonsole

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

Codevervollständigung mit Groovy-Methoden

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.classpathgroovy-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