Bauen von Java- und Groovy-Projekten mit Gradle

Vor über zwei Jahren habe ich hier bereits eine kleine Einführung in Gradle gegeben. Eigentlich sollten weitere darauf aufbauende Blogeinträge folgen. Gradle hat sich in der Zeit rasant weiter entwickelt. Damals standen wir kurz vor dem Release von Gradle 1.0, nun ist gerade die Version 1.5 erschienen. Es wird also Zeit, die kleine Blog-Serie zu Gradle fortzusetzen. In vielen Projekten (besonders Open Source) hat Gradle die bisherigen Platzhirsche Ant und Maven längst abgelöst.

Gradle ist zwar ein “General purpose” Build Framework, seine Wurzeln liegen aber in der Java-Welt. Entsprechend einfach ist es auch, ein Java-Projekt zu bauen. Hält man sich an gewisse Konventionen die Maven etabliert hat, dann besteht das Build-Management Skript (build.gradle) sogar nur aus einer Zeile:

apply plugins:'java'

Das Gradle Java Plugin geht ohne weitere Konfiguration davon aus, daß die Quellen unter src/main/java und src/main/resources liegen. Folgende Tasks stehen automatisch zur Verfügung:

$ gradle tasks
:tasks

------------------------------------------------------------
All tasks runnable from root project
------------------------------------------------------------

Build tasks
-----------
assemble - Assembles the outputs of this project.
build - Assembles and tests this project.
buildDependents - Assembles and tests this project and all projects that depend on it.
buildNeeded - Assembles and tests this project and all projects it depends on.
classes - Assembles the main classes.
clean - Deletes the build directory.
jar - Assembles a jar archive containing the main classes.
testClasses - Assembles the test classes.

Documentation tasks
-------------------
javadoc - Generates Javadoc API documentation for the main source code.

Help tasks
----------
[...]

Verification tasks
------------------
check - Runs all checks.
test - Runs the unit tests.
[...]

Um das Projekt zu bauen, reicht der Befehl gradle assemble:

$ gradle assemble
:compileJava
:processResources UP-TO-DATE
:classes
:jar
:assemble

BUILD SUCCESSFUL

Total time: 5.149 secs

Möchte man sein Projekt in Eclipse bearbeiten, genügt das Einbinden eines weiteren Plugins in der build.gradle:

apply plugins:'eclipse'

Dann kann man mit gradle eclipse die benötigten IDE Artefakte erzeugen und das Projekt anschließend in Eclipse importieren. Es gibt natürlich auch ein Gradle Eclipse Plugin, über welches man Gradle Tasks direkt aus der IDE heraus aufrufen kann. IntelliJ IDEA kann das natürlich auch längst und bei NetBeans ist man ebenfalls bereits mit der Entwicklung einer solchen Erweiterung beschäftigt.

Was fehlt nun noch zu einem richtigen Java-Projekt? Natürlich Tests. Zunächst muß man sich für ein Test-Framework entscheiden, JUnit ist meist eine gute Wahl. Gradle funktioniert aber auch mit anderen Bibliotheken, z. B. TestNG. Die Integration von JUnit in Gradle ist einfach, das Java-Plugin bringt eigentlich schon alles mit. Es müssen nur noch die Abhängigkeiten zur eigentlichen Bibliothek gesetzt werden:

repositories {
   mavenCentral()
}

dependencies {
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

Mit gradle test kann man dann die Tests ausführen. Beim allerersten Aufruf werden zunächst die nötigen Abhängigkeiten heruntergeladen und im lokalen Repository abgelegt:

$ gradle test
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:compileTestJava
Download http://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.pom
Download http://repo1.maven.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.pom
Download http://repo1.maven.org/maven2/org/hamcrest/hamcrest-parent/1.3/hamcrest-parent-1.3.pom
Download http://repo1.maven.org/maven2/junit/junit/4.11/junit-4.11.jar
Download http://repo1.maven.org/maven2/org/hamcrest/hamcrest-core/1.3/hamcrest-core-1.3.jar
:processTestResources UP-TO-DATE
:testClasses
:test

BUILD SUCCESSFUL

Total time: 10.635 secs

Will man das Projekt einmal kompilieren, die Artefakte (z. B. *.jar Dateien) bauen und alle Tests ausführen, reicht ein gradle build:

$ gradle build
:compileJava UP-TO-DATE
:processResources UP-TO-DATE
:classes UP-TO-DATE
:jar UP-TO-DATE
:assemble UP-TO-DATE
:compileTestJava UP-TO-DATE
:processTestResources UP-TO-DATE
:testClasses UP-TO-DATE
:test UP-TO-DATE
:check UP-TO-DATE
:build UP-TO-DATE

BUILD SUCCESSFUL
Total time: 5.239 secs

An der Ausgabe erkennt man noch eine nette Eigenheit: Gradle legt vorher erzeugte Zwischenergebnisse in einem lokalen Cache ab und muß so bereits ausgeführte Tasks nicht ständig neu starten (“UP-TO-DATE”). Bei Änderungen an den Ausgangsdateien (z. B. am Quellcode) erkennt Gradle natürlich, daß die Tasks erneut ausgeführt werden müssen. Will man eine Neugenerierung erzwingen, kann mit gradle clean auch das vorherige Build-Ergebnis komplett entfernt werden. Dabei wird das Ausgabe-Verzeichnis “build” gelöscht und der nächste Gradle-Lauf beginnt wieder bei Null.

Will man im Projekt Teile oder den ganzen Quellcode in Groovy schreiben, reicht es übrigens einfach das Groovy Plugins hinzuzufügen, wobei dann das Java Plugin automatisch importiert wird und nicht mehr separat in der build.gradle deklariert werden muß:

apply plugins:'groovy'

Ansonsten unterscheidet sich die Vorgehensweise nicht von der hier zuvor beschriebenen für reine Java-Projekte. Groovy- und Java-Quellcode wird dank des Groovy Cross-Compilers gemeinsam übersetzt.

Weitere praktische Tipps zum Umgang mit Gradle finden sich einerseits in der sehr ausführlichen Referenzdokumentation, aber auch im Gradle Cookbook und in den Blogs Practical Gradle bzw. Gradle Goodness. Es gibt mittlerweile auch zwei Bücher, unter anderem das als kostenlose Online-Version erhältliche “Building and Testing with Gradle.” Andere, sogar deutschsprachige Bücher sind für die nächsten Monate angekündigt.

Short URL for this post: http://wp.me/p4nxik-t6
This entry was posted in Build, config and deploy and tagged , . Bookmark the permalink.

2 Responses to Bauen von Java- und Groovy-Projekten mit Gradle

  1. Ein weiteres Buch, das sich mit den Grundlagen von Gradle und weiterfuehrenden Themen zu Gradle befasst, ist Gradle in Action von Manning. 1/3 des Buchs ist schon per Early Access Program (MEAP) erhaeltlich. Nach und nach werden weitere Kapitel hinzugefuegt.

  2. Falk Sippach Falk Sippach says:

    Danke für die Ergänzung, Dein Buch hatte ich vergessen, obwohl wir schon die MEAP-Version gekauft haben. Ich kann es bisher (das erste Drittel) auf jeden Fall auch empfehlen. Mach weiter so.

Leave a Reply