Gradle ist ein Build-Tool, wie z.B. maven oder ant. Um eine lauffähige Anwendung zusammen zu bauen, muss festgelegt werden, welche Abhängigkeiten es beim kompilieren gibt, welche Bibliotheken das Projekt benötigt und welche Tests ausgeführt werden sollen. Die Abhängigkeiten und den Ablauf legt man im Build-Tool fest und baut damit die ausführbare Anwendung zusammen.
Durch Erweiterung mit Plugins kann Gradle sowohl ant-Build-Scripte als auch maven-POM (Projekt Object Model) ausführen.
Bevor im nächsten Schritt ein zweiter Build-Job für ein Web-Projekt zusammen mit dem Gradle-Build-Tool angelegt werden kann benötigen wir zunächst Gradle und ein entsprechendes Web-Projekt auf dem Entwicklungs-Rechner.
Zusätzlich gibt es noch die Möglichkeit den Gradle-Wrapper zu verwenden. Spring Boot unterstützt z.B. die Verwendung des Gradle-Wrappers beim Erzeugen der Projekte. Bein Verwenden des Gradle-Wrappers muss auf dem Entwicklungsrechner nichts mehr installiert werden.
Ich möchte aber mein eigenes Gradle verwenden und beschreibe deshalb die Installation der Standalone-Version von Gradle.
Für den Build des Projekts in der Entwicklung-Umgebung Eclipse würde normalerweise die Installation eines entsprechenden Gradle-Plugins für Eclipse ausreichen. Jedoch hat es Vorteile das Projekt auch unabhängig von Eclipse zusammenbauen zu können:
- Funktioniert der Build lokal auf dem Entwicklungsrechner, ist die Wahrscheinlichkeit hoch, dass der Build auch durch Jenkins auf dem Server erfolgreich ist
- Es wird sichergestellt, dass das Projekt auch ohne Eclipse-spezifische Bibliotheken zusammengebaut werden kann und lauffähig ist
Gradle-Standalone-Version
Hier beschreibe ich die Installation der Standalone-Version von Gradle für OS/X, was in ähnlicher Weise aber für die meisten Unix-System zutreffen sollte. Für die Installation unter Windows gebe ich im Text Hinweise.
Zuerst ladet ihr euch die aktuelle Version von Gradle von hier herunter: Gradle Installation. Damit Gradle funktioniert benötigt ihr lediglich eine Java-Installation.
Direkt im Homeverzeichnis meines OS/X-Users habe ich dann ein Verzeichnis von gradle angelegt und den Inhalt des ZIP-Files dorthin kopiert. Das könnt ihr entweder mit dem Finder (ist ein wenig einfacher) von OS/X oder in der Kommandozeile erledigen:
mkdir gradle cd gradle mv ~/Downloads/gradle-3.4-all.zip . unzip gradle-3.4-all.zip mv gradle-3.4/* . rm -r gradle-3.4 rm gradle-3.4-all.zip
Unter Windows geht das auch einfach mit dem Windows-Explorer.
Damit ihr gradle in der Kommandozeile ausführen könnt, müsst ihr noch eine Umgebungsvariable und den Pfad in der Umgebungsvariable PATH ergänzen. Damit ihr das nicht jedesmal tun müsst, wenn ihr die Kommandozeile neu öffnet, könnt ihr das Setzen der Umgebungsvariablen in der Datei .bash_profile in eurem Home-Verzeichnis eintragen:
nano ~/.bash_profile
Dann könnt ihr folgende Einträge in der Datei vornehmen und danach speichern:
export GRADLE_HOME=/yourPathToGradle/gradle export PATH=$GRADLE_HOME/bin:$PATH
Danach die Kommandozeile schließen und wieder öffnen. Mit
gradle -version
könnt ihr testen, ob ihr Gradle aufrufen könnt.
Unter Windows könnt ihr die Umgebungsvariablen über System -> Erweiterte Einstellungen -> Umgebungsvariablen über die Windows-Oberfläche bequem setzen.
Installation Gradle-Plugin in Eclipse
Um Gradle auch in Eclipse verwenden zu können, z.B. um ein Gradle-Projekt zu importieren und Gradle-Tasks zu starten, benötigt ihr noch ein Plugin für Eclipse. Als Gradle-Plugin für Eclipse hab ich das Plugin von Buildship Gradle Integration 2.0 verwendet. Das Plugin könnt ihr über den Eclipse-Marketplace installieren.
Gradle-Plugin
Nach erfolgreicher Installation habt ihr unter unter Eclipse -> Einstellung einen neuen Eintrag für die Gradle-Konfiguration, falls ihr auch in Eclipse zum Build die gerade eben installierte Standalone-Version von Gradle verwenden wollt.
Als nächstes werde ich das Erzeugen eines Gradle-Web-Projekts mit Spring-Boot und den Import dieses Projekt in Eclipse beschreiben.
Gradle-Daemon
Der Gradle-Daeomon ist ein Hintergrundprozess, der normalerweise beim ersten Aufruf eines Gradle-Builds gestartet wird. Der Gradle-Daeomon verringert die Build-Dauer für euer Projekt, in dem er z.B. Informationen über Projekt-Strukturen, Dateien oder Tasks im Speicher cached.
Mit dem Befehl –status könnt ihr euch die aktuell laufenden Gradle-Daemons anzeigen lassen:
gradle --status
Stoppen könnt ihr den Daemon mit:
gradle --stop
Wollt ihr z.B. den Build ohne Gradle-Daemon ausführen, könnt ihr –no-daemon verwenden:
gradle --no-daemon
Falls ihr die Verwendung des Daemons für alle Projekte abschalten wollt, könnt ihr euch eine Property-Datei mit dem Namen gradle.properties im .gradle – Verzeichnis in eurem Homeverzeichnis eures Benutzers anlegen:
nano ~/.gradle/gradle.properties
Dort tragt ihr diese Zeile ein: org.gradle.daemon=false
Wollt ihr trotz abgeschalteten Daemon ein einzelnes Projekt mit dem Daemon bauen, geht das mit dem Befehl:
gradle build --daemon
Gradle Wrapper
Der Gradle-Wrapper bietet die Möglichkeit, ein Projekt zu bauen, ohne das Gradle lokal installiert sein muss. Die zum Bau des Projekts benötigten Gradle-Wrapper-Dateien werden in das zentrale Repository übertragen. So kann jeder Entwickler das Projekt mit der Gradle-Version im Repository zusammenbauen, ohne lokal eine Gradle-Version installieren zu müssen.
Wie funktioniert das?
Als erstes muss einmalig der Gradle-Wrapper erzeugt werden. Falls ihr die Version vom Gradle-Wrapper wechseln möchtet, müsst ihr das Erzeugen des Gradle-Wrappers neu durchführen. Zum Erzeugen des Gradle-Wrappers wird eine lokale Installation von Gradle benötigt.
Zuerst erweitert ihr euer Gradle Build-Script build.gradle um eine neue Gradle-Task:
task createwrapper(type: Wrapper) {
gradleVersion = '3.4' //we want gradle 3.4 to run this project
}
Den Namen der Task könnt ihr frei vergeben. Mit dem Attribut gradleVersion wählt ihr die Version von Gradle, mit der euer Projekt zusammengebaut werden soll.
Dann startet ihr die Erzeugung des Gradle-Wrappers mit der lokalen Installation von gradle:
gradle createwrapper
Damit werden diese Verzeichnisse und Dateien in eurem Projekt erzeugt:
|-gradle
|--- wrapper
|--- gradle-wrapper.jar
|--- gradle-wrapper.properties
|-gradlew
|-gradlew.bat
Diese Dateien checkt ihr in das zentrale Repository ein.
Wenn nun ein weiterer Entwickler das Projekt aus dem zentralen Repository auscheckt (einen Clone erzeugt), kann er das Projekt durch den Aufruf von gradlew, lokal auf seinem Rechner, mit derselben Gradle-Version zusammenbauen:
./gradlew build
Beim ersten Aufruf von gradlew wird automatisch die gleiche Gradle-Wrapper-Version, wie im Repository angegeben, auf den Rechner des Entwicklers heruntergeladen. Unter OS/X wurde die Gradle-Wrapper-Version im Home-Verzeichnis des aktuellen Benutzers unter ~/.gradle/wrapper/dist gespeichert.
Damit kann man einfach sicher stellen, das alle Entwickler beim Zusammenbau des Projekts die gleiche Version von Gradle verwenden und so z.B. Build-Probleme durch unterschiedliche Gradle-Versionen minimieren.