Gradle - Kurzanleitung

"Gradle is an open source build automation system"

Ant und Maven waren auf dem JAVA-Markt sehr erfolgreich. Ant war das erste Build-Tool, das im Jahr 2000 veröffentlicht wurde. Es basiert auf einer prozeduralen Programmieridee. Später wird es durch die Möglichkeit verbessert, Plug-Ins und das Abhängigkeitsmanagement über das Netzwerk mithilfe von Apache-IVY zu akzeptieren. Der Hauptnachteil ist XML als Format zum Schreiben von Build-Skripten. Hierarchisch zu sein ist nicht gut für die prozedurale Programmierung, und XML wird in der Regel unüberschaubar groß.

Maven wird im Jahr 2004 eingeführt. Es kommt mit viel Verbesserung als ANT. Es ändert seine Struktur und verwendet weiterhin XML zum Schreiben von Build-Spezifikationen. Maven verlässt sich auf die Konventionen und kann die Abhängigkeiten über das Netzwerk herunterladen. Der Hauptvorteil von Maven ist sein Lebenszyklus. Während Sie kontinuierlich denselben Lebenszyklus für mehrere Projekte verfolgen. Dies ist mit Kosten für Flexibilität verbunden. Maven hat auch einige Probleme beim Abhängigkeitsmanagement. Konflikte zwischen Versionen derselben Bibliothek werden nicht gut behandelt, und komplexe angepasste Build-Skripte sind in Maven tatsächlich schwieriger zu schreiben als in ANT.

Schließlich kam Gradle 2012 ins Bild. Gradle verfügt über einige effiziente Funktionen beider Tools.

Eigenschaften von Gradle

Im Folgenden finden Sie eine Liste der Funktionen, die Gradle bietet.

• Declarative builds and build-by-convention- Gradle ist mit einer separaten domänenspezifischen Sprache (DSL) verfügbar, die auf der Sprache Groovy basiert. Gradle bietet deklarative Sprachelemente. Diese Elemente bieten auch Unterstützung für Java, Groovy, OSGI, Web und Scala.

• Language for dependency based programming - Die deklarative Sprache befindet sich oben auf einem Allzweck-Aufgabendiagramm, das Sie in Ihrem Build vollständig nutzen können.

• Structure your build- Mit Gradle können Sie endlich gemeinsame Designprinzipien auf Ihren Build anwenden. Sie erhalten eine perfekte Struktur für den Bau, sodass Sie einen gut strukturierten und leicht zu wartenden, nachvollziehbaren Bau entwerfen können.

• Deep API - Mit dieser API können Sie das Konfigurations- und Ausführungsverhalten im Kern überwachen und anpassen.

• Gradle scales - Gradle kann die Produktivität problemlos steigern, von einfachen und einzelnen Projekt-Builds bis hin zu riesigen Enterprise-Multi-Projekt-Builds.

• Multi-project builds- Gradle unterstützt Builds für mehrere Projekte und teilweise Builds. Wenn Sie ein Teilprojekt erstellen, kümmert sich Gradle um die Erstellung aller Teilprojekte, von denen es abhängt.

• Different ways to manage your builds - Gradle unterstützt verschiedene Strategien zum Verwalten Ihrer Abhängigkeiten.

• Gradle is the first build integration tool- Gradle wird für Ihre ANT-Aufgaben, Maven- und Lvy-Repository-Infrastruktur zum Veröffentlichen und Abrufen von Abhängigkeiten vollständig unterstützt. Gradle bietet auch einen Konverter zum Umwandeln einer Maven pom.xml in ein Gradle-Skript.

• Ease of migration- Gradle kann sich leicht an jede Struktur anpassen, die Sie haben. Daher können Sie Ihren Gradle-Build immer in demselben Zweig entwickeln, in dem Sie ein Live-Skript erstellen können.

• Gradle Wrapper- Mit Gradle Wrapper können Sie Gradle-Builds auf Computern ausführen, auf denen Gradle nicht installiert ist. Dies ist nützlich für die kontinuierliche Integration von Servern.

• Free open source - Gradle ist ein Open Source-Projekt und unter der Apache Software License (ASL) lizenziert.

• Groovy- Gradles Build-Skript ist in Groovy geschrieben. Das gesamte Design von Gradle ist darauf ausgerichtet, als Sprache und nicht als starrer Rahmen verwendet zu werden. Mit Groovy können Sie Ihr eigenes Skript mit einigen Abstraktionen schreiben. Die gesamte Gradle-API ist vollständig in der Sprache Groovy konzipiert.

Warum Groovy?

Die vollständige Gradle-API wurde in der Sprache Groovy entwickelt. Dies ist ein Vorteil eines internen DSL gegenüber XML. Gradle ist im Kern ein Allzweck-Build-Tool. Der Schwerpunkt liegt auf Java-Projekten. In solchen Projekten sind die Teammitglieder mit Java sehr vertraut und es ist besser, dass ein Build für alle Teammitglieder so transparent wie möglich ist.

Sprachen wie Python, Groovy oder Ruby eignen sich besser für das Build-Framework. Groovy wurde ausgewählt, weil es für Benutzer von Java bei weitem die größte Transparenz bietet. Die Basissyntax von Groovy ist dieselbe wie bei Java. Darüber hinaus bietet Groovy noch viel mehr.

Gradle ist ein Build-Tool, das auf Java basiert. Es gibt einige Voraussetzungen, die vor der Installation des Gradle-Rahmens installiert werden müssen.

Voraussetzungen

JDK und Groovy sind die Voraussetzungen für die Installation von Gradle.

• Für Gradle muss JDK Version 6 oder höher auf Ihrem System installiert sein. Es verwendet die installierten JDK-Bibliotheken und setzt auf die Umgebungsvariable JAVA_HOME.

• Gradle verfügt über eine eigene Groovy-Bibliothek, daher müssen wir Groovy nicht explizit installieren. Wenn es installiert ist, wird dies von Gradle ignoriert.

Im Folgenden finden Sie die Schritte zum Installieren von Gradle in Ihrem System.

Schritt 1 - Überprüfen Sie die JAVA-Installation

Zunächst muss das Java Software Development Kit (SDK) auf Ihrem System installiert sein. Um dies zu überprüfen, führen Sie ausJava –version Befehl in einer der Plattformen, an denen Sie arbeiten.

In Windows -

Führen Sie den folgenden Befehl aus, um die Java-Installation zu überprüfen. Ich habe JDK 1.8 in meinem System installiert.

C:\> java -version

Ausgabe -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Unter Linux -

Führen Sie den folgenden Befehl aus, um die Java-Installation zu überprüfen. Ich habe JDK 1.8 in meinem System installiert.

$ java - version

Ausgabe -

java version "1.8.0_66"
Java(TM) SE Runtime Environment (build 1.8.0_66-b18)
Java HotSpot(TM) 64-Bit Server VM (build 25.66-b18, mixed mode)

Wir gehen davon aus, dass die Leser dieses Tutorials Java SDK Version 1.8.0_66 auf ihrem System installiert haben.

Schritt 2 - Laden Sie die Gradle Build-Datei herunter

Laden Sie die neueste Version von Gradle über den Link " Gradle herunterladen" herunter . Klicken Sie auf der Referenzseite aufComplete DistributionVerknüpfung. Dieser Schritt ist für jede Plattform üblich. Dazu erhalten Sie die komplette Distributionsdatei in Ihren Downloads-Ordner.

Schritt 3 - Umgebung für Gradle einrichten

Das Einrichten der Umgebung bedeutet, dass wir die Verteilungsdatei extrahieren und die Bibliotheksdateien an den richtigen Speicherort kopieren müssen. EinrichtenGRADLE_HOME und PATH Umgebungsvariablen.

Dieser Schritt ist plattformabhängig.

In Windows -

Extrahieren Sie die heruntergeladene Zip-Datei mit dem Namen gradle-2.11-all.zip und kopieren Sie die Verteilungsdateien von Downloads\gradle-2.11\ zu C:\gradle\ Standort.

Danach fügen Sie die C:\gradle und C:\gradle\bin Verzeichnisse zu den GRADLE_HOME und PATHSystemvariablen. Befolgen Sie die angegebenen Anweisungenright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Dort finden Sie ein Dialogfeld zum Erstellen und Bearbeiten von Systemvariablen. Klicken Sie auf die Schaltfläche Neu, um die Variable GRADLE_HOME zu erstellen (folgen Sie dem Screenshot auf der linken Seite). Klicken Sie auf Bearbeiten, um die vorhandene Pfadsystemvariable zu bearbeiten (folgen Sie dem Screenshot auf der rechten Seite). Befolgen Sie die unten angegebenen Screenshots.

Unter Linux -

Extrahieren Sie die heruntergeladene Zip-Datei mit dem Namen gradle-2.11-all.zip dann finden Sie eine extrahierte Datei mit dem Namen gradle-2.11.

Sie können Folgendes verwenden, um die Verteilungsdateien von zu verschieben Downloads/gradle-2.11/ zu /opt/gradle/Standort. Führen Sie diesen Vorgang aus dem Download-Verzeichnis aus.

$ sudo mv gradle-2.11 /opt/gradle

Bearbeiten Sie die Datei ~ / .bashrc, fügen Sie den folgenden Inhalt ein und speichern Sie sie.

export ORIENT_HOME = /opt/gradle
export PATH = $PATH:

Führen Sie den folgenden auszuführenden Befehl aus ~/.bashrc Datei.

$ source ~/.bashrc

Schritt 4: Überprüfen Sie die Gradle-Installation

In Fenstern:

Sie können den folgenden Befehl an der Eingabeaufforderung ausführen.

C:\> gradle –v

Ausgabe: Dort finden Sie die Gradle-Version.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978
Groovy: 2.4.4

Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Windows 8.1 6.3 amd64

Unter Linux:

Sie können den folgenden Befehl im Terminal ausführen.

$ gradle –v

Ausgabe: Dort finden Sie die Gradle-Version.

------------------------------------------------------------
Gradle 2.11
------------------------------------------------------------

Build time: 2016-02-08 07:59:16 UTC
Build number: none
Revision: 584db1c7c90bdd1de1d1c4c51271c665bfcba978

Groovy: 2.4.4
Ant: Apache Ant(TM) version 1.9.3 compiled on December 23 2013
JVM: 1.7.0_60 (Oracle Corporation 24.60-b09)
OS: Linux 3.13.0-74-generic amd64

Gradle erstellt eine Skriptdatei für zwei Dinge. einer istprojects und ein anderer ist tasks. Jeder Gradle-Build repräsentiert ein oder mehrere Projekte. Ein Projekt stellt eine Bibliotheks-JAR oder eine Webanwendung dar, oder es kann eine ZIP-Datei darstellen, die aus den von anderen Projekten erstellten JARs zusammengestellt wurde. Mit einfachen Worten, ein Projekt besteht aus verschiedenen Aufgaben. Eine Aufgabe bedeutet eine Arbeit, die ein Build ausführt. Eine Aufgabe kann darin bestehen, einige Klassen zu kompilieren, eine JAR zu erstellen, Javadoc zu generieren oder einige Archive in einem Repository zu veröffentlichen.

Gradle verwendet Groovy language zum Schreiben von Skripten.

Build Script schreiben

Gradle bietet eine domänenspezifische Sprache (Domain Specific Language, DSL) zur Beschreibung von Builds. Dies verwendet die Groovy-Sprache, um die Beschreibung eines Builds zu vereinfachen. Jedes Build-Skript von Gradle wird mit UTF-8 codiert, offline gespeichert und als build.gradle bezeichnet.

build.gradle

Wir beschreiben Aufgaben und Projekte mithilfe eines Groovy-Skripts. Sie können einen Gradle-Build mit dem Befehl Gradle ausführen. Dieser Befehl sucht nach einer Datei mit dem Namenbuild.gradle. Schauen Sie sich das folgende Beispiel an, das ein kleines Skript darstellt, das gedruckt wirdtutorialspoint. Kopieren Sie das folgende Skript und speichern Sie es in einer Datei mit dem Namenbuild.gradle. Dieses Build-Skript definiert einen Aufgabennamen Hallo, mit dem die Tutorialspoint-Zeichenfolge gedruckt wird.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das obige Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert ist.

C:\> gradle –q hello

Ausgabe:

tutorialspoint

Wenn Sie der Meinung sind, dass die Aufgabe ähnlich wie das ANT-Ziel funktioniert, ist dies richtig. Die Gradle-Aufgabe entspricht dem ANT-Ziel.

Sie können diese Hallo-Aufgabe vereinfachen, indem Sie eine Verknüpfung angeben (die ein Symbol darstellt <<) zum doLastErklärung. Wenn Sie diese Verknüpfung zur obigen Aufgabe hinzufügenhello Es sieht wie im folgenden Skript aus.

task hello << {
   println 'tutorialspoint'
}

Wie oben können Sie das obige Skript mit ausführen gradle –q hello Befehl.

Das Grade-Skript verwendete hauptsächlich zwei reale Objekte, eines ist Projektobjekt und eines ist Skriptobjekt.

Project Object- Jedes Skript beschreibt ein oder mehrere Projekte. Während der Ausführung konfiguriert dieses Skript das Projektobjekt. Sie können einige Methoden aufrufen und Eigenschaften in Ihrem Build-Skript verwenden, die an das Projektobjekt delegiert sind.

Script Object- Gradle hat Skriptcode in Klassen aufgenommen, die die Skriptschnittstelle implementieren und dann ausführen. Dies bedeutet, dass alle von der Skriptschnittstelle deklarierten Eigenschaften und Methoden in Ihrem Skript verfügbar sind.

Die folgende Tabelle definiert die Liste von standard project properties. Alle diese Eigenschaften sind in Ihrem Build-Skript verfügbar.

Groovy Basics

Gradle-Build-Skripte verwenden die Groovy-API in voller Länge. Schauen Sie sich als Startup die folgenden Beispiele an.

Im folgenden Beispiel wird das Konvertieren einer Zeichenfolge in Großbuchstaben erläutert.

Kopieren Sie den unten angegebenen Code und speichern Sie ihn in build.gradle Datei.

task upper << {
   String expString = 'TUTORIALS point'
   println "Original: " + expString
   println "Upper case: " + expString.toUpperCase()
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert ist.

C:\> gradle –q upper

Ausgabe:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

Im folgenden Beispiel wird erläutert, wie der Wert eines impliziten Parameters ($ it) viermal gedruckt wird.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task count << {
   4.times { 
      print "$it " 
   }
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert ist.

$ gradle –q count

Ausgabe:

0 1 2 3

Die groovige Sprache bietet viele Funktionen, in denen einige wichtige Funktionen weiter unten erläutert werden.

Groovy JDK-Methoden

Groovy fügt den Standard-Java-Klassen viele nützliche Methoden hinzu. Beispielsweise implementiert die Iterable API von JDK eineeach() Methode, die über die Elemente der iterierbaren Schnittstelle iteriert.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task groovyJDK << {
   String myName = "Marc";
   myName.each() { 
      println "${it}" 
   };
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q groovyJDK

Ausgabe:

M
a
r
c

Immobilien-Accessoren

Sie können automatisch auf die entsprechenden Getter- und Setter-Methoden einer bestimmten Eigenschaft zugreifen, indem Sie deren Referenz angeben.

Das folgende Snippet definiert die Syntax der Getter- und Setter-Methoden einer Eigenschaft buildDir.

// Using a getter method
println project.buildDir
println getProject().getBuildDir()

// Using a setter method
project.buildDir = 'target'
getProject().setBuildDir('target')

Optionale Klammern bei Methodenaufrufen

Groovy enthält eine spezielle Funktion beim Aufrufen von Methoden, dh die Klammern sind für den Methodenaufruf optional. Diese Funktion gilt auch für Gradle-Skripte.

Schauen Sie sich die folgende Syntax an. Das definiert einen MethodenaufrufsystemProperty von test Objekt.

test.systemProperty 'some.prop', 'value'
test.systemProperty('some.prop', 'value')

Abschluss als letzter Parameter der Methode

Gradle DSL verwendet an vielen Stellen Verschlüsse. Wenn der letzte Parameter einer Methode ein Abschluss ist, können Sie den Abschluss nach dem Methodenaufruf platzieren.

Das folgende Snippet definiert die Syntaxen, die Closures als Parameter für die Methode repositories () verwenden.

repositories {
   println "in a closure"
}
repositories() { 
   println "in a closure" 
}
repositories({ println "in a closure" })

Standardimporte

Gradle fügt den Gradle-Skripten automatisch eine Reihe von Importanweisungen hinzu. Die folgende Liste zeigt Ihnen die Standardimportpakete für das Gradle-Skript.

import org.gradle.*
import org.gradle.api.*
import org.gradle.api.artifacts.*
import org.gradle.api.artifacts.cache.*
import org.gradle.api.artifacts.component.*
import org.gradle.api.artifacts.dsl.*
import org.gradle.api.artifacts.ivy.*
import org.gradle.api.artifacts.maven.*
import org.gradle.api.artifacts.query.*
import org.gradle.api.artifacts.repositories.*
import org.gradle.api.artifacts.result.*
import org.gradle.api.component.*
import org.gradle.api.credentials.*
import org.gradle.api.distribution.*
import org.gradle.api.distribution.plugins.*
import org.gradle.api.dsl.*
import org.gradle.api.execution.*
import org.gradle.api.file.*
import org.gradle.api.initialization.*
import org.gradle.api.initialization.dsl.*
import org.gradle.api.invocation.*
import org.gradle.api.java.archives.*
import org.gradle.api.logging.*
import org.gradle.api.plugins.*
import org.gradle.api.plugins.announce.*
import org.gradle.api.plugins.antlr.*
import org.gradle.api.plugins.buildcomparison.gradle.*
import org.gradle.api.plugins.jetty.*
import org.gradle.api.plugins.osgi.*
import org.gradle.api.plugins.quality.*
import org.gradle.api.plugins.scala.*
import org.gradle.api.plugins.sonar.*
import org.gradle.api.plugins.sonar.model.*
import org.gradle.api.publish.*
import org.gradle.api.publish.ivy.*
import org.gradle.api.publish.ivy.plugins.*
import org.gradle.api.publish.ivy.tasks.*
import org.gradle.api.publish.maven.*
import org.gradle.api.publish.maven.plugins.*
import org.gradle.api.publish.maven.tasks.*
import org.gradle.api.publish.plugins.*
import org.gradle.api.reporting.*
import org.gradle.api.reporting.components.*
import org.gradle.api.reporting.dependencies.*
import org.gradle.api.reporting.model.*
import org.gradle.api.reporting.plugins.*
import org.gradle.api.resources.*
import org.gradle.api.specs.*
import org.gradle.api.tasks.*
import org.gradle.api.tasks.ant.*
import org.gradle.api.tasks.application.*
import org.gradle.api.tasks.bundling.*
import org.gradle.api.tasks.compile.*
import org.gradle.api.tasks.diagnostics.*
import org.gradle.api.tasks.incremental.*
import org.gradle.api.tasks.javadoc.*
import org.gradle.api.tasks.scala.*
import org.gradle.api.tasks.testing.*
import org.gradle.api.tasks.testing.junit.*
import org.gradle.api.tasks.testing.testng.*
import org.gradle.api.tasks.util.*
import org.gradle.api.tasks.wrapper.*
import org.gradle.authentication.*
import org.gradle.authentication.http.*
import org.gradle.buildinit.plugins.*
import org.gradle.buildinit.tasks.*
import org.gradle.external.javadoc.*
import org.gradle.ide.cdt.*
import org.gradle.ide.cdt.tasks.*
import org.gradle.ide.visualstudio.*
import org.gradle.ide.visualstudio.plugins.*
import org.gradle.ide.visualstudio.tasks.*
import org.gradle.ivy.*
import org.gradle.jvm.*
import org.gradle.jvm.application.scripts.*
import org.gradle.jvm.application.tasks.*
import org.gradle.jvm.platform.*
import org.gradle.jvm.plugins.*
import org.gradle.jvm.tasks.*
import org.gradle.jvm.tasks.api.*
import org.gradle.jvm.test.*
import org.gradle.jvm.toolchain.*
import org.gradle.language.assembler.*
import org.gradle.language.assembler.plugins.*
import org.gradle.language.assembler.tasks.*
import org.gradle.language.base.*
import org.gradle.language.base.artifact.*
import org.gradle.language.base.plugins.*
import org.gradle.language.base.sources.*
import org.gradle.language.c.*
import org.gradle.language.c.plugins.*
import org.gradle.language.c.tasks.*
import org.gradle.language.coffeescript.*
import org.gradle.language.cpp.*
import org.gradle.language.cpp.plugins.*
import org.gradle.language.cpp.tasks.*
import org.gradle.language.java.*
import org.gradle.language.java.artifact.*
import org.gradle.language.java.plugins.*
import org.gradle.language.java.tasks.*
import org.gradle.language.javascript.*
import org.gradle.language.jvm.*
import org.gradle.language.jvm.plugins.*
import org.gradle.language.jvm.tasks.*
import org.gradle.language.nativeplatform.*
import org.gradle.language.nativeplatform.tasks.*
import org.gradle.language.objectivec.*
import org.gradle.language.objectivec.plugins.*
import org.gradle.language.objectivec.tasks.*
import org.gradle.language.objectivecpp.*
import org.gradle.language.objectivecpp.plugins.*
import org.gradle.language.objectivecpp.tasks.*
import org.gradle.language.rc.*
import org.gradle.language.rc.plugins.*
import org.gradle.language.rc.tasks.*
import org.gradle.language.routes.*
import org.gradle.language.scala.*
import org.gradle.language.scala.plugins.*
import org.gradle.language.scala.tasks.*
import org.gradle.language.scala.toolchain.*
import org.gradle.language.twirl.*
import org.gradle.maven.*
import org.gradle.model.*
import org.gradle.nativeplatform.*
import org.gradle.nativeplatform.platform.*
import org.gradle.nativeplatform.plugins.*
import org.gradle.nativeplatform.tasks.*
import org.gradle.nativeplatform.test.*
import org.gradle.nativeplatform.test.cunit.*
import org.gradle.nativeplatform.test.cunit.plugins.*
import org.gradle.nativeplatform.test.cunit.tasks.*
import org.gradle.nativeplatform.test.googletest.*
import org.gradle.nativeplatform.test.googletest.plugins.*
import org.gradle.nativeplatform.test.plugins.*
import org.gradle.nativeplatform.test.tasks.*
import org.gradle.nativeplatform.toolchain.*
import org.gradle.nativeplatform.toolchain.plugins.*
import org.gradle.platform.base.*
import org.gradle.platform.base.binary
import org.gradle.platform.base.component.*
import org.gradle.platform.base.plugins.*
import org.gradle.platform.base.test.*
import org.gradle.play.*
import org.gradle.play.distribution.*
import org.gradle.play.platform.*
import org.gradle.play.plugins.*
import org.gradle.play.tasks.*
import org.gradle.play.toolchain.*
import org.gradle.plugin.use.*
import org.gradle.plugins.ear.*
import org.gradle.plugins.ear.descriptor.*
import org.gradle.plugins.ide.api.*
import org.gradle.plugins.ide.eclipse.*
import org.gradle.plugins.ide.idea.*
import org.gradle.plugins.javascript.base.*
import org.gradle.plugins.javascript.coffeescript.*
import org.gradle.plugins.javascript.envjs.*
import org.gradle.plugins.javascript.envjs.browser.*
import org.gradle.plugins.javascript.envjs.http.*
import org.gradle.plugins.javascript.envjs.http.simple.*
import org.gradle.plugins.javascript.jshint.*
import org.gradle.plugins.javascript.rhino.*
import org.gradle.plugins.javascript.rhino.worker.*
import org.gradle.plugins.signing.*
import org.gradle.plugins.signing.signatory.*
import org.gradle.plugins.signing.signatory.pgp.*
import org.gradle.plugins.signing.type.*
import org.gradle.plugins.signing.type.pgp.*
import org.gradle.process.*
import org.gradle.sonar.runner.*
import org.gradle.sonar.runner.plugins.*
import org.gradle.sonar.runner.tasks.*
import org.gradle.testing.jacoco.plugins.*
import org.gradle.testing.jacoco.tasks.*
import org.gradle.testkit.runner.*
import org.gradle.util.*

Das Gradle-Build-Skript beschreibt ein oder mehrere Projekte. Jedes Projekt besteht aus verschiedenen Aufgaben. Eine Aufgabe ist eine Arbeit, die ein Build ausführt. Die Aufgabe besteht möglicherweise darin, einige Klassen zu kompilieren, Klassendateien in einem separaten Zielordner zu speichern, JAR zu erstellen, Javadoc zu generieren oder einige Erfolge in einem Repository zu veröffentlichen.

In diesem Kapitel wird erläutert, was eine Aufgabe ist und wie eine Aufgabe generiert und ausgeführt wird.

Aufgaben definieren

Aufgabe ist ein Schlüsselwort, mit dem eine Aufgabe in ein Erstellungsskript definiert wird. Schauen Sie sich das folgende Beispiel an, das eine Aufgabe mit dem Namen darstellthello das druckt tutorialspoint. Kopieren Sie das folgende Skript und speichern Sie es in einer Datei mit dem Namenbuild.gradle. Dieses Build-Skript definiert einen Aufgabennamen Hallo, mit dem die Tutorialspoint-Zeichenfolge gedruckt wird.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das obige Skript aus. Sie sollten dies dort ausführen, wo die Datei build.gradle gespeichert ist.

C:\> gradle –q hello

Ausgabe:

tutorialspoint

Sie können diese Hallo-Aufgabe vereinfachen, indem Sie eine Verknüpfung angeben (die ein Symbol darstellt <<) zum doLastErklärung. Wenn Sie diese Verknüpfung zur obigen Aufgabe hinzufügenhello Es sieht wie im folgenden Skript aus.

task hello << {
   println 'tutorialspoint'
}

Sie können das obige Skript mit ausführen gradle –q hello Befehl.

Hier sind einige Variationen beim Definieren einer Aufgabe. Schauen Sie sich diese an. Das folgende Beispiel definiert eine Aufgabehello.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task (hello) << {
   println "tutorialspoint"
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q hello

Ausgabe:

tutorialspoint

Sie können auch Zeichenfolgen für die Aufgabennamen verwenden. Schauen Sie sich das gleiche Hallo-Beispiel an. Hier werden wir String als Aufgabe verwenden.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task('hello') << {
   println "tutorialspoint"
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q hello

Ausgabe:

tutorialspoint

Sie können auch eine alternative Syntax zum Definieren einer Aufgabe verwenden. Das ist die Methode create () zum Definieren einer Aufgabe. Schauen Sie sich das unten stehende Hallo-Beispiel an.

Kopieren Sie den unten angegebenen Code und speichern Sie ihn in build.gradle Datei.

tasks.create(name: 'hello') << {
   println "tutorialspoint"
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q hello

Ausgabe:

tutorialspoint

Aufgaben suchen

Wenn Sie Aufgaben suchen möchten, die Sie in der Build-Datei definiert haben, müssen Sie die entsprechenden Standard-Projekteigenschaften verwenden. Das bedeutet, dass jede Aufgabe als Eigenschaft des Projekts verfügbar ist und der Aufgabenname als Eigenschaftsname verwendet wird.

Sehen Sie sich den folgenden Code an, der auf Aufgaben als Eigenschaften zugreift.

Kopieren Sie den unten angegebenen Code und speichern Sie ihn in build.gradle Datei.

task hello

println hello.name
println project.hello.name

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q hello

Ausgabe:

hello
hello

Sie können alle Eigenschaften auch über die Aufgabensammlung verwenden.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task hello

println tasks.hello.name
println tasks['hello'].name

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q hello

Ausgabe:

hello
hello

Sie können auch über die Aufgaben auf den Pfad der Aufgabe zugreifen. Dazu können Sie die Methode getByPath () mit einem Aufgabennamen, einem relativen Pfad oder einem absoluten Pfad aufrufen.

Kopieren Sie den unten angegebenen Code und speichern Sie ihn in build.gradle Datei.

project(':projectA') {
   task hello
}
task hello

println tasks.getByPath('hello').path
println tasks.getByPath(':hello').path
println tasks.getByPath('projectA:hello').path
println tasks.getByPath(':projectA:hello').path

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo die Datei build.gradle gespeichert wird.

C:\> gradle –q hello

Ausgabe:

:hello
:hello
:projectA:hello
:projectA:hello

Hinzufügen von Abhängigkeiten zu Aufgaben

Sie können festlegen, dass eine Aufgabe von einer anderen Aufgabe abhängig ist. Wenn also eine Aufgabe erledigt ist, wird nur eine andere Aufgabe gestartet. Jede Aufgabe wird mit dem Aufgabennamen unterschieden. Die Sammlung von Aufgabennamen wird durch ihre Aufgabensammlung bezeichnet. Um auf eine Aufgabe in einem anderen Projekt zu verweisen, sollten Sie den Pfad des Projekts als Präfix für den jeweiligen Aufgabennamen verwenden.

Das folgende Beispiel fügt eine Abhängigkeit von taskX zu taskY hinzu.

Kopieren Sie den unten angegebenen Code und speichern Sie ihn in build.gradleDatei. Schauen Sie sich den folgenden Code an.

task taskX << {
   println 'taskX'
}
task taskY(dependsOn: 'taskX') << {
   println "taskY"
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo diebuild.gradle Dateispeicher.

C:\> gradle –q taskY

Ausgabe:

taskX
taskY

Im obigen Beispiel wird die Abhängigkeit von der Aufgabe mithilfe ihrer Namen hinzugefügt. Es gibt eine andere Möglichkeit, eine Aufgabenabhängigkeit zu erreichen, indem Sie die Abhängigkeit mithilfe eines Aufgabenobjekts definieren.

Nehmen wir das gleiche Beispiel für taskY, das von taskX abhängig ist, aber wir verwenden Taskobjekte anstelle von Taskreferenznamen.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task taskY << {
   println 'taskY'
}
task taskX << {
   println 'taskX'
}
taskY.dependsOn taskX

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Sie sollten dies dort ausführen, wo die Datei build.gradle gespeichert ist.

C:\> gradle –q taskY

Ausgabe:

taskX
taskY

Im obigen Beispiel wird die Abhängigkeit von der Aufgabe mithilfe ihrer Namen hinzugefügt. Es gibt eine andere Möglichkeit, eine Aufgabenabhängigkeit zu erreichen, bei der die Abhängigkeit mithilfe eines Aufgabenobjekts definiert wird.

Hier nehmen wir das gleiche Beispiel, dass taskY von taskX abhängt, aber wir verwenden Taskobjekte anstelle von Taskreferenznamen. Schau es dir an.

Kopieren Sie den unten angegebenen Code und speichern Sie ihn in build.gradleDatei. Schauen Sie sich den folgenden Code an.

task taskX << {
   println 'taskX'
}
taskX.dependsOn {
   tasks.findAll { 
      task → task.name.startsWith('lib') 
   }
}
task lib1 << {
   println 'lib1'
}
task lib2 << {
   println 'lib2'
}
task notALib << {
   println 'notALib'
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Es führt das oben angegebene Skript aus. Sie sollten dies ausführen, wo diebuild.gradle Dateispeicher.

C:\> gradle –q taskX

Ausgabe:

lib1
lib2
taskX

Hinzufügen einer Beschreibung zu einer Aufgabe

Sie können Ihrer Aufgabe eine Beschreibung hinzufügen. Diese Beschreibung wird bei der Ausführung angezeigtGradle tasks. Dies ist mit dem Schlüsselwort description möglich.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradleDatei. Schauen Sie sich den folgenden Code an.

task copy(type: Copy) {
   description 'Copies the resource directory to the target directory.'
   from 'resources'
   into 'target'
   include('**/*.txt', '**/*.xml', '**/*.properties')
   println("description applied")
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Sie sollten dies dort ausführen, wo die Datei build.gradle gespeichert ist.

C:\> gradle –q copy

Wenn der Befehl erfolgreich ausgeführt wird, erhalten Sie die folgende Ausgabe.

description applied

Aufgaben überspringen

Das Überspringen von Aufgaben kann durch Übergeben eines Prädikatabschlusses erfolgen. Dies ist nur möglich, wenn die Methode einer Aufgabe oder ein Abschluss aStopExecutionException bevor die eigentliche Arbeit einer Aufgabe ausgeführt wird.

Kopieren Sie den folgenden Code und speichern Sie ihn in build.gradle Datei.

task eclipse << {
   println 'Hello Eclipse'
}

// #1st approach - closure returning true, if the task should be executed, false if not.
eclipse.onlyIf {
   project.hasProperty('usingEclipse')
}

// #2nd approach - alternatively throw an StopExecutionException() like this
eclipse.doFirst {
   if(!usingEclipse) {
      throw new StopExecutionException()
   }
}

Führen Sie den folgenden Befehl an der Eingabeaufforderung aus. Sie sollten dies dort ausführen, wo die Datei build.gradle gespeichert ist.

C:\> gradle –q eclipse

Aufgabenstruktur

Gradle hat verschiedene Phasen bei der Arbeit mit Aufgaben. Zunächst gibt es eine Konfigurationsphase, in der der Code ausgeführt wird, der direkt beim Schließen einer Aufgabe angegeben wird. Der Konfigurationsblock wird für jede verfügbare Aufgabe ausgeführt und nicht nur für die Aufgaben, die später tatsächlich ausgeführt werden.

Nach der Konfigurationsphase führt die Ausführungsphase den Code innerhalb der aus doFirst oder doLast Schließung der Aufgaben, die tatsächlich ausgeführt werden.

Das Gradle-Erstellungsskript definiert einen Prozess zum Erstellen von Projekten. Jedes Projekt enthält einige Abhängigkeiten und einige Veröffentlichungen. Abhängigkeiten sind die Dinge, die das Erstellen Ihres Projekts unterstützen, z. B. die erforderliche JAR-Datei aus anderen Projekten und externe JARs wie JDBC-JAR oder Eh-Cache-JAR im Klassenpfad. Veröffentlichungen sind die Ergebnisse des Projekts, z. B. Testklassendateien und Builddateien, z. B. Kriegsdateien.

Alle fast alle Projekte sind nicht in sich geschlossen. Sie benötigen Dateien, die von anderen Projekten erstellt wurden, um die Quelldateien zu kompilieren und zu testen. Um beispielsweise den Ruhezustand im Projekt verwenden zu können, müssen Sie einige Ruhezustand-JARs in den Klassenpfad aufnehmen. Gradle verwendet ein spezielles Skript, um die Abhängigkeiten zu definieren, die heruntergeladen werden müssen.

Gradle kümmert sich darum, die Ergebnisse irgendwo zu erstellen und zu veröffentlichen. Das Veröffentlichen basiert auf der von Ihnen definierten Aufgabe. Möglicherweise möchten Sie die Dateien in ein lokales Verzeichnis kopieren oder in ein entferntes Maven- oder Lvy-Repository hochladen, oder Sie verwenden die Dateien aus einem anderen Projekt im selben Multiprojekt-Build. Wir können den Prozess der Veröffentlichung einer Aufgabe als Veröffentlichung bezeichnen.

Abhängigkeiten erklären

Die Abhängigkeitskonfiguration ist nichts anderes als die Definition einer Reihe von Abhängigkeiten. Mit dieser Funktion können Sie externe Abhängigkeiten deklarieren, die Sie aus dem Web herunterladen möchten. Dies definiert verschiedene Steher wie folgt.

apply plugin: 'java'

repositories {
   mavenCentral()
}

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
   testCompile group: 'junit', name: 'junit', version: '4.+'
}

Abhängigkeitskonfigurationen

Die Abhängigkeitskonfiguration ist nichts anderes als die Definition einer Reihe von Abhängigkeiten. Mit dieser Funktion können Sie externe Abhängigkeiten deklarieren, die Sie aus dem Internet herunterladen möchten. Dies definiert die folgenden verschiedenen Standardkonfigurationen.

• Compile - Die Abhängigkeiten, die zum Kompilieren der Produktionsquelle des Projekts erforderlich sind.

• Runtime- Die Abhängigkeiten, die die Produktionsklassen zur Laufzeit benötigen. Enthält standardmäßig auch die Abhängigkeiten zur Kompilierungszeit.

• Test Compile- Die Abhängigkeiten, die zum Kompilieren der Testquelle des Projekts erforderlich sind. Standardmäßig enthält es kompilierte Produktionsklassen und die Abhängigkeiten zur Kompilierungszeit.

• Test Runtime- Die zum Ausführen der Tests erforderlichen Abhängigkeiten. Standardmäßig enthält es Laufzeit- und Testkompilierungsabhängigkeiten.

Externe Abhängigkeiten

Externe Abhängigkeiten gehören zu den Abhängigkeiten. Dies ist eine Abhängigkeit von einigen Dateien, die außerhalb des aktuellen Builds erstellt und in einem Repository wie Maven Central oder einem Unternehmens-Maven- oder Lvy-Repository oder einem Verzeichnis des lokalen Dateisystems gespeichert wurden.

Das folgende Codeausschnitt dient zum Definieren der externen Abhängigkeit. Verwenden Sie diesen Code inbuild.gradle Datei.

dependencies {
   compile group: 'org.hibernate', name: 'hibernate-core', version: '3.6.7.Final'
}

Eine externe Abhängigkeit deklariert externe Abhängigkeiten und das Verknüpfungsformular sieht wie folgt aus: "Gruppe: Name: Version".

Repositories

Beim Hinzufügen externer Abhängigkeiten. Gradle sucht sie in einem Repository. Ein Repository ist nur eine Sammlung von Dateien, die nach Gruppe, Name und Version geordnet sind. Standardmäßig definiert Gradle keine Repositorys. Wir müssen mindestens ein Repository explizit definieren. Das folgende Codefragment definiert, wie das Maven-Repository definiert wird. Verwenden Sie diesen Code inbuild.gradle Datei.

repositories {
   mavenCentral()
}

Der folgende Code definiert Remote Maven. Verwenden Sie diesen Code inbuild.gradle Datei.

repositories {
   maven {
      url "http://repo.mycompany.com/maven2"
   }
}

Artefakte veröffentlichen

Abhängigkeitskonfigurationen werden auch zum Veröffentlichen von Dateien verwendet. Diese veröffentlichten Dateien werden als Artefakte bezeichnet. Normalerweise verwenden wir Plug-Ins, um Artefakte zu definieren. Sie müssen Gradle jedoch mitteilen, wo die Artefakte veröffentlicht werden sollen. Sie können dies erreichen, indem Sie Repositorys an die Aufgabe zum Hochladen von Archiven anhängen. Sehen Sie sich die folgende Syntax zum Veröffentlichen des Maven-Repositorys an. Während der Ausführung generiert Gradle eine Pom.xml gemäß den Projektanforderungen und lädt sie hoch. Verwenden Sie diesen Code inbuild.gradle Datei.

apply plugin: 'maven'

uploadArchives {
   repositories {
      mavenDeployer {
         repository(url: "file://localhost/tmp/myRepo/")
      }
   }
}

Das Plugin ist nichts anderes als eine Reihe von Aufgaben. Fast alle nützlichen Aufgaben wie das Kompilieren von Aufgaben, das Festlegen von Domänenobjekten, das Einrichten von Quelldateien usw. werden von Plugins ausgeführt. Das Anwenden eines Plugins auf ein Projekt bedeutet, dass das Plugin die Funktionen des Projekts erweitern kann. Die Plugins können folgende Aufgaben ausführen:

• Erweitern Sie das grundlegende Gradle-Modell (z. B. fügen Sie neue DSL-Elemente hinzu, die konfiguriert werden können).
• Konfigurieren Sie das Projekt entsprechend den Konvertierungen (z. B. neue Aufgaben hinzufügen oder sinnvolle Standardeinstellungen konfigurieren).
• Wenden Sie eine bestimmte Konfiguration an (z. B. organisatorische Repositorys hinzufügen oder Standards durchsetzen).

Arten von Plugins

In Gradle gibt es zwei Arten von Plugins: Skript-Plugins und Binär-Plugins. Skript-Plugins sind ein zusätzliches Build-Skript, das einen deklarativen Ansatz für die Bearbeitung des Builds bietet. Dies wird normalerweise in einem Build verwendet. Binäre Plugins sind die Klassen, die die Plugin-Schnittstelle implementieren und einen programmatischen Ansatz zur Manipulation des Builds verfolgen. Binäre Plugins können sich in einem Build-Skript, in der Projekthierarchie oder extern in einer Plugin-JAR befinden.

Plugins anwenden

Project.apply()Die API-Methode wird verwendet, um das jeweilige Plugin anzuwenden. Sie können dasselbe Plugin mehrmals verwenden. Es gibt zwei Arten von Plugins: das Skript-Plugin und das Binär-Plugin.

Skript-Plugins

Skript-Plugins können über ein Skript im lokalen Dateisystem oder an einem Remotestandort angewendet werden. Dateisystemspeicherorte sind relativ zum Projektverzeichnis, während Remoteskriptspeicherorte die HTTP-URL angeben. Schauen Sie sich das folgende Code-Snippet an. Es wird verwendet, um die anzuwendenother.gradlePlugin zum Build-Skript. Verwenden Sie diesen Code inbuild.gradle Datei.

apply from: 'other.gradle'

Binäre Plugins

Jedes Plugin wird durch die Plugin-ID identifiziert. Einige Kern-Plugins verwenden Kurznamen, um es anzuwenden, und einige Community-Plugins verwenden einen vollständig qualifizierten Namen für die Plugin-ID. Einige Zeit erlaubt es, die Klasse des Plugins anzugeben.

Schauen Sie sich das folgende Code-Snippet an. Es zeigt, wie Sie das Java-Plugin mithilfe seines Typs anwenden. Verwenden Sie diesen Code inbuild.gradle Datei.

apply plugin: JavaPlugin

Sehen Sie sich den folgenden Code zum Anwenden des Core-Plugins mit Kurznamen an. Verwenden Sie diesen Code inbuild.gradle Datei.

plugins {
   id 'java'
}

Sehen Sie sich den folgenden Code zum Anwenden des Community-Plugins mit Kurznamen an. Verwenden Sie diesen Code inbuild.gradle Datei.

plugins {
   id "com.jfrog.bintray" version "0.4.1"
}

Benutzerdefinierte Plugins schreiben

Beim Erstellen eines benutzerdefinierten Plugins müssen Sie eine Implementierung des Plugins schreiben. Gradle instanziiert das Plugin und ruft die Plugin-Instanz mit der Plugin.apply () -Methode auf. Das folgende Beispiel enthält ein Begrüßungs-Plugin, das dem Projekt eine Hallo-Aufgabe hinzufügt. Schauen Sie sich den folgenden Code an. Verwenden Sie diesen Code inbuild.gradle Datei.

apply plugin: GreetingPlugin

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.task('hello') << {
         println "Hello from the GreetingPlugin"
      }
   }
}

Verwenden Sie den folgenden Code, um das obige Skript auszuführen.

C:\> gradle -q hello

Ausgabe:

Hello from the GreetingPlugin

Eingaben vom Build abrufen

Die meisten Plugins benötigen die Konfigurationsunterstützung aus dem Build-Skript. Dem Gradle-Projekt ist ein ExtensionContainer-Objekt zugeordnet, mit dessen Hilfe alle Einstellungen und Eigenschaften verfolgt werden können, die an Plugins übergeben werden.

Fügen wir dem Projekt ein einfaches Erweiterungsobjekt hinzu. Hier fügen wir dem Projekt ein Begrüßungserweiterungsobjekt hinzu, mit dem Sie die Begrüßung konfigurieren können. Verwenden Sie diesen Code inbuild.gradle Datei.

apply plugin: GreetingPlugin

greeting.message = 'Hi from Gradle'

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      // Add the 'greeting' extension object
      project.extensions.create("greeting", GreetingPluginExtension)
		
      // Add a task that uses the configuration
      project.task('hello') << {
         println project.greeting.message
      }
   }
}

class GreetingPluginExtension {
   def String message = 'Hello from GreetingPlugin'
}

Verwenden Sie den folgenden Code, um das obige Skript auszuführen.

C:\> gradle -q hello

Ausgabe:

Hi from Gradle

In diesem Beispiel ist GreetingPlugin ein einfaches altes Groovy-Objekt mit einem Feld namens message. Das Erweiterungsobjekt wird der Plugin-Liste mit dem Namen Begrüßung hinzugefügt. Dieses Objekt wird dann als Projekteigenschaft mit demselben Namen wie das Erweiterungsobjekt verfügbar.

Gradle fügt für jedes Erweiterungsobjekt einen Konfigurationsabschluss hinzu, sodass Sie die Einstellungen zusammenfassen können. Schauen Sie sich den folgenden Code an. Verwenden Sie diesen Code inbuild.gradle Datei.

apply plugin: GreetingPlugin

greeting {
   message = 'Hi'
   greeter = 'Gradle'
}

class GreetingPlugin implements Plugin<Project> {
   void apply(Project project) {
      project.extensions.create("greeting", GreetingPluginExtension)
		
      project.task('hello') << {
         println "${project.greeting.message} from ${project.greeting.greeter}"
      }
   }
}

class GreetingPluginExtension {
   String message
   String greeter
}

Verwenden Sie den folgenden Code, um das obige Skript auszuführen.

C:\> gradle -q hello

Ausgabe:

Hello from Gradle

Standard Gradle Plugins

Es gibt verschiedene Plugins, die in der Gradle-Distribution enthalten sind.

Sprach-Plugins

Diese Plugins bieten Unterstützung für verschiedene Sprachen, die in der JVM kompiliert und ausgeführt werden können.

Inkubation von Sprach-Plugins

Diese Plugins bieten Unterstützung für verschiedene Sprachen.

Gradle bietet eine Befehlszeile zum Ausführen des Build-Skripts. Es kann mehr als eine Aufgabe gleichzeitig ausführen. In diesem Kapitel wird erläutert, wie Sie mehrere Aufgaben mit unterschiedlichen Optionen ausführen.

Mehrere Aufgaben ausführen

Sie können mehrere Aufgaben aus einer einzigen Build-Datei ausführen. Gradle kann diese Build-Datei mit verarbeitengradle command. Dieser Befehl kompiliert jede Aufgabe in der Reihenfolge, in der sie aufgelistet sind, und führt jede Aufgabe zusammen mit den Abhängigkeiten mit verschiedenen Optionen aus.

Example- Es gibt vier Aufgaben - Aufgabe1, Aufgabe2, Aufgabe3 und Aufgabe4. Aufgabe3 und Aufgabe4 hängen von Aufgabe 1 und Aufgabe 2 ab. Schauen Sie sich das folgende Diagramm an.

In den obigen 4 Aufgaben sind voneinander abhängig, dargestellt durch ein Pfeilsymbol. Schauen Sie sich den folgenden Code an. Kopieren kann es einfügenbuild.gradle Datei.

task task1 << {
   println 'compiling source'
}

task task2(dependsOn: task1) << {
   println 'compiling unit tests'
}

task task3(dependsOn: [task1, task2]) << {
   println 'running unit tests'
}

task task4(dependsOn: [task1, task3]) << {
   println 'building the distribution'
}

Sie können den folgenden Code zum Kompilieren und Ausführen der obigen Aufgabe verwenden.

C:\> gradle task4 test

Ausgabe:

:task1
compiling source
:task2
compiling unit tests
:task3
running unit tests
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Aufgaben ausschließen

Während Sie eine Aufgabe von der Ausführung ausschließen, können Sie die Option –x zusammen mit dem Befehl gradle verwenden und den Namen der Aufgabe angeben, die Sie ausschließen möchten.

Verwenden Sie den folgenden Befehl, um task4 vom obigen Skript auszuschließen.

C:\> gradle task4 -x test

Ausgabe:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Fortsetzung des Builds bei Auftreten eines Fehlers

Gradle bricht die Ausführung ab und schlägt den Build fehl, sobald eine Aufgabe fehlschlägt. Sie können die Ausführung auch dann fortsetzen, wenn ein Fehler auftritt. Dazu müssen Sie die Option –continue mit dem Befehl gradle verwenden. Es behandelt jede Aufgabe separat zusammen mit ihren Abhängigkeiten. Der wichtigste Punkt ist, dass jeder aufgetretene Fehler abgefangen und am Ende der Ausführung des Builds gemeldet wird. Angenommen, wenn eine Aufgabe fehlschlägt, werden auch die abhängigen nachfolgenden Aufgaben nicht ausgeführt.

Auswählen des auszuführenden Builds

Wenn Sie den Befehl gradle ausführen, wird im aktuellen Verzeichnis nach einer Build-Datei gesucht. Mit der Option –b können Sie eine bestimmte Build-Datei zusammen mit dem absoluten Pfad auswählen. Das folgende Beispiel wählt ein Projekt ausmyproject.gradle Datei, die sich in der befindet subdir/ Schau es dir an.

task hello << {
   println "using build file '$buildFile.name' in '$buildFile.parentFile.name'."
}

Mit dem folgenden Befehl können Sie das obige Skript ausführen.

C:\> gradle -q -b subdir/myproject.gradle hello

Ausgabe:

using build file 'myproject.gradle' in 'subdir'.

Build-Informationen abrufen

Gradle bietet mehrere integrierte Aufgaben zum Abrufen der Informationsdetails zur Aufgabe und zum Projekt. Dies kann hilfreich sein, um die Struktur und die Abhängigkeiten Ihres Builds zu verstehen und Probleme zu debuggen. Sie können das Projektbericht-Plugin verwenden, um Ihrem Projekt Aufgaben hinzuzufügen, die diese Berichte generieren.

Projekte auflisten

Mit können Sie die Projekthierarchie des ausgewählten Projekts und seiner Unterprojekte auflisten gradle –q projectsBefehl. In diesem Beispiel verwenden Sie den folgenden Befehl, um alle Projekte in der Build-Datei aufzulisten.

C:\> gradle -q projects

Ausgabe:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

Der Bericht zeigt die Beschreibung jedes Projekts, falls angegeben. Mit dem folgenden Befehl können Sie die Beschreibung angeben. Fügen Sie es in diebuild.gradle Datei.

description = 'The shared API for the application'

Aufgaben auflisten

Mit dem folgenden Befehl können Sie alle Aufgaben auflisten, die zu mehreren Projekten gehören.

C:\> gradle -q tasks

Ausgabe:

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

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
dists - Builds the distribution
libs - Builds the JAR

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
components - Displays the components produced by root project 'projectReports'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
properties - Displays the properties of root project 'projectReports'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).

To see all tasks and more detail, run gradle tasks --all

To see more detail about a task, run gradle help --task <task>

Mit dem folgenden Befehl können Sie die Informationen aller Aufgaben anzeigen.

C:\> gradle -q tasks --all

Ausgabe:

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

Default tasks: dists

Build tasks
-----------
clean - Deletes the build directory (build)
api:clean - Deletes the build directory (build)
webapp:clean - Deletes the build directory (build)
dists - Builds the distribution [api:libs, webapp:libs]
   docs - Builds the documentation
api:libs - Builds the JAR
   api:compile - Compiles the source files
webapp:libs - Builds the JAR [api:libs]
   webapp:compile - Compiles the source files

Build Setup tasks
-----------------
init - Initializes a new Gradle build. [incubating]
wrapper - Generates Gradle wrapper files. [incubating]

Help tasks
----------
buildEnvironment - Displays all buildscript dependencies declared in root project 'projectReports'.
api:buildEnvironment - Displays all buildscript dependencies declared in project ':api'.
webapp:buildEnvironment - Displays all buildscript dependencies declared in project ':webapp'.
components - Displays the components produced by root project 'projectReports'. [incubating]
api:components - Displays the components produced by project ':api'. [incubating]
webapp:components - Displays the components produced by project ':webapp'. [incubating]
dependencies - Displays all dependencies declared in root project 'projectReports'.
api:dependencies - Displays all dependencies declared in project ':api'.
webapp:dependencies - Displays all dependencies declared in project ':webapp'.
dependencyInsight - Displays the insight into a specific dependency in root project 'projectReports'.
api:dependencyInsight - Displays the insight into a specific dependency in project ':api'.
webapp:dependencyInsight - Displays the insight into a specific dependency in project ':webapp'.
help - Displays a help message.
api:help - Displays a help message.
webapp:help - Displays a help message.
model - Displays the configuration model of root project 'projectReports'. [incubating]
api:model - Displays the configuration model of project ':api'. [incubating]
webapp:model - Displays the configuration model of project ':webapp'. [incubating]
projects - Displays the sub-projects of root project 'projectReports'.
api:projects - Displays the sub-projects of project ':api'.
webapp:projects - Displays the sub-projects of project ':webapp'.
properties - Displays the properties of root project 'projectReports'.
api:properties - Displays the properties of project ':api'.
webapp:properties - Displays the properties of project ':webapp'.
tasks - Displays the tasks runnable from root project 'projectReports' 
   (some of the displayed tasks may belong to subprojects).
api:tasks - Displays the tasks runnable from project ':api'.
webapp:tasks - Displays the tasks runnable from project ':webapp'.

Hier finden Sie eine Liste von Befehlen in einer Tabellenbeschreibung mit verschiedenen Optionen.

In diesem Kapitel wird erläutert, wie Sie ein Java-Projekt mithilfe der Gradle-Erstellungsdatei erstellen.

Zunächst müssen wir dem Build-Skript ein Java-Plugin hinzufügen, da es Aufgaben zum Kompilieren von Java-Quellcode, Ausführen von Komponententests, Erstellen von Javadoc und Erstellen einer JAR-Datei enthält. Verwenden Sie die folgende Zeile inbuild.gradle Datei.

apply plugin: 'java'

Java-Standardprojektlayout

Wann immer Sie Ihrem Build ein Plugin hinzufügen, setzt es ein bestimmtes Setup Ihres Java-Projekts voraus (ähnlich wie bei Maven). Schauen Sie sich die folgende Verzeichnisstruktur an.

• src / main / java enthält den Java-Quellcode
• src / test / java enthält die Java-Tests

Wenn Sie diesem Setup folgen, reicht die folgende Build-Datei aus, um ein Java-Projekt zu kompilieren, zu testen und zu bündeln.

Geben Sie zum Starten des Builds den folgenden Befehl in die Befehlszeile ein.

C:\> gradle build

SourceSetskann verwendet werden, um eine andere Projektstruktur anzugeben. Zum Beispiel werden die Quellen in a gespeichertsrc Ordner statt in src/main/java. Schauen Sie sich die folgende Verzeichnisstruktur an.

apply plugin: 'java'
sourceSets {
   main {
      java {
         srcDir 'src'
      }
   }
	
   test {
      java {
         srcDir 'test'
      }
   }
}

Init Task Execution

Gradle unterstützt noch nicht mehrere Projektvorlagen. Aber es bietet eineinitAufgabe zum Erstellen der Struktur eines neuen Gradle-Projekts. Ohne zusätzliche Parameter erstellt diese Aufgabe ein Gradle-Projekt, das die Gradle-Wrapper-Dateien enthält. A.build.gradle und settings.gradle Datei.

Beim Hinzufügen der --type Parameter mit java-library Als Wert wird eine Java-Projektstruktur erstellt und die build.gradleDatei enthält eine bestimmte Java-Vorlage mit Junit. Schauen Sie sich den folgenden Code für anbuild.gradle Datei.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

Im Abschnitt Repositorys wird definiert, wo die Abhängigkeiten zu finden sind. Jcenterdient zum Auflösen Ihrer Abhängigkeiten. Der Abschnitt "Abhängigkeiten" enthält Informationen zu externen Abhängigkeiten.

Angeben der Java-Version

Normalerweise verfügt ein Java-Projekt über eine Version und eine Ziel-JRE, auf der es kompiliert wird. Dasversion und sourceCompatibility Eigenschaft kann in der gesetzt werden build.gradle Datei.

version = 0.1.0
sourceCompatibility = 1.8

Wenn das Artefakt eine ausführbare Java-Anwendung ist, wird die MANIFEST.MF Datei muss die Klasse mit der Hauptmethode kennen.

apply plugin: 'java'

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Example:

Erstellen Sie eine Verzeichnisstruktur wie im folgenden Screenshot gezeigt.

Kopieren Sie den unten angegebenen Java-Code in die Datei App.java und speichern Sie ihn in consumerbanking\src\main\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App {
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Kopieren Sie den unten angegebenen Java-Code in die Datei AppTset.java und speichern Sie ihn in consumerbanking\src\test\java\com\bank directory.

package com.bank;

/**
* Hello world!
*
*/

public class App{
   public static void main( String[] args ){
      System.out.println( "Hello World!" );
   }
}

Kopieren Sie den unten angegebenen Code in die Datei build.gradle und platzieren Sie ihn in consumerbanking\ Verzeichnis.

apply plugin: 'java'

repositories {
   jcenter()
}

dependencies {
   compile 'org.slf4j:slf4j-api:1.7.12'
   testCompile 'junit:junit:4.12'
}

jar {
   manifest {
      attributes 'Main-Class': 'com.example.main.Application'
   }
}

Verwenden Sie die folgenden Befehle, um das obige Skript zu kompilieren und auszuführen.

consumerbanking\> gradle tasks
consumerbanking\> gradle assemble
consumerbanking\> gradle build

Überprüfen Sie alle Klassendateien in den jeweiligen Verzeichnissen und überprüfen Sie consumerbanking\build\lib Ordner für consumerbanking.jar Datei.

In diesem Kapitel wird erläutert, wie Sie ein Groovy-Projekt mit kompilieren und ausführen build.gradle Datei.

Das Groovy Plug-In

Das Groovy-Plug-In für Gradle erweitert das Java-Plug-In und bietet Aufgaben für Groovy-Programme. Sie können die folgende Zeile zum Anwenden des groovigen Plugins verwenden.

apply plugin: 'groovy'

Die vollständige Build-Skriptdatei lautet wie folgt. Kopieren Sie den folgenden Code inbuild.gradle Datei.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

dependencies {
   compile 'org.codehaus.groovy:groovy-all:2.4.5'
   testCompile 'junit:junit:4.12'
}

Mit dem folgenden Befehl können Sie das Build-Skript ausführen.

gradle build

Standardprojektlayout von Groovy-Projekten

Das Groovy-Plugin setzt ein bestimmtes Setup Ihres Groovy-Projekts voraus.

• src / main / groovy enthält den Groovy-Quellcode
• src / test / groovy enthält die Groovy-Tests
• src / main / java enthält den Java-Quellcode
• src / test / java enthält die Java-Tests

Überprüfen Sie das entsprechende Verzeichnis wo build.gradle Dateispeicherorte für den Build-Ordner.

Die Testaufgabe erkennt automatisch alle Komponententests im Testquellensatz und führt sie aus. Es wird auch ein Bericht erstellt, sobald die Testausführung abgeschlossen ist. JUnit und TestNG sind die unterstützten APIs.

Die Testaufgabe bietet a Test.getDebug()Methode, die so eingestellt werden kann, dass die JVM auf einen Debugger wartet. Bevor Sie mit der Ausführung fortfahren, wird der Debugger-Beitrag auf gesetzt5005.

Testerkennung

Das Test TaskErkennt, welche Klassen Testklassen sind, indem die kompilierten Testklassen überprüft werden. Standardmäßig werden alle .class-Dateien gescannt. Sie können benutzerdefinierte Einschlüsse / Ausschlüsse festlegen. Es werden nur diese Klassen gescannt. Abhängig vom verwendeten Testframework (JUnit / TestNG) verwendet die Testklassenerkennung unterschiedliche Kriterien.

Bei Verwendung von JUnit suchen wir nach JUnit 3- und 4-Testklassen. Wenn eines der folgenden Kriterien übereinstimmt, wird die Klasse als JUnit-Testklasse betrachtet.

• Eine Klasse oder eine Superklasse erweitert TestCase oder GroovyTestCase
• Klasse oder eine Superklasse wird mit @RunWith kommentiert
• Klasse oder eine Superklasse enthalten eine mit @Test kommentierte Methode
• Bei Verwendung von TestNG suchen wir nach Methoden, die mit @Test kommentiert sind

Note- Die abstrakten Klassen werden nicht ausgeführt. Gradle scannt den Vererbungsbaum auch in JAR-Dateien im Testklassenpfad.

Wenn Sie die Testklassenerkennung nicht verwenden möchten, können Sie sie durch Festlegen deaktivieren scanForTestClasses zu falsch.

Testgruppierung

JUnit und TestNG ermöglichen ausgefeilte Gruppierungen von Testmethoden. Für die Gruppierung führt JUnit Testklassen und Methoden JUnit 4.8 das Konzept der Kategorien ein. Die Testaufgabe ermöglicht die Angabe der JUnit-Kategorien, die Sie ein- und ausschließen möchten.

Sie können das folgende Codefragment in der Datei build.gradle verwenden, um Testmethoden zu gruppieren.

test {
   useJUnit {
      includeCategories 'org.gradle.junit.CategoryA'
      excludeCategories 'org.gradle.junit.CategoryB'
   }
}

Einschließen und Ausschließen bestimmter Tests

Das Test Klasse hat eine include und excludeMethode. Mit diesen Methoden kann festgelegt werden, welche Tests tatsächlich ausgeführt werden sollen.

Führen Sie nur die enthaltenen Tests aus -

test {
   include '**my.package.name/*'
}

Ausgeschlossene Tests überspringen -

test {
   exclude '**my.package.name/*'
}

Die Probe build.gradle Datei wie unten gezeigt zeigt es verschiedene Konfigurationsoptionen.

apply plugin: 'java' // adds 'test' task

test {
   // enable TestNG support (default is JUnit)
   useTestNG()

   // set a system property for the test JVM(s)
   systemProperty 'some.prop', 'value'

   // explicitly include or exclude tests
   include 'org/foo/**'
   exclude 'org/boo/**'

   // show standard out and standard error of the test JVM(s) on the console
   testLogging.showStandardStreams = true

   // set heap size for the test JVM(s)
   minHeapSize = "128m"
   maxHeapSize = "512m"

   // set JVM arguments for the test JVM(s)
   jvmArgs '-XX:MaxPermSize=256m'
   
   // listen to events in the test execution lifecycle
   beforeTest { 
      descriptor → logger.lifecycle("Running test: " + descriptor)
   }

   // listen to standard out and standard error of the test JVM(s)
   onOutput { 
      descriptor, event → logger.lifecycle
         ("Test: " + descriptor + " produced standard out/err: " 
         + event.message )
   }
}

Sie können die folgende Befehlssyntax verwenden, um eine Testaufgabe auszuführen.

gradle <someTestTask> --debug-jvm

Gradle kann problemlos kleinste und größte Projekte bearbeiten. Kleine Projekte haben eine einzelne Build-Datei und einen Quellbaum. Es ist sehr einfach, ein Projekt zu verdauen und zu verstehen, das in kleinere, voneinander abhängige Module aufgeteilt wurde. Gradle unterstützt dieses Szenario, das aus mehreren Projekten besteht, perfekt.

Struktur für die Erstellung mehrerer Projekte

Solche Builds gibt es in allen Formen und Größen, aber sie haben einige gemeinsame Eigenschaften -

• EIN settings.gradle Datei im Stamm- oder Hauptverzeichnis des Projekts.

• EIN build.gradle Datei im Stamm- oder Hauptverzeichnis.

• Untergeordnete Verzeichnisse, die ihre eigenen haben *.gradle Build-Dateien (einige Builds für mehrere Projekte lassen möglicherweise untergeordnete Projekt-Build-Skripte aus).

Verwenden Sie den folgenden Befehl, um alle Projekte in der Build-Datei aufzulisten.

C:\> gradle -q projects

Ausgabe:

------------------------------------------------------------
Root project
------------------------------------------------------------

Root project 'projectReports'
+--- Project ':api' - The shared API for the application
\--- Project ':webapp' - The Web application implementation

To see a list of the tasks of a project, run gradle <project-path>:tasks
For example, try running gradle :api:tasks

Der Bericht enthält die Beschreibung jedes Projekts, falls angegeben. Mit dem folgenden Befehl können Sie die Beschreibung angeben. Fügen Sie es in diebuild.gradle Datei.

description = 'The shared API for the application'

Angeben einer allgemeinen Build-Konfiguration

In einem build.gradle Datei im root_project können allgemeine Konfigurationen auf alle Projekte oder nur auf die Unterprojekte angewendet werden.

allprojects {
   group = 'com.example.gradle'
   version = '0.1.0'
}

subprojects {
   apply plugin: 'java'
   apply plugin: 'eclipse'
}

Dies gibt eine gemeinsame an com.example.gradle Gruppe und die 0.1.0Version für alle Projekte. Dassubprojects Beim Schließen werden gemeinsame Konfigurationen für alle Unterprojekte angewendet, jedoch nicht für das Stammprojekt wie das allprojects Schließung tut.

Projektspezifische Konfigurationen und Abhängigkeiten

Der Kern ui und util Teilprojekte können auch eigene haben build.gradle Datei, wenn sie spezielle Anforderungen haben, die von der allgemeinen Konfiguration des Stammprojekts noch nicht angewendet werden.

Beispielsweise ist das UI-Projekt normalerweise vom Kernprojekt abhängig. Das UI-Projekt braucht also ein eigenesbuild.gradle Datei, um diese Abhängigkeit anzugeben.

dependencies {
   compile project(':core')
   compile 'log4j:log4j:1.2.17'
}

Projektabhängigkeiten werden mit der Projektmethode angegeben.

Gradle bietet verschiedene Möglichkeiten zum Bereitstellen von Build-Artefakt-Repositorys. Wenn Sie Signaturen für Ihre Artefakte in einem Maven-Repository bereitstellen, möchten Sie auch die veröffentlichte POM-Datei signieren.

Verwenden des Maven-Publish-Plugins

maven-publishPlugin, das standardmäßig von Gradle bereitgestellt wird. Wird zum Veröffentlichen des Gradle-Skripts verwendet. Schauen Sie sich den folgenden Code an.

apply plugin: 'java'
apply plugin: 'maven-publish'

publishing {
   publications {
      mavenJava(MavenPublication) {
         from components.java
      }
   }

   repositories {
      maven {
         url "$buildDir/repo"
      }
   }
}

Es gibt mehrere Veröffentlichungsoptionen, wenn die Java und die maven-publishPlugin wird angewendet. Schauen Sie sich den folgenden Code an, der das Projekt in einem Remote-Repository bereitstellt.

apply plugin: 'groovy'
apply plugin: 'maven-publish'

group 'workshop'
version = '1.0.0'

publishing {
   publications {
      mavenJava(MavenPublication) { 
         from components.java 
      }
   }
	
   repositories {
      maven {
          default credentials for a nexus repository manager
         credentials {
            username 'admin'
            password 'admin123'
         }
         // url to the releases maven repository
            url "http://localhost:8081/nexus/content/repositories/releases/"
      }
   }
}

Konvertieren eines Projekts von Maven nach Gradle

Es gibt einen speziellen Befehl zum Konvertieren von Apache Maven pom.xml Dateien zu Gradle-Build-Dateien, wenn alle verwendeten Maven-Plug-Ins für diese Aufgabe bekannt sind.

In diesem Abschnitt das Folgende pom.xmlDie Maven-Konfiguration wird in ein Gradle-Projekt konvertiert. Schau es dir an.

<project xmlns = "http://maven.apache.org/POM/4.0.0" 
   xmlns:xsi = "http://www.w3.org/2001/XMLSchema-instance"
   xsi:schemaLocation = "http://maven.apache.org/POM/4.0.0
   http://maven.apache.org/xsd/maven-4.0.0.xsd">
	
   <modelVersion>4.0.0</modelVersion>
   <groupId>com.example.app</groupId>
   <artifactId>example-app</artifactId>
   <packaging>jar</packaging>
   
   <version>1.0.0-SNAPSHOT</version>
	
   <dependencies>
      <dependency>
         <groupId>junit</groupId>
         <artifactId>junit</artifactId>

         <version>4.11</version>
         <scope>test</scope>
      </dependency>
   </dependencies>
	
</project>

Sie können den folgenden Befehl in der Befehlszeile verwenden, der zur folgenden Gradle-Konfiguration führt.

C:\> gradle init --type pom

Das init Die Aufgabe hängt von der Wrapper-Aufgabe ab, sodass ein Gradle-Wrapper erstellt wird.

Das Ergebnis build.gradle Datei sieht ähnlich aus -

apply plugin: 'java'
apply plugin: 'maven'

group = 'com.example.app'
version = '1.0.0-SNAPSHOT'

description = """"""

sourceCompatibility = 1.5
targetCompatibility = 1.5

repositories {
   maven { url "http://repo.maven.apache.org/maven2" }
}

dependencies {
   testCompile group: 'junit', name: 'junit', version:'4.11'
}

In diesem Kapitel wird die Integration von Eclipse und Gradle erläutert. Befolgen Sie die unten angegebenen Schritte, um das Gradle-Plugin zu Eclipse hinzuzufügen.

Schritt 1 - Öffnen Sie den Eclipse Marketplace

Öffnen Sie zunächst die Eclipse, die in Ihrem System installiert ist. Gehen Sie zur Hilfe -> klicken Sie auf EclipseMarketplace. Schauen Sie sich den folgenden Screenshot an.

Schritt 2 - Installieren Sie das Buildship Plugin

Nachdem Sie dort auf den Eclipse Marketplace geklickt haben, finden Sie den folgenden Screenshot. Hier in der linken Suchleiste geben Sie einbuildship. Buildship ist ein Gradle-Integrations-Plugin. Wenn Sie das Buildship auf Ihrem Bildschirm finden, klicken Sie auf der rechten Seite auf Installieren. Schauen Sie sich den folgenden Screenshot an.

Danach finden Sie dort den folgenden Screenshot. Sie müssen die Softwareinstallation bestätigen, indem Sie auf die Schaltfläche Bestätigen klicken. Schauen Sie sich den folgenden Screenshot an.

Danach müssen Sie im folgenden Bildschirm auf Lizenzvereinbarung akzeptieren klicken und auf Fertig stellen klicken. Schauen Sie sich den folgenden Screenshot an.

Die Installation dauert einige Zeit. Schauen Sie sich den folgenden Screenshot an.

Danach werden Sie aufgefordert, Eclipse neu zu starten. Dort werden Sie auswählenYes.

Schritt 3 - Überprüfen des Gradle Plugins

Während der Überprüfung erstellen wir ein neues Projekt, indem wir das vorgegebene Verfahren befolgen. Gehen Sie in der Eclipse zur Datei -> klicken Sie auf Neu -> klicken Sie auf andere Projekte. Dort finden Sie den folgenden Bildschirm. Wählen Sie dort Gradle-Projekt und klicken Sie auf Weiter. Schauen Sie sich den folgenden Screenshot an.

Nachdem Sie dort auf die Schaltfläche Weiter geklickt haben, wird der folgende Bildschirm angezeigt. Dort geben Sie den Gradle-Ausgangsverzeichnispfad des lokalen Dateisystems an und klicken auf die Schaltfläche Weiter. Schauen Sie sich den folgenden Screenshot an.

Schauen Sie sich den folgenden Screenshot an, in dem Sie den Namen für das Gradle-Projekt angeben. In diesem Tutorial verwenden wirdemoproject und klicken Sie auf Fertig stellen.

Schauen Sie sich den folgenden Screenshot an, um das Projekt zu bestätigen. Dafür haben wir im folgenden Bildschirm die Schaltfläche Fertig stellen.

Schritt 4 - Überprüfen der Verzeichnisstruktur

Überprüfen Sie nach erfolgreicher Installation des Gradle-Plugins die Verzeichnisstruktur des Demoprojekts auf die Standarddateien und -ordner, wie im folgenden Screenshot gezeigt.