Communardo Software GmbH, Kleiststraße 10 a, D-01129 Dresden

Java Projekte mit Groovy - Der erste Kontakt...

Wer sich als Java-Entwickler bereits ein wenig mit der Sprache Groovy beschäf­tigt hat, wird wäh­rend der Projektarbeit sicher schon einige Verwendungsmöglichkeiten für Groovy-Sprachkonstrukte gefun­den haben. In den meis­ten Fällen betrifft dies eher rela­tiv tri­viale Funktionen, wie Operationen im Dateisystem oder das Auswerten von Variablen eines Typs. Da aber gerade in der Erstellung von Prototypen die Evaluierung von Kernprozessen im Vordergrund steht, kann die ergän­zende Verwendung von Skriptsprachen á la Groovy etwas mehr Geschwindigkeit und Flexibilität in die Entwicklung bringen.

Vorbereitungen

Um das eigene Projekt fit für den Groovy-Code zu machen, muss zunächst ein­mal die groovy-all‑1.5.4.jar in den Build-Path auf­ge­nom­men wer­den. In der Regel fin­det sich diese Library im Verzeichnis der Groovy-Installation im Ordner \embed­da­ble. Verwendet man Eclipse, so funk­tio­niert das in etwa so 'Project > Properties > Java Build Path > Libraries > Add External JARs…', wobei man es vor­zie­hen sollte die Bibliothek in ein eige­nes Projektverzeichnis zu kopie­ren (/lib) und von dort aus zu verlinken.

Theoretisch könnte es jetzt auch schon los­ge­hen, aber ich denke die Wenigsten wol­len beim Programmieren auf lieb gewon­nene Features wie z.B Syntax Highlighting ver­zich­ten. Es gibt für die gän­gigs­ten IDE's bereits Groovy-Plugins und ein paar Links dazu fin­den sich am Ende des Beitrages, wer mit Eclipse arbei­tet kann mal einen Blick hier­auf wer­fen. Die Plugins an sich sind zwar noch nicht 100% aus­ge­reift und Autocompletion ver­misst man stel­len­weise auch, aber hey – ich habe vor kur­zem mit dem vi pro­gram­miert, auch das ging 😉

Der erste Kontakt

Um einen schnel­len Einstieg zu bekom­men, soll ein klei­nes Beispielprojekt in Form eines Autohandels den Integrationsprozess ver­an­schau­li­chen. Nachfolgend fin­det sich ein Listing zweier Interfaces die als Schnittstelle zur Groovy-Welt dienen.

package de.j2g.interfaces;

public inter­face ICar {
    public String getMake();
    public String getModel();
    public String getType();
    public dou­ble getPrice();
}

package de.j2g.interfaces;

import java.util.ArrayList;

public inter­face IGarage {
    public ArrayList<ICar> getCars();
}

Nachdem die Struktur steht, geht es an die Implementierung der Groovy-Klassen. In einem sepa­ra­ten Package wird die Klasse Car.groovy erzeugt, wel­che das Interface ICar implementiert:

package de.j2g.groovy

import de.j2g.interfaces.ICar;

class Car imple­ments ICar {
    String make
    String model
    String type
    dou­ble price
}

Nein, hier wurde nicht ver­ges­sen die Methoden des Interfaces hin­zu­schrei­ben. Da Groovy die Getter- und Setter-Methoden zur bei Kompilierung selbst hin­zu­fügt, müs­sen ledig­lich die Instanzvariablen defi­niert wer­den. Als Nächstes kommt die Implementierung der Garage.groovy:

package de.j2g.groovy

import de.j2g.interfaces.IGarage;
import de.j2g.interfaces.ICar;
import java.util.ArrayList;

class Garage imple­ments IGarage {
    public ArrayList<ICar> getCars() {

    def cars = new ArrayList<ICar>()

    def car1 = new Car()
    car1.make = "Ford"
    car1.model = "SHELBY GT500"
    car1.type = "Sports Car"
    car1.price = 89000.00

    def car2 = new Car()
    car2.make = "Ford"
    car2.model = "Taurus"
    car2.type = "Full-Size"
    car2.price = 21000.00

    cars.add(car1)
    cars.add(car2)

    return cars
    }
}

Der Groovy-Teil steht, jetzt fehlt noch der Aufruf aus der Java-Welt. In der Main-Klasse wer­den als ers­tes die benö­tig­ten Groovy-Klassen über den mit­ge­lie­fer­ten GroovyClassLoader gela­den. Da nur die Methode getCars() der Garage.groovy ange­spro­chen wird, muss auch nur diese Klasse expli­zit gela­den wer­den. Alle abhän­gi­gen Klassen, in die­sem Fall nur die Car.groovy, wer­den auto­ma­tisch mit­kom­pi­liert und gela­den. Ist die Klasse gela­den, erzeugt man davon eine neue Instanz und cas­tet diese auf das zuvor ange­legte Interface IGarage.

package de.j2g.main;

import groovy.lang.GroovyClassLoader;
import groovy.lang.GroovyObject;

import java.util.ArrayList;

import org.codehaus.groovy.control.CompilationFailedException;

import de.j2g.interfaces.ICar;
import de.j2g.interfaces.IGarage;

public class CarDealer {

    public sta­tic void main(String[] args) {
        System.out.print("Loading groovy classes… ");
        ClassLoader parent = CarDealer.class.getClassLoader();
        GroovyClassLoader loa­der = new GroovyClassLoader(parent);

        Class gGarage = null;

        try {
            gGarage = loader.loadClass("de.j2g.groovy.Garage");
        } catch (CompilationFailedException e) {
            …
        } catch (ClassNotFoundException e) {
            …
        }

        GroovyObject goGarage = null;
        try {
            goGarage = (GroovyObject) gGarage.newInstance();
        } catch (Exception e) {
            …
        }

        System.out.println(" done!");

        IGarage garage = (IGarage) goGarage;
        ArrayList<ICar> cars = garage.getCars();

        for (ICar car : cars) {
            System.out.print("\n" + car.getMake() + " ");
            System.out.println(car.getModel());
            System.out.println(car.getPrice() + " €");
            System.out.println(car.getType());
        }
    }
}

Das Ausführen der Main-Class sollte fol­gende Ausgabe auf die Konsole bringen:

    Loading groovy classes... done!     

    Ford SHELBY GT500
    89000.0 €
    Sports Car
    

    Ford Taurus
    21000.0 €
    Full-Size

The Power of Groovy

Die Funktionen im obe­ren Beispiel hätte man sicher auch ebenso schnell in Java umset­zen kön­nen. Etwas Programmieraufwand konnte aber schon bei der Car.groovy gespart wer­den – es war nicht nötig die Getter- und Setter zu defi­nie­ren. Um nun die Effizienz der Skriptsprache noch etwas deut­li­cher zu machen, wird im Folgenden die Klasse Garage.groovy um einen FileReader erweitert:

cars.txt

    Toyota;Camry;34000;Full-Size
    VW;Golf;25000;Economy

Garage.groovy

public ArrayList<ICar> getCars() {
    def cars = new ArrayList<ICar>()
    def carFile = new File('D:/cars.txt')

    carFile.eachLine {
        line ->
            def carArray = line.split(';')
            def car = new Car()
            car.make = carArray[0]
            car.model = carArray[1]
            car.price = Integer.parseInt(carArray[2])
            car.type = carArray[3]
            cars.add(car)
    }
    return cars;
}

Fazit

Einfacher geht es kaum noch, wenig Code zur Funktionsimplementierung und optio­na­les Exception-Handling machen Groovy zum idea­len Begleiter für die Agile Entwicklung!

Groovy IDE Plugins: Eclipse IntelliJ JEdit Netbeans

Related Posts

Pin It on Pinterest