#ApacheGroovy

[draegerit]

Apache Groovy #7: Dependencymanagement mit Grapes

Mit der Annotation Grapes kannst du innerhalb deines Apache Groovy Scriptes ein recht einfaches aber mächtiges Dependencymanagement verwalten bw. einrichten.

Wenn wir normalerweise ein Projekt mit Abhängigkeiten (Dependencies) aufsetzen so benötigen wir ein Maven, Gradle, Ivy oder ähnliches welches diese für uns im Projekt herunterlädt und bereithält. (Oder du ladest die *.jar Datei herunter und legst diese in deinem Projekt ab.) Beide Wege sind natürlich auch in Groovy möglich, jedoch kann du dir dieses mit Grapes deutlich vereinfachen. Du benötigst vor deinem Aufruf lediglich die Annotation @Grapes mit den Daten zur Dependency welche du zbsp. aus dem Maven Repository ablesen kannst.

Ein Beispiel mit Apache-Commons-Lang3

Die wohl bekannteste Bibliothek ist die apache-commons-lang3, diese bietet eine Vielzahl an nützlichen Funktionen, welche einem das Programmieren deutlich erleichtert. Im Maven Repository dieser Bibliothek finden wir Einträge zu den gängigen Dependencymanagement Systemen und ebenso auch für Grape.

Hier müssen wir uns nurnoch den Text aus dem Reiter "Grape" kopieren und an die erste Zeile unserer Klasse einfügen. // https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 @Grapes( @Grab(group='org.apache.commons', module='commons-lang3', version='3.12.0') ) import org.apache.commons.lang3.text.WordUtils String name = "Stefan Draeger" println new WordUtils().initials(name) Ausgabe in der GroovyConsole: groovy> // https://mvnrepository.com/artifact/org.apache.commons/commons-lang3 groovy> @Grapes( groovy> @Grab(group='org.apache.commons', module='commons-lang3', version='3.12.0') groovy> ) groovy> import org.apache.commons.lang3.text.WordUtils groovy> String name = "Stefan Draeger" groovy> println new WordUtils().initials(name) SD In diesem Fall wurden die Anfangsbuchstaben der Wörter in dem Feld "name" ausgegeben. Read the full article

[kotlintutorial]

RT @glaforge: You can now write @gcpcloud Functions in #java, or in you favorite JVM language like @ApacheGroovy, @kotlin, @jruby... Or use a framework like @micronautfw or @springcloud. https://t.co/ntkFZNE6n2 https://t.co/TCHX0YjVZm

[pdudits]

1.0 RC1 of @micronautfw is out!

@graalvm native image support

compilation-time support for @OpenApiSpec

compile-time validation

mapping annotations also at compile timehttps://t.co/wH7eNiLJeZ#microservices w/ @ApacheGroovy @kotlin @java

— Guillaume Laforge (@glaforge) October 1, 2018

http://twitter.com/glaforge/status/1046782780229718017

[draegerit]

Einrichten von Eclipse zum Entwickeln in Apache Groovy

In diesem kurzen Beitrag zeige ich dir, wie du die Entwicklungsumgebung Eclipse zum Entwickeln von Apache Groovy einrichtest.

Eclipse IDE zum Programmieren in Apache Groovy einrichten Im Beitrag Apache Groovy #2: einrichten der IDE habe ich dir bereits gezeigt, wie du IntelliJ und die GroovyConsole nutzt, um Skripte auszuführen.

Download der Eclipse IDE

Die Eclipse IDE kann unter https://www.eclipse.org/ kostenfrei heruntergeladen werden, dabei hat man die Wahl zwischen einem Installer mit Oomph und einer ZIP-Datei. Der Weg mit dem Installer ist deutlich einfacher, jedoch benötigst du lokale Adminrechte zum Installieren von Software. Solltest du diese Rechte nicht haben, so bleibt dir nur der Weg über die ZIP-Datei.

Eclipse installer mit Oomph

download von ZIP-Packages download eines ZIP-Packages für Windows In meinem Fall verwende ich ein PC mit Microsoft Windows 10 Pro und lade das "Windows x86_64" vom Eintrag "Eclipse IDE for Enterprise Java and Web Developers" herunter. Wenn die knapp 500 MB große Datei heruntergeladen wurde, dann muss diese in ein beliebiges Verzeichnis entpackt werden.

Benötigte Java Runtime für Eclipse

Um Eclipse zu starten, benötigen wir ein installiertes Oracle Java. Ob auf deinem Computer Java installiert ist, kannst du auf der Kommandozeile mit dem Befehl "java -version" prüfen. java version "18.0.1.1" 2022-04-22 Java(TM) SE Runtime Environment (build 18.0.1.1+2-6) Java HotSpot(TM) 64-Bit Server VM (build 18.0.1.1+2-6, mixed mode, sharing) Es kann aber auch sein das Java installiert wurde nur nicht die Umgebungsvariablen eingerichtet / erweitert wurden.

Starten & einrichten des Workspaces

Wenn Eclipse gestartet werden kann, wird man zunächst aufgefordert einen Workspace zu wählen bzw. einzurichten, dieses ist das Arbeitsverzeichnis der aktuellen Eclipse Instanz. Man kann theoretisch beliebig viele Workspaces einrichten (bis die Festplatte gefüllt ist :) ).

Auswahl eines Workspaces beim Starten der Eclipse IDE In meinem Fall verwende ich pro Projekt einen eigenen Workspace, somit hat man einen sehr guten Überblick.

Installieren der Groovy Development Tools

öffnen des Marketplace in der Eclipse IDE Damit wir ein Groovy Projekt und die dazugehörigen Klassen & Skripte ausführen können, benötigen wir das Plugin "Groovy Development Tools". Dieses Plugin kann über den Marketplace installiert werden, welchen du über "Help" (1) > "Eclipse Marketplace..." (2) navigierst.

Suchen nach den "Groovy Development Tools" im Eclipse Marketplace Im nun geöffneten Marketplace suchen wir mit dem Schlagwort "groovy" (3) nach den besagten "Groovy Development Tools". Die Installation wird mit der Schaltfläche "Install" (4) gestartet.

Auswahl der zu installierenden Features Die Liste der Features belassen wir und bestätigen den Dialog mit der Schaltfläche "Confirm >".

Bestätigen der Lizenz für die "Groovy Developer Tools" Die Lizenz bestätigen wir ebenfalls und klicken auf die Schaltfläche "Finish".

Zulassen von vertrauenswürdigen Quellen zum Installieren von Features Damit die Installation starten kann, müssen wir die Quellen zulassen und markieren den Eintrag "Unsigned" (5) und betätigen die Schaltfläche "Trust Selected".

neu starten der Eclipse IDE nach dem Installieren Wenn die Installation abgeschlossen ist, muss die Eclipse IDE neu gestartet werden, indem die Schaltfläche "Restart Now" betätigt wird.

Erstes Groovy Projekt erstellen

Wenn die "Groovy Developer Tools" installiert und die Eclipse IDE installiert wurde, können wir ein erstes Groovy Projekt erstellen. Wenn wir noch kein Projekt erstellt haben, also unser Workspace leer ist, dann können wir über den Hyperlink "Create a Groovy project" ein neues Groovy Projekt erstellen.

Erzeugen eines Groovy Projektes aus einem leeren Workspace alternative über einen Wizard

öffnen des Dialogs "Select a wizard" Alternativ kannst du auch ein Projekt erstellen, indem du über das Hauptmenü "File" (1) > "New" (2) > "Other..." (3) zum Dialog "Select a wizard" navigierst.

erstellen eines neuen Groovy Projektes über den Wizard In dem neuen Dialog wählen wir aus dem Baum den Knoten "Groovy" (4) aus und dort dann "Groovy Project" (5).

setzen des Projektnamens Damit das Projekt angelegt werden kann, muss ein Name (7) eingegeben werden, erst dann können wir die Schaltfläche "Next" (8) betätigen.

Eventuelles wechseln in die passende Perspektive von Eclipse Im Abschluss der Erstellung des Projektes können wir in die entsprechende Perspektive wechseln lassen.

Erzeugen neuer Klassen / Scripte

erzeugen eines neuen Groovy Types über das Contextmenü Wenn das neue Groovy Projekt erzeugt wurde, können wir dann über das Contextmenü (rechte Maustaste) des Ordners "src" (1) über das Menü "New" (2) zu "Groovy Type" (3) navigieren und den Dialog "New Groovy Type" öffnen.

Auswahl des Types sowie Eingabe des Namens Aus dem Dialog "New Groovy Type" können wir diverse Typen erzeugen.

Testen der Installation / Konfiguration mit einem kleinen Script

Wollen wir zum Abschluss die Installation / Konfiguration testen und ein kleines Groovy Script schreiben, welches lediglich die Zeichenkette "Hello World!" ausgibt.

Ausführen des Beispielcodes "Hello World!" Da wir "nur" die Zeichenkette "Hello World!" ausgeben wollen, hat unser Script nur eine Zeile (7). Die können wir über die Schaltfläche "Run As..." (8) starten.

Dialog "Run As" zum Ausführen von Code Im Dialog "Run As" können wir wählen, wie dieses Script gestartet wird. In meinem Fall führe ich dieses als "Groovy Script" (9) aus und markiere den entsprechenden Eintrag und betätige die Schaltfläche "OK" (10). Wenn wir das Script erneut ausführen wollen, dann müssen wir diesen Schritt nicht wiederholen.

Ausgabe der Zeichenkette "Hello World!" in der Konsole In der Konsole wird die Zeichenkette ausgegeben und wir können mit der eigentlichen Entwicklung starten. Read the full article

[draegerit]

Apache Groovy #9 - objektorientierte Programmierung - Interfaces

In diesem Beitrag stelle ich dir vor, wie du Interfaces in Groovy implementieren und nutzen kannst.

Im ersten Teil zur objektorientierten Programmierung mit Groovy habe ich dir bereits gezeigt, wie du Klassen und abstrakte Klassen erstellen und somit mit Vererbung arbeiten kannst. Hier soll es nun um die Interfaces gehen. In diesem Beitrag verwende ich die Eclipse IDE welche ich für die Entwicklung von Groovy Skripte erweitert habe, wie du dieses machen kannst, habe ich im Beitrag Einrichten von Eclipse zum Entwickeln in Apache Groovy ausführlich erläutert.

Was ist ein Interface?

Ein Interface definiert eine Art Muster, welchem eine Klasse entsprechen muss, die dieses Interface implementiert. D.h. es werden die Methoden definiert, aber nicht ausprogrammiert. Die eigentliche Bussiness-Logik wird in den Klassen oder Serviceimplementationen geschrieben. Auf der Seite https://docs.groovy-lang.org/docs/next/html/documentation/#interfaces findest du die offizielle Dokumentation zu den Interfaces in Apache Groovy.

Wie wird ein Interface aufgebaut?

Ein Interface wird eingeleitet mit dem Schlüsselwort "interface" gefolgt von einem Namen. interface ReportService Ein Interface kann weitere Interfaces erweitern, dafür werden diese mit dem Schlüsselwort "extends" Kommasepariert aufgeführt. interface ReportService extends Serializable, SQLData ein kleines Beispiel Starten wir mit einem kleinen Beispiel, zunächst wollen wir einen Service schreiben, welcher nur eine Funktion bietet, der Ausgabe einer Zeile auf der Kommandozeile. interface OutputService { def void printlnWithTimestamp(String text) } Die Implementation des Services kann dann wiefolgt aussehen: import java.text.SimpleDateFormat class OutputServiceImpl implements OutputService{ @Override public void printlnWithTimestamp(String text) { SimpleDateFormat df = new SimpleDateFormat("MM/dd/yyyy HH:mm:SS") String datetime = df.format(new Date()) println(" "+text) } } Wenn wir dieses nun wie folgt initialisieren und aufrufen: OutputService outputService outputService = new OutputServiceImpl() outputService.printlnWithTimestamp("Hallo Welt!") Dann erhalten wir folgende Ausgabe auf der Kommandozeile / im Terminal der IDE:

Ausgabe einer Servieimplementation in Groovy

Erweitern des Groovy Interfaces um eine Methode

Wenn wir nun das Interface um eine weitere Methode erweitern, dann werden im gleichen Zuge gezwungen diese auch in der Implementierung zu programmieren. Dieses ist ein Vorteil bei Interfaces und auch abstrakten Klassen, denn so zwingt man andere Entwickler sich an das Format zu halten.

Eine weitere Implementierung

Natürlich kann man auch eine weitere Implementierung zu diesem Interface schreiben und aufrufen und so zwischen mehreren Funktionen mit dem gleichen Namen wechseln. In meinem Fall erstelle ich mir eine weitere Implementation mit dem Zusatz das, dass Datumsformat auf Deutsch und zusätzlich der Benutzername ausgegeben wird. import java.text.SimpleDateFormat class OutputServiceImpl2 implements OutputService{ @Override public void printlnWithTimestamp(String text) { SimpleDateFormat df = new SimpleDateFormat("dd.MM.yyyy HH:mm:SS") String datetime = df.format(new Date()) String username = System.getProperty("user.name"); println(" "+text) } } Wenn wir dieses nun initialisieren und ausführen, so erhalten wir nachfolgende Ausgabe:

eine weitere Implementation des Interfaces Erkennbar ist, dass wir in der Zeile 2 unser Interface definieren und jeweils in den Zeilen 4 & 7 eine andere Implementation zuweisen. Dieses funktioniert, da wir für unsere Klassen eine Vorlage nutzen und somit mit dieser arbeiten.

Groovy-Interface-Magic

Kommen wir nun zur Groovy Magic mit Interfaces. Wenn wir eine "normale" Klasse mit den Methoden aus dem Interface implementieren, ohne das Interface selber zu implementieren, dann können wir eine Instanz von dieser Klasse in das Interface umwandeln. import java.text.SimpleDateFormat public class OutputClass { public void printlnWithTimestamp(String text) { SimpleDateFormat df = new SimpleDateFormat("MM/dd/yyyy HH:mm:SS") String datetime = df.format(new Date()) println(" "+text) } public void eineWeitereMethode() { println("Hier passiert nichts!") } } Um nun diese Klasse in eine Instanz unseres Interfaces zu verwandeln, benötigen wir den coercion operator, mit diesem können wir diverse Datentypen umwandeln (ähnlich wie ein casting). OutputClass outputClass = new OutputClass() service = outputClass as OutputService assert service instanceof OutputService Wenn wir dieses nun aufrufen, dann wird keine Fehlermeldung ausgegeben und unsere Klasse verhält sich wie das Interface. Jedoch verlieren wir die Funktion "eineWeitereMethode", denn diese ist im Interface nicht definiert. Read the full article

[draegerit]

Apache Groovy #8: objektorientierte Programmierung

In diesem Beitrag möchte ich dir die objektorientierte Programmierung mit Apache Groovy näher bringen.

OOP mit Apache Groovy - Teil 1 Bisher haben wir unsere Groovy Skripte lediglich in einer Datei geschrieben, welche einfach ausgeführt wurde. Das ist für kleine Skripte völlig okay, wenn wir jedoch große Business-Anwendungen entwickeln wollen, dann sollten wir eine gewisse Struktur einbauen und unseren Code aufteilen. Die offizielle Dokumentation zur objektorientierten Programmierung in Apache Groovy findest du unter https://groovy-lang.org/objectorientation.html.

Erzeugen einer Klasse

Eine Groovy Klasse ist der Java Klasse sehr ähnlich und auch voll kompatibel mit Java. D.h. du kannst eine Java Klasse aus Groovy importieren und ableiten. Eine Groovy Klasse erzeugen wir mit dem Schlüsselwort "class" jedoch entfällt der aus Java ggf. bekannte Accessmodifier "public", da in Groovy generell alle Klassen "public" sind. Innerhalb dieser Klasse können wir nun Felder und Funktionen definieren, welche die Klasse auszeichnen. class Person { String firstname String lastname def greeting() { "Hello from $firstname $lastname" } } Erzeugen wir uns nun ein erstes Objekt: println new Person(firstname:"Stefan", lastname:"Draeger").greeting() Die Ausgabe in der Konsole ist wie folgt: Hello from Stefan Draeger Was einem auffällt, ist der Konstruktor, welchen wir für die Erzeugung unserer Klasse verwenden, hier nutzen wir die Feldnamen als Parameter und können diesen, so die Werte übergeben. Natürlich könnten wir auch zuerst nur eine leere Hülle erzeugen und die Werte per Setter setzen. Person p1 = new Person() p1.setFirstname("Max") p1.setLastname("Mustermann") println p1.greeting() Was einem erfahrenen Javaentwickler auffallen wird ist, dass wir Funktionen verwenden, welche in der Klasse nicht definiert sind. In Groovy werden für alle öffentliche Felder getter & setter automatisch bereitgestellt (dieses können wir durch eine Annotation steuern). private Felder in Klassen Wenn wir jedoch ein Feld mit dem Accessmodifier "private" markieren, dann haben wir keinen Zugriff mehr über einen Setter auf diesen, sondern nur noch über den Konstruktor. Wir müssten also den Setter (und Getter) selber schreiben. Im nachfolgenden Beispiel habe ich das Feld "lastname" auf "private" gesetzt und erhalte beim Ausführen des Skriptes dann eine Exception das, die Funktion "setLastname()" nicht gefunden wurde. class Person { String firstname private String lastname def greeting() { "Hello from $firstname $lastname" } } Person p1 = new Person() p1.setFirstname("Max") p1.setLastname("Mustermann") println p1.greeting() Caught: groovy.lang.MissingMethodException: No signature of method: person.Person.setLastname() is applicable for argument types: (String) values:

Vererbung

Mit Vererbung können wir öffentliche Attribute (Felder, Funktionen) von einer anderen Klasse erben und wiederverwenden. Nehmen wir zunächst ein einfaches Beispiel, wir wollen ein Fahrzeugpool pflegen, dort haben wir diverse Kraftfahrzeuge (LKW, Auto, Motorrad) enthalten. Allen diesen Kraftfahrzeugen ist gleich, dass diese folgende Attribute haben: - Anzahl X Räder, - Anzahl X Sitzplätze, - Farbe, - PS, - Gewicht, - Zulässiges Gesamtgewicht Jetzt könnte man einfach für jeden der genannten Typen Kraftfahrzeuge eine Klasse mit den oben genannten Attributen erstellen, das würde funktionieren, hätte jedoch nichts mit objektorientierte Programmierung zu tun. import groovy.transform.ToString @ToString class Kraftfahrzeug { int anzahlRaeder; int anzahlSitzplaetze; String farbe; int ps; double gewicht; double zulGesamtgewicht; } Wir können nun beliebig viele Instanzen von dieser Klasse erzeugen und so unseren Fahrzeugpool aufbauen. Kraftfahrzeug lkw = new Kraftfahrzeug() lkw.setAnzahlRaeder(8) lkw.setAnzahlSitzplaetze(3) lkw.setFarbe("blau") lkw.setPs(800) lkw.setGewicht(1.7) lkw.setZulGesamtgewicht(40) Kraftfahrzeug auto = new Kraftfahrzeug() auto.setAnzahlRaeder(4) auto.setAnzahlSitzplaetze(5) auto.setFarbe("rot") auto.setPs(112) auto.setGewicht(1.5) auto.setZulGesamtgewicht(3.5) Kraftfahrzeug motorad = new Kraftfahrzeug() auto.setAnzahlRaeder(2) auto.setAnzahlSitzplaetze(2) auto.setFarbe("schwarz") auto.setPs(130) auto.setGewicht(250) auto.setZulGesamtgewicht(1) println lkw println auto println motorad Ausgabe in der Konsole: Kraftfahrzeug(8, 3, blau, 800, 1.7, 40.0) Kraftfahrzeug(2, 2, schwarz, 130, 250.0, 1.0) Kraftfahrzeug(0, 0, null, 0, 0.0, 0.0) Wir haben aber das Problem, dass wir diese Objekte nicht unterscheiden können, ob es ein Lkw, Auto oder Motorrad ist. Hier müssten wir also entweder ein zusätzliches Feld pflegen oder wir nutzen die objektorientierte Programmierung und erben von der Klasse "Kraftfahrzeug". Fangen wir mit der Klasse "Auto" an, hier erben wir nur von der Klasse "Kraftfahrzeug" und fügen zunächst keine weiteren Felder oder Funktionen hinzu. import groovy.transform.ToString @ToString class Auto extends Kraftfahrzeug{ } Da ich an der Klasse Kraftfahrzeug die Annotation @ToString gesetzt habe, muss ich diese auch an die neue Klasse Auto setzen, da sonst die toString Methode der Klasse Kraftfahrzeuge aufgerufen wird und dieses zu Verwirrung führen kann. Wenn wir nun ein Objekt vom Typ Auto erzeugen, dann wird in der Konsole die Ausgabe erzeugt, dass wir zwei unterschiedliche Objekte haben. Kraftfahrzeug lkw = new Kraftfahrzeug() lkw.setAnzahlRaeder(8) lkw.setAnzahlSitzplaetze(3) lkw.setFarbe("blau") lkw.setPs(800) lkw.setGewicht(1.7) lkw.setZulGesamtgewicht(40) Auto auto = new Auto(); auto.setAnzahlRaeder(4) auto.setAnzahlSitzplaetze(5) auto.setFarbe("rot") auto.setPs(112) auto.setGewicht(1.3) auto.setZulGesamtgewicht(3.5) println lkw println auto de.draegerit.firstprj.oop.Kraftfahrzeug(8, 3, blau, 800, 1.7, 40.0) de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4) Nun können wir uns eine Liste mit den Kraftfahrzeugen aufbauen und verwalten. List kfzPool = new ArrayList() Kraftfahrzeug lkw = new Kraftfahrzeug() lkw.setAnzahlRaeder(8) lkw.setAnzahlSitzplaetze(3) lkw.setFarbe("blau") lkw.setPs(800) lkw.setGewicht(1.7) lkw.setZulGesamtgewicht(40) Auto auto = new Auto() auto.setAnzahlRaeder(4) auto.setAnzahlSitzplaetze(5) auto.setFarbe("rot") auto.setPs(112) auto.setGewicht(1.3) auto.setZulGesamtgewicht(3.5) for(int i=0;i if(kfz instanceof Auto) println kfz } de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4) de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4) de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4) de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4) de.draegerit.firstprj.oop.Auto(5, 112, rot, 3.5, 1.3, 4) Read the full article

[draegerit]

Apache Groovy #2: einrichten der IDE

In diesem Beitrag soll es nun darum gehen, wie du eine IDE für Apache Groovy einrichten bzw. deine Entwicklungsumgebung einrichtest.

Benötigte Ressourcen

- Oracle Java JDK (kein JRE!) - Groovy

Installieren von Oracle Java JDK

Für das Ausführen von Groovy benötigen wir eine Oracle Java JDK. Zunächst prüfen wir auf der Kommandozeile, ob bereits ein Oracle Java JDK installiert ist.

Anzeigen der Java Version in der Konsole In meinem Fall ist die Java Version 17 installiert. Wenn kein Oracle Java installiert ist, dann erhältst du die nachfolgende Meldung in der Konsole.

Meldung, kein Java installiert Einrichten eines Oracle Accounts zum Download von Java Wenn du kein Java installiert hast, dann musst du dir dieses herunterladen und installieren. Zum Download benötigst du jedoch einen Account bei Oracle welchen du kostenfrei anlegen kannst. Setzen der Umgebungsvariablen JAVA_HOME & Path Wenn du Oracle Java installiert hast, dann musst du zum Schluss die Umgebungsvariable "JAVA_HOME" erstellen und die Variable "Path" erweitern. Um eine neue Umgebungsvariable zu erstellen, kannst du diese entweder nur für deinen aktuell angemeldeten Benutzer erstellen oder soweit du Administratorrechte hast, diese systemweit für alle Benutzer erstellen.

Einträge im Startmenü zum hinzufügen von Umgebungsvariablen Ich meinem Fall erstelle ich die Umgebungsvariablen für meinen Benutzer und wähle den obigen Eintrag.

Dialog "Umgebungsvariablen" Im neuen Fenster "Umgebungsvariablen" wählen wir die Schaltfläche "Neu...". Im neuen Fenster "Neue Benutzervariable" geben wir als Namen den Wert "JAVA_HOME" ein und als Wert den Pfad zum Basisverzeichnis von dem installierten Oracle Java. In meinem Fall habe ich mehrere Oracle Java installiert und habe die Version JDK 17 ausgewählt.

Umgebungsvariable "JAVA_HOME" anlegen Im Anschluss erweitern wir die bestehende Variable "Path" um den Eintrag zum BIN-Verzeichnis von Java. Dieses bewirkt, dass wir auf der Konsole einfach "java-version" tippen können, ohne dass wir den kompletten Pfad angeben müssen.

Path Variable ergänzen

Installieren von Groovy

Es gibt zwei Wege, Apache Groovy zu installieren, zum einen als Download einer ZIP-Datei sowie als MSI-Datei mit einem Wizard.

Installieren über ZIP-Datei

Wenn du keine Administratorrechte auf deinem Rechner hast, dann kannst du die Installation mit der ZIP-Datei wählen. Auf der Seite https://groovy.apache.org/download.html kannst du die Schaltfläche "Download" wählen und lädst dir somit immer die aktuelle Version von Apache Groovy herunter.

Wenn die ZIP-Datei heruntergeladen wurde, wird diese in ein beliebiges Verzeichnis entpackt. In meinem Fall habe ich mir auf dem Laufwerk "C" einen Ordner "Groovy" erstellt und dort die Datei entpackt.

Installieren als MSI-Datei mit Wizard

Wenn du Administratorrechte hast, dann kannst du die Installation via EXE-Datei wählen und dich mithilfe eines Wizards durch die Installation führen lassen.

Wenn du den Windows Defender aktiv hast, dann wird ggf. die MSI-Datei als potentiell gefährlich angezeigt werden. Um jedoch trotzdem Apache Groovy per MSI-Datei zu installieren, müssen wir zurnächst auf "Weitere Information" (1) klicken, um dann die Schaltfläche "Trotzdem ausführen" (2) zu bekommen.

Wenn der Wizard gestartet ist, dann musst du im zweiten Schritt die Lizenz akzeptieren und um dritten Schritt die Schaltfläche "Typical" betätigen.

Im Abschluss der Installation musst noch die Umgebungsvariable GROOVY_HOME erstellen und die Path Variable erweitern, dieses geschieht wie beim Abschnitt Java.

GroovySH - Shell

In der Groovy Shell können wir programmieren, jedoch ohne die netten Features wie Codevervollständigung. Aber für einen ersten Test soll das schon einmal ausreichen. Wir starten die Grooy Shell mit dem Befehl "groovysh" auf der Kommandozeile.

Die Groovy Shell kann über den Befehl ":quit" verlassen werden. Nun kann man einige einfache Rechenaufgaben eingeben und sich die Lösung mit der Return-Taste ausgeben lassen. groovy:000> 1+1 ===> 2 groovy:000> 5*9 ===> 45 groovy:000> 12/9 ===> 1.3333333333 groovy:000> 7/0 ERROR java.lang.ArithmeticException: Division by zero groovy:000> Wir sehen nun das nach jedem betätigen der Return-Taste der Code ausgeführt wird, das nützt uns beim Programmieren im OOP Bereich recht wenig, denn meist haben wir dann Klassen und Strukturen welche zunächst angelegt werden und später verwendet werden. Doch hier ist der Compiler "inteligent genug" um zu erkennen, das noch etwas kommen kann. Ein kleiner Test Erstellen wir eine Klasse Greeting welche zunächst nur die Funktion "sayHello" beinhalten soll. C:Usersstefa>groovysh Groovy Shell (2.4.5, JVM: 1.8.0_311) Type ':help' or ':h' for help. ------------------------------------------------------------------------------------- groovy:000> class Greeting { groovy:001> def sayHello(){ println "Hello World!" } groovy:002> } ===> true groovy:000> greeting = new Greeting() ===> Greeting@17923a5 groovy:000> greeting.sayHello() Hello World! ===> null groovy:000>

GroovyConsole

Die GroovyConsole ist eine kleine IDE in welche du bereits kleinere Projekte programmieren kannst. Dieses Tool startest du über die Kommandozeile mit dem Befehl "groovyConsole".

Ein erstes kleines Programm in der GroovyConsole

Schreiben wir nun unser kleines Programm "Greeting" (3) in der GroovyConsole. Dieses Programm speichern wir als Datei "Application.groovy" (1) und kompilieren und führen dieses über die Schaltfläche "Execute Groovy Script" (2) aus. Die Ausgabe unseres Programmes erfolgt dann im unteren Bereich der GroovyConsole (4).

Installieren von IntelliJ

Bisher haben wir nur Entwicklungsumgebungen verwendet welche mit wenigen Features daher kommen, wir große, anspruchsvolle Projekte benötigen aber ein Tool welches uns bei der Entwicklung unterstützt, eines davon ist IntelliJ. Du kannst dir IntelliJ in zwei Versionen installieren, wobei die eine davon eine 30 Tage Testversion ist und eine Menge an Features bietet. Im Nachfolgenden möchte ich dir jedoch die Community Edition zeigen, denn diese reicht für die meisten Projekte aus. Wenn die knapp 600 MB große Datei SETUP-Datei heruntergeladen wurde, wird der Wizard gestartet.

Erstellen eines Groovy Projektes Wenn wir IntelliJ zum ersten mal starten, dann können wir aus dem Dialog auswählen ob wir ein neues Projekt erstellen möchten, ein bereits erstellen öffnen, oder aber aus einem VCS System (Git, Mercury, SVN, CVS) einen Zweig laden wollen. In unserem Fall möchten wir ein neues Projekt erstellen und klicken daher auf die Schaltfläche "New Project".

Im neuen Dialog vergeben wir nun dem neuen Projekt einen Namen (1) und wählen als Sprache "Groovy" (2) aus. Sollten wir keinen speziellen Java / Groovy Compiler benötigen, so können wir mit der schaltfläche "Create" (3) das Projekt erstellen.

Wenn die IDE geladen und das Projekt erzeugt wurde, können wir mit der Programmierung beginnen. Unter Entwicklern hat sich es bewährt, dass Klassen in Packages nach Funktion sortiert werden, daher starten wir damit und erzeugen uns zunächst ein solches Package über einen Rechtsklick auf den Ordner "src" > "New" > "Package".

Als Format kann man folgendes Muster verwenden "..".

Troubleshooting

Fehlermeldung Error: Could not find or load main class org.codehaus.groovy.tools.GroovyStarter Sollte dieser Fehler erscheinen, so prüfe zunächst, ob deine Umgebungsvariable GROOVY_HOME auf das korrekte Verzeichnis zeigt. C:Usersstefa>groovy -v Error: Could not find or load main class org.codehaus.groovy.tools.GroovyStarter Caused by: java.lang.ClassNotFoundException: org.codehaus.groovy.tools.GroovyStarter In meinem Fall lautet dieses "C:Groovygroovy-2.4.5". Read the full article