Einführung
Das Thema dieser Rezension wird das automatische Build-System Gradle sein. Im Englischen heißen Build-Systeme
Build Tools .
![Eine kurze Einführung in Gradle – 1]()
Warum ist das überhaupt notwendig? Das manuelle Erstellen von Projekten in Java ist ein ziemlich arbeitsintensiver Prozess. Es ist notwendig, die Bibliotheken und Frameworks, die das Projekt benötigt und von denen das Projekt abhängt, korrekt anzugeben. Hier können Sie einen hervorragenden Artikel über Habré lesen: „
Arbeiten mit Java auf der Befehlszeile “. Früher oder später werden Sie damit beginnen, einige Skripte zu erstellen, um diesen Prozess zu automatisieren. Stellen Sie sich nun vor, dass alle Entwickler auf der ganzen Welt dies tun und jeder erneut schreibt, was jemand bereits für sein Projekt geschrieben hat. Und dann erschienen Projektmontagesysteme, die diesen Prozess automatisieren. Darüber hinaus ermöglichen sie Ihnen einerseits, ein Projekt so zusammenzustellen, wie Sie es möchten, andererseits stellen sie Ihnen mehr oder weniger standardisierte Werkzeuge zur Verfügung. Eine Alternative zu Gradle ist das automatisierte Build-System Maven. Diese beiden Montagesysteme sind einerseits unterschiedlich, weisen andererseits aber auch einige Gemeinsamkeiten auf. Auf der Gradle-Website gibt es Material zu diesem Thema: „
Migration von Maven nach Gradle “. Wie in diesem Tutorial dargelegt, haben Gradle und Maven eine unterschiedliche Sichtweise auf die Erstellung eines Projekts. Gradle basiert auf einem Diagramm von Aufgaben, die voneinander abhängen können. Aufgaben erledigen eine Art Arbeit. Maven verwendet ein Modell bestimmter Phasen, an die bestimmte „Ziele“ geknüpft sind. An diesen Zielen wird einiges getan. Aufgrund dieser unterschiedlichen Ansätze folgen jedoch beide Build-Systeme derselben Konvention und das Abhängigkeitsmanagement ist ähnlich. Um Gradle verwenden zu können, müssen Sie es herunterladen. Bei Google oder Yandex geben wir „Gradle Build Tool“ ein und in den ersten Ergebnissen sehen wir die offizielle Website:
https://gradle.org . Auf der Gradle-Hauptseite gibt es einen Link mit dem Text „Docs“, der zur
Gradle-Dokumentation führt . Zuerst müssen wir Gradle installieren (Installieren), daher interessiert uns der Abschnitt „
Gradle installieren “ der Dokumentation. Es gibt viele Installationsmethoden, darunter auch die „altmodische“ Methode, d. h. manuell installieren („
Manuell installieren “). Laden Sie gemäß den Anweisungen eine Datei vom Typ „
Nur binär “ herunter, die einen Namen wie gradle-5.1.1-bin.zip hat. Als nächstes entpacken Sie das Archiv und konfigurieren die Umgebungsvariable PATH gemäß den Anweisungen. Die Hauptsache ist, dass der Befehl nach dem Ausführen der Anweisungen
gradle -vdie Version des installierten Gradle anzeigt. Möglicherweise besteht das Problem, dass das System Gradle bei der Standortbestimmung nicht an der gewünschten Stelle findet. Deshalb können Sie unter Windows Folgendes tun (unter *nix gibt es Analoga):
for %i in (gradle.bat) do @echo. %~$PATH:i Jetzt können wir vielleicht anfangen, uns kennenzulernen.
Initialisieren eines Gradle-Projekts
Ich möchte sofort darauf hinweisen, dass es bei Gradle um die Ausführung von Aufgaben geht, die
Aufgaben genannt werden (ich werde sie Aufgaben nennen).
Aufgaben werden durch verschiedene Plugins bereitgestellt . Ich empfehle Ihnen, mehr über Plugins in der offiziellen Dokumentation zu lesen: „
Verwenden von Gradle-Plugins “. Es gibt eine Reihe von „Core Plugins“, die immer verfügbar sind, wenn Gradle installiert ist. Es gibt verschiedene Kategorien dieser Plugins, wir interessieren uns jedoch für die Kategorie „
Utility “. Dieses Set enthält das Plugin „
Build Init Plugin “, das Aufgaben zum Initialisieren eines Gradle-Projekts bereitstellt. Wir sind daran interessiert, einen Projekttyp zu erstellen: „
Java-Anwendung “. Lassen Sie uns die Gradle-Aufgabe ausführen:
gradle init --type java-application Lassen Sie uns unterwegs einige Fragen beantworten, zum Beispiel, dass wir Groovy DSL (Standard-Aufgabenbeschreibungssprache für Gradle) und das JUnit-Testframework verwenden möchten (wir werden darüber in einer anderen Rezension sprechen). Nach der Erstellung erhalten wir den folgenden Dateisatz:
Zunächst erhalten wir nach der Initialisierung einen speziellen Wrapper, der für unsere Gradle-Version vorkonfiguriert ist – ein spezielles Skript. Ich rate Ihnen, mehr darüber in der offiziellen Dokumentation zu lesen – „
The Gradle Wrapper “. Zweitens sehen wir das Gradle Build Script – die Datei build.gradle. Dies ist die Hauptdatei, die beschreibt, welche Bibliotheken und Frameworks unser Projekt verwendet, welche Plugins mit dem Projekt verbunden werden müssen und verschiedene Aufgaben beschreibt. Ich empfehle Ihnen, mehr über diese Datei in der offiziellen Dokumentation zu lesen: „
Build Script Basics “.
Plugins und Aufgaben
Wenn wir uns nun den Inhalt des Build-Skripts ansehen, sehen wir den Abschnitt „Plugins“:
plugins {
id 'java'
id 'application'
}
Dies sind die gleichen Plugins, über die wir zuvor gesprochen haben. Und wenn es Plugins gibt, dann gibt es Aufgaben, die uns jetzt zur Verfügung stehen. Wir können den Befehl gradle task ausführen und sehen, was wir jetzt mit dem Projekt tun können:
Durch die Ausführung
gradle runstarten wir beispielsweise die Hauptklasse unserer Java-Anwendung:
Wie wir sehen können, steht das Gleiche weiter unten.
2 actionable tasks: 1 executed, 1 up-to-date Was bedeutet das? Das bedeutet, dass insgesamt 2 Aufgaben erledigt wurden: Außerdem wurde 1 tatsächlich erledigt und eine wurde nicht ausgeführt, weil... es ist aktuell, das heißt, der Zustand ist aktuell und es wurde nichts unternommen. Wir können den sogenannten „Dry Run“ ausführen:
gradle run -m Führen wir diesen Befehl aus, wir werden sehen, welche Aufgaben ausgeführt werden, um die Ausführungsaufgabe auszuführen:
Wie wir sehen können, wurden insgesamt 4 Aufgaben abgeschlossen: Bevor run ausgeführt wurde, wurden die Abhängigkeitsaufgabenklassen ausgeführt. Die Klassen selbst haben zwei Abhängigkeiten und werden daher auch „compileJava“ und „processResources“ ausgeführt. Wenn wir eine Aufgabe ausführen, können wir sie ausführen, während wir eine bestimmte Protokollebene anzeigen (die Protokollierungsebene bestimmt, wie wichtig Nachrichten wir sehen möchten). Wir können zum Beispiel Folgendes tun
gradle run -i. Dadurch werden uns auch Informationsmeldungen angezeigt wie:
Task :classes UP-TO-DATE
Skipping task ':classes' as it has no actions.
Weitere Informationen zur Protokollierung in Gradle finden Sie in der offiziellen Dokumentation: „
Gradle Logging “. Wie wir sehen können, wurde die Klassenaufgabe übersprungen, da sie
UP-TO-DATE ist , das heißt, der Status ist aktuell, es muss nichts getan werden, es gab also keine Aktionen. Dies liegt daran, dass Gradle standardmäßig über „
Aktualisierungsprüfungen “ oder den sogenannten inkrementellen Build verfügt. Weitere Informationen zu diesem Mechanismus finden Sie in der Gradle-Dokumentation: „
Aktualisierungsprüfungen (AKA Incremental Build) “. Dieser Mechanismus kann jedoch deaktiviert werden, indem eine Aufgabe ausgeführt wird, die das Flag --rerun-tasks angibt. Zum Beispiel,
gradle run --rerun-tasks. Dann sehen wir:
2 umsetzbare Aufgaben: 2 ausgeführt. Wie Sie sehen können, berücksichtigt die Anzahl der ausgeführten Aufgaben nur die erste Ebene des Diagramms, also die ausgeführte Aufgabe selbst und die Aufgaben, von denen sie direkt abhängt , Klassen. Aufgaben, von denen Klassen abhängen, werden hier nicht gezählt (obwohl sie ausgeführt werden, wenn die Klassenaufgabe ausgeführt wird). Lesen Sie auch über die Aufgaben:
Abhängigkeiten
Eine der Hauptaufgaben eines jeden Build-Systems ist die Verwaltung von Abhängigkeiten, also der Verwaltung der Bibliotheken/Frameworks, die unser Projekt benötigt. Das Build-System muss sicherstellen, dass sie zum richtigen Zeitpunkt verfügbar sind und das endgültige Artefakt unserer Anwendung auf die richtige Weise zusammenstellen. Standardmäßig sehen wir nach Gradle Init für Java-Application den folgenden Inhalt im Build-Skript:
dependencies {
implementation 'com.google.guava:guava:26.0-jre'
testImplementation 'junit:junit:4.12'
}
Hier ist sofort klar, was wir verbinden. Ohne ein gewisses Verständnis ist jedoch nicht klar, was Implementierung und Testimplementierung sind. Hier müssen wir uns noch einmal der Gradle-Dokumentation zuwenden, da die Gradle-Dokumentation gut geschrieben ist. Es heißt „
Verwaltung von Abhängigkeitskonfigurationen “. Wie in der Dokumentation angegeben, wird jede Abhängigkeit mit einem bestimmten Bereich deklariert – dem Bereich, in dem diese Abhängigkeit verfügbar sein wird. Dieser Bereich wird durch eine Konfiguration bestimmt, die jeweils einen eindeutigen Namen hat. Interessant ist auch, dass viele Gradle-Plugins vordefinierte Konfigurationen hinzufügen. Um herauszufinden, welche Konfigurationen wir haben, können wir Folgendes ausführen:
gradle --console plain dependencies Auf diese Weise sehen wir eine Liste aller verfügbaren Konfigurationen und ihrer Abhängigkeiten. Wir können diese Liste filtern, sodass wir nur die verfügbaren Konfigurationen selbst sehen:
gradle --console plain dependencies | find " - " Woher wissen wir, was wir verwenden sollen? Hier müssen Sie ein wenig lesen. Weil Wir verwenden das Plugin „Java“, also beginnen wir mit seiner Dokumentation und dem Abschnitt „
Abhängigkeitsverwaltung “. Hier sehen wir, dass es früher eine Konfiguration (auch bekannt als Bereich) namens „compile“ gab, die „Abhängigkeit während der Kompilierung erforderlich“ bedeutete. Aber dann wurde es durch die Implementierung ersetzt (auf Englisch Superseded). Weitere Informationen zum Austausch finden Sie im Abschnitt „
API- und Implementierungstrennung “. Es stellt sich heraus, dass diese Abhängigkeit vom „Kompilierungsklassenpfad“ besteht. Aber manchmal möchten wir, dass unsere Abhängigkeit im endgültigen Artefakt enthalten ist. Wofür? Zum Beispiel werden wir ein ausführbares JAR haben, das selbst alles Notwendige enthalten sollte. Was sollen wir dann tun? Erstens gibt es keine solche Unterstützung „out of the box“ (also standardmäßig ohne zusätzliche Aktionen). Dies liegt daran, dass jeder das Archiv auf seine eigene Weise zusammenstellen möchte und Gradle versucht, minimalistisch zu sein. Wir können auch keine JAR-Archive im Klassenpfad verwenden (ohne zusätzliche Manipulationen im Code), weil So funktioniert es nicht ( weitere Einzelheiten finden Sie unter „
Oracle: Klassen zum Klassenpfad der JAR-Datei hinzufügen “). Der schönste Weg ist daher der folgende Code im Build-Skript:
jar {
manifest {
attributes 'Main-Class': 'jrgradle.App'
}
from configurations.compileClasspath.collect { it.isDirectory() ? it : zipTree(it) }
}
In den JAR-Aufgabeneinstellungen legen wir fest, was zum JAR-Dateimanifest hinzugefügt wird (siehe „
Oracle: Den Einstiegspunkt einer Anwendung festlegen “). Und dann sagen wir, dass alle Abhängigkeiten, die für die Kompilierung benötigt wurden, in das JAR aufgenommen werden. Eine Alternative ist die Nutzung des „
Gradle Shadow Plugins “. Es mag kompliziert erscheinen, aber andere Plugins können das Leben einfacher machen. Wenn wir beispielsweise eine Webanwendung erstellen (im Gegensatz zu einer normal laufenden Java-Anwendung), verwenden wir ein spezielles Plugin – „
Gradle War Plugin “, das ein anderes Verhalten aufweist und unser Leben dort einfacher wird (alle notwendigen Abhängigkeiten werden berücksichtigt). vom Plugin selbst in ein separates Spezialverzeichnis gelegt werden. Solche Arbeiten werden dadurch geregelt, wie Webanwendungen strukturiert sein sollten. Aber das ist eine ganz andere Geschichte.
Ergebnisse
Gradle ist eine ausgezeichnete Wahl für Projekterstellungssysteme. Dies wird durch die Tatsache bestätigt, dass es von Entwicklern so bekannter Projekte wie Spring und Hibernate verwendet wird. Oben wurden nur die grundlegendsten Dinge besprochen. Dahinter verbergen sich eine Million Funktionen und Möglichkeiten, die Entwicklern zur Verfügung stehen. Gradle unterstützt auch die Erstellung von Multi-Modul-Projekten, was in dieser Rezension nicht behandelt wird, aber Gradle selbst verfügt über ein hervorragendes Tutorial: „
Erstellen von Multi-Projekt-Builds “. Ich hoffe, diese Rezension hat auch gezeigt, dass die Dokumentation von Gradle auf 5+ geschrieben ist und Sie leicht finden können, was Sie brauchen, wenn Sie wissen, wo Sie suchen müssen. Und das wird passieren, wenn Sie die Grundlagen verstehen. Darüber hinaus bietet Gradle tolle Tutorials. Abschließen möchte ich mit einer kleinen Liste dessen, was Sie mit Gradle sonst noch sehen können:
#Wjatscheslaw
GO TO FULL VERSION