Groovy – kurz & gut
()
About this ebook
Read more from Jörg Staudemeyer
Android-Programmierung kurz & gut Rating: 0 out of 5 stars0 ratingsAndroid mit Kotlin – kurz & gut: Inklusive Android 8 und Android Studio 3.0 Rating: 0 out of 5 stars0 ratingsR – kurz & gut Rating: 0 out of 5 stars0 ratings
Related to Groovy – kurz & gut
Related ebooks
Einstieg in Google Go Rating: 0 out of 5 stars0 ratingsWindows PowerShell 5 – kurz & gut Rating: 0 out of 5 stars0 ratingsEinführung in Programmiersprachen Rating: 0 out of 5 stars0 ratingsKompaktkurs C# 7 Rating: 0 out of 5 stars0 ratingsPrinzipien des Softwaredesigns: Entwurfsstrategien für komplexe Systeme Rating: 0 out of 5 stars0 ratingsJava 8 - Die Neuerungen: Lambdas, Streams, Date and Time API und JavaFX 8 im Überblick Rating: 0 out of 5 stars0 ratingsModerne Datenzugriffslösungen mit Entity Framework 6 Rating: 0 out of 5 stars0 ratingsJavaScript effektiv: 68 Dinge, die ein guter JavaScript-Entwickler wissen sollte Rating: 0 out of 5 stars0 ratingsMicroservices: Der Hype im Realitätscheck Rating: 0 out of 5 stars0 ratingsAutomatisiertes Testen: Testautomatisierung mit Geb und ScalaTest Rating: 0 out of 5 stars0 ratingsVue.js für alle: Wissenswertes für Einsteiger und Experten Rating: 0 out of 5 stars0 ratingsGraphQL: Eine Einführung in APIs mit GraphQL Rating: 0 out of 5 stars0 ratingsMobile Web-Apps mit JavaScript: Leitfaden für die professionelle Entwicklung Rating: 0 out of 5 stars0 ratingsLDAP für Java-Entwickler: Einstieg und Integration (Neuauflage) Rating: 0 out of 5 stars0 ratingsSprechen Sie Java?: Eine Einführung in das systematische Programmieren Rating: 4 out of 5 stars4/5Web-Applikationen entwickeln mit NoSQL: Das Buch für Datenbank-Einsteiger und Profis! Rating: 0 out of 5 stars0 ratingsDynamic Proxies: Effizient programmieren Rating: 0 out of 5 stars0 ratingsTypo 3: Das Praxisbuch für Entwickler Rating: 0 out of 5 stars0 ratingsC++: Kurzportträt einer zeitlosen Sprache Rating: 0 out of 5 stars0 ratingsJava Core Programmierung: Memory Model und Garbage Collection Rating: 0 out of 5 stars0 ratingsBootstrap kurz & gut Rating: 0 out of 5 stars0 ratingsDocker: Webseiten mittels Containerarchitektur erstellen Rating: 3 out of 5 stars3/5Dynamische Webseiten: Einstieg in HTML, PHP und MySQL Rating: 0 out of 5 stars0 ratingsGitHub – Eine praktische Einführung: Von den ersten Schritten bis zu eigenen GitHub Actions Rating: 0 out of 5 stars0 ratingsClusterbau: Hochverfügbarkeit mit Linux Rating: 0 out of 5 stars0 ratingsC# 8.0 – kurz & gut Rating: 0 out of 5 stars0 ratingsEinstieg in TypeScript: Grundlagen für Entwickler Rating: 0 out of 5 stars0 ratingsPython lernen – kurz & gut Rating: 0 out of 5 stars0 ratingsJava – die Neuerungen in Version 9 bis 12: Modularisierung, Syntax- und API-Erweiterungen Rating: 0 out of 5 stars0 ratingsSingle-Page-Web-Apps: JavaScript im Einsatz: Webseiten erstellen mit AngularJS, Meteor und jQuery Mobile Rating: 0 out of 5 stars0 ratings
Programming For You
Python-Grundlagen Rating: 0 out of 5 stars0 ratingsMikrocontroller in der Elektronik: Mikrocontroller programmieren und in der Praxis einsetzen Rating: 0 out of 5 stars0 ratingsHausautomation mit Raspberry Pi: Alarmanlage, Heizung, Smart Home, W-LAN & Co: 20 Projekte, die Ihr Leben leichter machen Rating: 0 out of 5 stars0 ratingsPython kurz & gut: Für Python 3.x und 2.7 Rating: 3 out of 5 stars3/5C++: Eine kompakte Einführung Rating: 0 out of 5 stars0 ratingsMicrosoft Word 2016 (Microsoft Press): Einfache Anleitungen für wichtige Aufgaben Rating: 0 out of 5 stars0 ratingsSQL – kurz & gut Rating: 0 out of 5 stars0 ratingsJavaScript kurz & gut Rating: 3 out of 5 stars3/5Python | Schritt für Schritt Programmieren lernen: Der ultimative Anfänger Guide für einen einfachen & schnellen Einstieg Rating: 0 out of 5 stars0 ratingsProgrammieren lernen mit Python 3: Schnelleinstieg für Beginner Rating: 0 out of 5 stars0 ratingsDie ultimative QNAP NAS Bibel - Das Praxisbuch - mit vielen Insider Tipps und Tricks - komplett in Farbe Rating: 0 out of 5 stars0 ratingsAndroid-Entwicklung für Einsteiger - 20.000 Zeilen unter dem Meer: 2. erweiterte Auflage Rating: 0 out of 5 stars0 ratingsAlgorithmen: Grundlagen und Implementierung Rating: 0 out of 5 stars0 ratingsHacken mit Python und Kali-Linux: Entwicklung eigener Hackingtools mit Python unter Kali-Linux Rating: 0 out of 5 stars0 ratingsHTML5-Programmierung von Kopf bis Fuß: Webanwendungen mit HTML5 und JavaScript Rating: 0 out of 5 stars0 ratingsDas große Python3 Workbook: Mit vielen Beispielen und Übungen - Programmieren leicht gemacht! Rating: 4 out of 5 stars4/5Raspberry Pi: Einstieg • Optimierung • Projekte Rating: 5 out of 5 stars5/5Praktisches Programmieren in C: Grundlagen und Tipps Rating: 0 out of 5 stars0 ratingsEigene Spiele programmieren – Python lernen: Der spielerische Weg zur Programmiersprache Rating: 0 out of 5 stars0 ratingsRaspberry Pi: Mach's einfach: Die kompakteste Gebrauchsanweisung mit 222 Anleitungen. Geeignet für Raspberry Pi 3 Modell B / B+ Rating: 0 out of 5 stars0 ratingsJavaScript kinderleicht!: Einfach programmieren lernen mit der Sprache des Web Rating: 0 out of 5 stars0 ratingsArduino: Ein schneller Einstieg in die Microcontroller-Entwicklung Rating: 5 out of 5 stars5/5Programmieren von Kopf bis Fuß Rating: 4 out of 5 stars4/5Vue.js für alle: Wissenswertes für Einsteiger und Experten Rating: 0 out of 5 stars0 ratingsSQL von Kopf bis Fuß Rating: 4 out of 5 stars4/5Programmieren für Einsteiger: Teil 2 Rating: 0 out of 5 stars0 ratingsC von Kopf bis Fuß Rating: 3 out of 5 stars3/5Java 8 - Die Neuerungen: Lambdas, Streams, Date and Time API und JavaFX 8 im Überblick Rating: 0 out of 5 stars0 ratingsPowerShell: Anwendung und effektive Nutzung Rating: 5 out of 5 stars5/5
Reviews for Groovy – kurz & gut
0 ratings0 reviews
Book preview
Groovy – kurz & gut - Jörg Staudemeyer
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> )