Gradle - szybki przewodnik

"Gradle is an open source build automation system"

Ant i Maven odnieśli znaczny sukces na rynku JAVA. Ant było pierwszym narzędziem do budowania wydanym w 2000 roku i zostało opracowane w oparciu o ideę programowania proceduralnego. Później został ulepszony o możliwość akceptowania wtyczek i zarządzania zależnościami przez sieć z pomocą Apache-IVY. Główną wadą jest XML jako format do pisania skryptów kompilacji, ponieważ hierarchia nie jest dobra w programowaniu proceduralnym, a XML ma tendencję do niemożliwości zarządzania dużymi rozmiarami.

Maven został wprowadzony w 2004 roku. Zawiera wiele ulepszeń niż ANT. Zmienia swoją strukturę i nadal używa XML do pisania specyfikacji kompilacji. Maven opiera się na konwencjach i może pobierać zależności przez sieć. Główne zalety Mavena to cykl życia. Podczas ciągłego przestrzegania tego samego cyklu życia dla wielu projektów. Wiąże się to z kosztem elastyczności. Maven boryka się również z problemami związanymi z zarządzaniem zależnościami. Nie radzi sobie dobrze z konfliktami między wersjami tej samej biblioteki, a złożone, dostosowane skrypty budowania są w rzeczywistości trudniejsze do napisania w maven niż w ANT.

Wreszcie Gradle pojawił się w 2012 roku. Gradle posiada kilka wydajnych funkcji z obu narzędzi.

Funkcje Gradle

Poniżej znajduje się lista funkcji oferowanych przez Gradle.

• Declarative builds and build-by-convention- Gradle jest dostępny z oddzielnym językiem specyficznym dla domeny (DSL) opartym na języku Groovy. Gradle zapewnia deklaratywne elementy języka. Te elementy zapewniają również obsługę budowania według konwencji dla języków Java, Groovy, OSGI, Web i Scala.

• Language for dependency based programming - Język deklaratywny znajduje się na górze wykresu zadań ogólnego przeznaczenia, który możesz w pełni wykorzystać w swojej kompilacji.

• Structure your build- Gradle wreszcie umożliwia zastosowanie wspólnych zasad projektowania do kompilacji. Da ci idealną strukturę do budowy, dzięki czemu możesz zaprojektować dobrze zorganizowaną i łatwą w utrzymaniu, zrozumiałą konstrukcję.

• Deep API - Korzystając z tego interfejsu API, można monitorować i dostosowywać jego konfigurację i zachowanie podczas wykonywania do jego rdzenia.

• Gradle scales - Gradle może z łatwością zwiększyć swoją produktywność, od prostych i pojedynczych projektów po duże korporacyjne kompilacje z wieloma projektami.

• Multi-project builds- Gradle obsługuje kompilacje z wieloma projektami i obsługuje kompilacje częściowe. Jeśli zbudujesz podprojekt, Gradle zajmie się budowaniem wszystkich podprojektów, od których zależy.

• Different ways to manage your builds - Gradle obsługuje różne strategie zarządzania zależnościami.

• Gradle is the first build integration tool- Gradle w pełni obsługiwane dla zadań ANT, infrastruktura repozytoriów Maven i Lvy do publikowania i pobierania zależności. Gradle udostępnia również konwerter do przekształcania pliku pom.xml Mavena na skrypt Gradle.

• Ease of migration- Gradle może łatwo dostosować się do dowolnej posiadanej konstrukcji. Dlatego zawsze możesz opracować swoją kompilację Gradle w tej samej gałęzi, w której możesz zbudować skrypt na żywo.

• Gradle Wrapper- Gradle Wrapper umożliwia wykonywanie kompilacji Gradle na maszynach, na których nie jest zainstalowany Gradle. Jest to przydatne do ciągłej integracji serwerów.

• Free open source - Gradle to projekt typu open source, objęty licencją w ramach licencji oprogramowania Apache (ASL).

• Groovy- Skrypty budowania Gradle są napisane w Groovy. Cały projekt Gradle jest zorientowany na używanie go jako języka, a nie jako sztywne ramy. Groovy pozwala na napisanie własnego scenariusza z pewnymi abstrakcjami. Całe API Gradle jest w pełni zaprojektowane w języku Groovy.

Dlaczego Groovy?

Pełne API Gradle zostało zaprojektowane przy użyciu języka Groovy. Jest to zaleta wewnętrznego DSL nad XML. Gradle to narzędzie do budowania ogólnego przeznaczenia; jego głównym celem są projekty Java. W takich projektach członkowie zespołu będą dobrze zaznajomieni z Javą i lepiej, aby kompilacja była jak najbardziej przejrzysta dla wszystkich członków zespołu.

Języki takie jak Python, Groovy lub Ruby są lepsze do budowania frameworka. Dlaczego wybrano Groovy, ponieważ oferuje zdecydowanie największą przejrzystość dla osób używających Javy. Podstawowa składnia Groovy jest taka sama jak Java. Groovy zapewnia o wiele więcej.

Gradle to narzędzie do kompilacji oparte na języku Java. Istnieją pewne wymagania wstępne, które należy zainstalować przed zainstalowaniem szkieletu Gradle.

Wymagania wstępne

JDK i Groovy są warunkami wstępnymi instalacji Gradle.

• Gradle wymaga zainstalowania w systemie JDK w wersji 6 lub nowszej. Używa zainstalowanych bibliotek JDK i ustawia zmienną środowiskową JAVA_HOME.

• Gradle posiada własną bibliotekę Groovy, dlatego nie musimy jawnie instalować Groovy. Jeśli jest zainstalowany, jest ignorowany przez Gradle.

Poniżej przedstawiono kroki instalacji Gradle w systemie.

Krok 1 - Zweryfikuj instalację JAVA

Przede wszystkim musisz mieć zainstalowany zestaw Java Software Development Kit (SDK) w swoim systemie. Aby to sprawdzić, wykonajJava –version polecenie na dowolnej platformie, na której pracujesz.

W systemie Windows -

Wykonaj następujące polecenie, aby zweryfikować instalację Java. Zainstalowałem w swoim systemie JDK 1.8.

C:\> java -version

Wyjście -

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)

W systemie Linux -

Wykonaj następujące polecenie, aby zweryfikować instalację Java. Zainstalowałem w swoim systemie JDK 1.8.

$ java - version

Wyjście -

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)

Zakładamy, że czytelnicy tego samouczka mają zainstalowany pakiet Java SDK w wersji 1.8.0_66 w swoim systemie.

Krok 2 - Pobierz plik kompilacji Gradle

Pobierz najnowszą wersję Gradle, korzystając z łącza Pobierz Gradle . Na stronie odniesienia kliknijComplete Distributionpołączyć. Ten krok jest wspólny dla każdej platformy. W tym celu otrzymasz pełny plik dystrybucyjny do folderu Pobrane.

Krok 3 - Skonfiguruj środowisko dla Gradle

Skonfigurowanie środowiska oznacza, że ​​musimy wypakować plik dystrybucyjny, skopiować pliki biblioteki w odpowiednie miejsce. KonfigurowanieGRADLE_HOME i PATH Zmienne środowiskowe.

Ten krok zależy od platformy.

W systemie Windows -

Rozpakuj pobrany plik zip o nazwie gradle-2.11-all.zip i skopiuj pliki dystrybucyjne z Downloads\gradle-2.11\ do C:\gradle\ Lokalizacja.

Następnie dodaj C:\gradle i C:\gradle\bin katalogi do GRADLE_HOME i PATHzmienne systemowe. Postępuj zgodnie z podanymi instrukcjamiright click on my computers -> click on properties -> advanced system settings -> click on environmental variables. Znajdziesz tam okno dialogowe do tworzenia i edycji zmiennych systemowych. Kliknij nowy przycisk do tworzenia zmiennej GRADLE_HOME (postępuj zgodnie z lewym zrzutem ekranu). Kliknij Edytuj, aby edytować istniejącą zmienną systemową Ścieżka (postępuj zgodnie z zrzutem ekranu po prawej stronie). Postępuj zgodnie z poniższymi zrzutami ekranu.

W systemie Linux -

Rozpakuj pobrany plik zip o nazwie gradle-2.11-all.zip wtedy znajdziesz rozpakowany plik o nazwie gradle-2.11.

Możesz użyć poniższych, aby przenieść pliki dystrybucyjne z Downloads/gradle-2.11/ do /opt/gradle/Lokalizacja. Wykonaj tę operację z katalogu pobierania.

$ sudo mv gradle-2.11 /opt/gradle

Edytuj plik ~ / .bashrc i wklej do niego następującą zawartość i zapisz go.

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

Wykonaj następujące polecenie, aby wykonać ~/.bashrc plik.

$ source ~/.bashrc

Krok 4: Sprawdź instalację Gradle

W oknach:

Możesz wykonać następujące polecenie w wierszu polecenia.

C:\> gradle –v

Wyjście: tam znajdziesz wersję Gradle.

------------------------------------------------------------
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

W systemie Linux:

Możesz wykonać następujące polecenie w terminalu.

$ gradle –v

Wyjście: tam znajdziesz wersję Gradle.

------------------------------------------------------------
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 buduje plik skryptu do obsługi dwóch rzeczy; Jeden jestprojects a inny jest tasks. Każda kompilacja Gradle reprezentuje jeden lub więcej projektów. Projekt reprezentuje plik JAR biblioteki lub aplikację internetową lub może reprezentować plik ZIP złożony z plików JAR utworzonych w innych projektach. Krótko mówiąc, projekt składa się z różnych zadań. Zadanie oznacza pracę, którą wykonuje kompilacja. Zadaniem może być kompilowanie niektórych klas, tworzenie pliku JAR, generowanie Javadoc lub publikowanie niektórych archiwów w repozytorium.

Gradle używa Groovy language do pisania scenariuszy.

Pisanie skryptu kompilacji

Gradle udostępnia język specyficzny dla domeny (DSL) do opisywania kompilacji. Używa języka Groovy, aby ułatwić opisanie kompilacji. Każdy skrypt kompilacji Gradle jest kodowany przy użyciu UTF-8, zapisywany w trybie offline i nazwany jako build.gradle.

build.gradle

Opisujemy zadania i projekty za pomocą skryptu Groovy. Kompilację Gradle można uruchomić za pomocą polecenia Gradle. To polecenie szuka pliku o nazwiebuild.gradle. Spójrz na poniższy przykład, który przedstawia mały skrypt, który drukujetutorialspoint. Skopiuj i zapisz następujący skrypt w pliku o nazwiebuild.gradle. Ten skrypt kompilacji definiuje nazwę zadania hello, która jest używana do drukowania ciągu tutorialspoint.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać tam, gdzie przechowywany jest plik build.gradle.

C:\> gradle –q hello

Wynik:

tutorialspoint

Jeśli myślisz, że zadanie działa podobnie do celu ANT, to prawda - zadanie Gradle jest równoważne z celem ANT.

Możesz uprościć to zadanie Hello, określając skrót (reprezentujący symbol <<) do doLastkomunikat. Jeśli dodasz ten skrót do powyższego zadaniahello będzie wyglądać jak poniższy skrypt.

task hello << {
   println 'tutorialspoint'
}

Podobnie jak powyżej możesz wykonać powyższy skrypt za pomocą gradle –q hello Komenda.

Skrypt Grade wykorzystywał głównie dwa prawdziwe obiekty, jeden to obiekt projektu, a drugi to obiekt skryptu.

Project Object- Każdy skrypt opisuje jeden lub wiele projektów. Podczas wykonywania te skrypty konfigurują obiekt projektu. Możesz wywołać niektóre metody i użyć właściwości w skrypcie kompilacji, które są delegowane do obiektu projektu.

Script Object- Gradle wziął kod skryptu do klas, które implementują interfejs skryptów, a następnie wykonuje. Oznacza to, że wszystkie właściwości i metody zadeklarowane przez interfejs skryptu są dostępne w skrypcie.

Poniższa tabela zawiera listę plików standard project properties. Wszystkie te właściwości są dostępne w skrypcie kompilacji.

Groovy Basics

Skrypty budowania Gradle używają pełnej długości Groovy API. Jako startup spójrz na poniższe przykłady.

Poniższy przykład wyjaśnia, jak konwertować ciąg na wielkie litery.

Skopiuj i zapisz poniższy kod do build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowywany jest plik build.gradle.

C:\> gradle –q upper

Wynik:

Original: TUTORIALS point
Upper case: TUTORIALS POINT

Poniższy przykład wyjaśnia, jak 4 razy drukować wartość niejawnego parametru ($ it).

Skopiuj i zapisz następujący kod w build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowywany jest plik build.gradle.

$ gradle –q count

Wynik:

0 1 2 3

Język Groovy zapewnia wiele funkcji, a niektóre z ważnych funkcji omówiono poniżej.

Groovy JDK Methods

Groovy dodaje wiele przydatnych metod do standardowych klas Java. Na przykład Iterable API z JDK implementujeeach() metoda, która iteruje po elementach Iterable Interface.

Skopiuj i zapisz następujący kod w build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q groovyJDK

Wynik:

M
a
r
c

Akcesory własności

Możesz automatycznie uzyskać dostęp do odpowiednich metod pobierających i ustawiających określonej właściwości, określając jej odniesienie.

Poniższy fragment kodu definiuje składnię metod pobierających i ustawiających właściwości buildDir.

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

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

Opcjonalne nawiasy na wywołaniach metod

Groovy zawiera specjalną funkcję w wywoływaniu metod, która polega na tym, że nawiasy są opcjonalne dla wywoływania metod. Ta funkcja dotyczy również skryptów Gradle.

Spójrz na następującą składnię. To definiuje wywołanie metodysystemProperty z test obiekt.

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

Zamknięcie jako ostatni parametr metody

Gradle DSL używa zamknięć w wielu miejscach. Tam, gdzie ostatnim parametrem metody jest zamknięcie, można je umieścić po wywołaniu metody.

Poniższy fragment kodu definiuje składnię używaną przez Zamknięcia jako parametry metody repozytorium ().

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

Domyślne importy

Gradle automatycznie dodaje zestaw instrukcji importu do skryptów Gradle. Poniższa lista przedstawia domyślne pakiety importu do skryptu Gradle.

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.*

Skrypt kompilacji Gradle opisuje jeden lub więcej projektów. Każdy projekt składa się z różnych zadań. Zadanie to praca wykonywana przez kompilację. Zadanie może polegać na kompilowaniu niektórych klas, przechowywaniu plików klas w oddzielnym folderze docelowym, tworzeniu JAR, generowaniu Javadoc lub publikowaniu niektórych osiągnięć w repozytoriach.

W tym rozdziale wyjaśniono, czym jest zadanie oraz jak je wygenerować i wykonać.

Definiowanie zadań

Zadanie to słowo kluczowe, które służy do definiowania zadania w skrypcie kompilacji. Spójrz na poniższy przykład, który przedstawia zadanie o nazwiehello które drukuje tutorialspoint. Skopiuj i zapisz następujący skrypt w pliku o nazwiebuild.gradle. Ten skrypt kompilacji definiuje nazwę zadania hello, która jest używana do drukowania ciągu tutorialspoint.

task hello {
   doLast {
      println 'tutorialspoint'
   }
}

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Należy to wykonać tam, gdzie przechowywany jest plik build.gradle.

C:\> gradle –q hello

Wynik:

tutorialspoint

Możesz uprościć to zadanie Hello, określając skrót (reprezentujący symbol <<) do doLastkomunikat. Jeśli dodasz ten skrót do powyższego zadaniahello będzie wyglądać jak poniższy skrypt.

task hello << {
   println 'tutorialspoint'
}

Możesz uruchomić powyższy skrypt za pomocą gradle –q hello Komenda.

Oto kilka odmian definiowania zadania, spójrz na to. Poniższy przykład definiuje zadaniehello.

Skopiuj i zapisz następujący kod w build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q hello

Wynik:

tutorialspoint

Możesz również użyć ciągów znaków w nazwach zadań. Spójrz na ten sam przykład powitania. Tutaj użyjemy String jako zadania.

Skopiuj i zapisz następujący kod w build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q hello

Wynik:

tutorialspoint

Możesz także użyć alternatywnej składni do zdefiniowania zadania. Oznacza to użycie metody create () do zdefiniowania zadania. Spójrz na ten sam przykład powitania podany poniżej.

Skopiuj i zapisz poniższy kod do build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q hello

Wynik:

tutorialspoint

Lokalizowanie zadań

Jeśli chcesz zlokalizować zadania zdefiniowane w pliku kompilacji, musisz użyć odpowiednich standardowych właściwości projektu. Oznacza to, że każde zadanie jest dostępne jako właściwość projektu, przy użyciu nazwy zadania jako nazwy właściwości.

Przyjrzyj się poniższemu kodowi, który uzyskuje dostęp do zadań jako właściwości.

Skopiuj i zapisz poniższy kod do build.gradle plik.

task hello

println hello.name
println project.hello.name

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q hello

Wynik:

hello
hello

Możesz również użyć wszystkich właściwości za pośrednictwem kolekcji zadań.

Skopiuj i zapisz następujący kod w build.gradle plik.

task hello

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q hello

Wynik:

hello
hello

Możesz również uzyskać dostęp do ścieżki zadania za pomocą zadań. W tym celu możesz wywołać metodę getByPath () z nazwą zadania, ścieżką względną lub ścieżką bezwzględną.

Skopiuj i zapisz poniższy kod do build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdy przechowuje plik build.gradle.

C:\> gradle –q hello

Wynik:

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

Dodawanie zależności do zadań

Możesz uzależnić zadanie od innego zadania, co oznacza, że ​​po wykonaniu jednego zadania rozpocznie się tylko inne zadanie. Każde zadanie jest rozróżniane nazwą zadania. Do zbioru nazw zadań odwołuje się jego kolekcja zadań. Aby odwołać się do zadania w innym projekcie, należy użyć ścieżki projektu jako przedrostka do odpowiedniej nazwy zadania.

Poniższy przykład, który dodaje zależność od taskX do taskY.

Skopiuj i zapisz poniższy kod do build.gradleplik. Spójrz na poniższy kod.

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

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdziebuild.gradle magazyny plików.

C:\> gradle –q taskY

Wynik:

taskX
taskY

Powyższy przykład to dodanie zależności od zadania przy użyciu jego nazw. Istnieje inny sposób osiągnięcia zależności między zadaniami, który polega na zdefiniowaniu zależności przy użyciu obiektu Task.

Weźmy ten sam przykład zależności taskY od taskX, ale używamy obiektów zadań zamiast nazw odwołań do zadań.

Skopiuj i zapisz następujący kod w build.gradle plik.

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

Wykonaj następujące polecenie w wierszu polecenia. Należy to wykonać tam, gdzie przechowywany jest plik build.gradle.

C:\> gradle –q taskY

Wynik:

taskX
taskY

Powyższy przykład to dodanie zależności od zadania przy użyciu jego nazw. Istnieje inny sposób osiągnięcia zależności między zadaniami, który polega na zdefiniowaniu zależności przy użyciu obiektu Task.

Tutaj bierzemy ten sam przykład, w którym taskY jest zależny od taskX, ale używamy obiektów zadań zamiast nazw odniesień do zadań. Przyjrzyj się temu.

Skopiuj i zapisz poniższy kod do build.gradleplik. Spójrz na poniższy kod.

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'
}

Wykonaj następujące polecenie w wierszu polecenia. Wykonuje powyższy skrypt. Powinieneś to wykonać, gdziebuild.gradle magazyny plików.

C:\> gradle –q taskX

Wynik:

lib1
lib2
taskX

Dodawanie opisu do zadania

Możesz dodać opis do swojego zadania. Ten opis jest wyświetlany podczas wykonywaniaGradle tasks. Jest to możliwe dzięki użyciu słowa kluczowego description.

Skopiuj i zapisz następujący kod w build.gradleplik. Spójrz na poniższy kod.

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

Wykonaj następujące polecenie w wierszu polecenia. Należy to wykonać tam, gdzie przechowywany jest plik build.gradle.

C:\> gradle –q copy

Jeśli polecenie zostanie wykonane pomyślnie, otrzymasz następujące dane wyjściowe.

description applied

Pomijanie zadań

Pomijanie zadań można wykonać, przekazując zamknięcie predykatu. Jest to możliwe tylko wtedy, gdy metoda zadania lub zakończenie rzucaStopExecutionException przed faktyczną pracą zadania.

Skopiuj i zapisz następujący kod w build.gradle plik.

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()
   }
}

Wykonaj następujące polecenie w wierszu polecenia. Należy to wykonać tam, gdzie przechowywany jest plik build.gradle.

C:\> gradle –q eclipse

Struktura zadań

Podczas pracy z zadaniami Gradle ma różne fazy. Przede wszystkim jest faza konfiguracji, w której wykonywany jest kod, który jest określony bezpośrednio w zamknięciu zadania. Blok konfiguracyjny jest wykonywany dla każdego dostępnego zadania, a nie tylko dla zadań, które są później faktycznie wykonywane.

Po fazie konfiguracji faza wykonywania uruchamia kod wewnątrz doFirst lub doLast zamknięcia tych zadań, które są faktycznie wykonywane.

Skrypt kompilacji Gradle definiuje proces tworzenia projektów; każdy projekt zawiera zależności i kilka publikacji. Zależności to elementy obsługujące tworzenie projektu, takie jak wymagany plik JAR z innych projektów i zewnętrzne pliki JAR, takie jak JDBC JAR lub Eh-cache JAR w ścieżce klas. Publikacje oznaczają wyniki projektu, takie jak pliki klas testowych i pliki kompilacji, takie jak pliki wojenne.

Większość projektów nie jest samowystarczalna. Potrzebują plików skompilowanych przez inne projekty, aby skompilować i przetestować pliki źródłowe. Na przykład, aby użyć Hibernate w projekcie, musisz dołączyć kilka plików JAR Hibernate do ścieżki klas. Gradle używa specjalnego skryptu do zdefiniowania zależności, które należy pobrać.

Gradle zajmuje się budowaniem i publikowaniem gdzieś wyników. Publikowanie odbywa się na podstawie zdefiniowanego zadania. Może chcieć skopiować pliki do katalogu lokalnego lub przesłać je do zdalnego repozytorium Maven lub Lvy albo możesz użyć plików z innego projektu w tej samej kompilacji z wieloma projektami. Proces publikowania zadania można nazwać publikacją.

Deklarowanie swoich zależności

Konfiguracja zależności to nic innego jak definiowanie zestawu zależności. Możesz użyć tej funkcji, aby zadeklarować zewnętrzne zależności, które chcesz pobrać z sieci. To definiuje różne kategorie, takie jak poniżej.

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.+'
}

Konfiguracje zależności

Konfiguracja zależności to nic innego jak definiowanie zestawu zależności. Możesz użyć tej funkcji do zadeklarowania zależności zewnętrznych, które chcesz pobrać z sieci. Definiuje następujące różne standardowe konfiguracje.

• Compile - Zależności wymagane do skompilowania produkcyjnego źródła projektu.

• Runtime- Zależności wymagane przez klasy produkcyjne w czasie wykonywania. Domyślnie obejmuje również zależności czasu kompilacji.

• Test Compile- Zależności wymagane do skompilowania testowego źródła projektu. Domyślnie zawiera skompilowane klasy produkcyjne i zależności czasu kompilacji.

• Test Runtime- Zależności wymagane do uruchomienia testów. Domyślnie zawiera zależności w czasie wykonywania i kompilacji testowej.

Zależności zewnętrzne

Zależności zewnętrzne są jednymi z typów zależności. Jest to zależność od niektórych plików zbudowanych poza bieżącą kompilacją i przechowywanych w jakimś repozytorium, takim jak centrala Maven, korporacyjne repozytorium Maven lub lvy, lub katalog w lokalnym systemie plików.

Poniższy fragment kodu służy do zdefiniowania zależności zewnętrznej. Użyj tego kodu wbuild.gradle plik.

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

Zależność zewnętrzna deklaruje zależności zewnętrzne, a forma skrótu wygląda jak „grupa: nazwa: wersja”.

Repozytoria

Podczas dodawania zależności zewnętrznych. Gradle szuka ich w repozytorium. Repozytorium to po prostu zbiór plików uporządkowanych według grupy, nazwy i wersji. Domyślnie Gradle nie definiuje żadnych repozytoriów. Musimy jawnie zdefiniować co najmniej jedno repozytorium. Poniższy fragment kodu definiuje sposób definiowania repozytorium Maven. Użyj tego kodu wbuild.gradle plik.

repositories {
   mavenCentral()
}

Poniższy kod służy do zdefiniowania zdalnego użytkownika. Użyj tego kodu wbuild.gradle plik.

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

Publikowanie artefaktów

Konfiguracje zależności są również używane do publikowania plików. Te opublikowane pliki nazywane są artefaktami. Zwykle używamy wtyczek do definiowania artefaktów. Musisz jednak powiedzieć Gradle, gdzie opublikować artefakty. Możesz to osiągnąć, dołączając repozytoria do zadania przesyłania archiwów. Spójrz na następującą składnię publikowania repozytorium Maven. Podczas wykonywania Gradle wygeneruje i załaduje Pom.xml zgodnie z wymaganiami projektu. Użyj tego kodu wbuild.gradle plik.

apply plugin: 'maven'

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

Wtyczka to nic innego jak zestaw zadań, prawie wszystkie przydatne zadania, takie jak kompilowanie zadań, ustawianie obiektów domeny, konfigurowanie plików źródłowych itp., Są obsługiwane przez wtyczki. Zastosowanie wtyczki do projektu oznacza, że ​​wtyczka rozszerza możliwości projektu. Wtyczki mogą wykonywać takie czynności, jak -

• Rozszerz podstawowy model Gradle (np. Dodaj nowe elementy DSL, które można skonfigurować).
• Skonfiguruj projekt zgodnie z konwersjami (np. Dodaj nowe zadania lub skonfiguruj rozsądne ustawienia domyślne).
• Zastosuj określoną konfigurację (np. Dodaj repozytoria organizacyjne lub egzekwuj standardy).

Rodzaje wtyczek

W Gradle są dwa rodzaje wtyczek: wtyczki skryptowe i wtyczki binarne. Wtyczki skryptów to dodatkowy skrypt kompilacji, który zapewnia deklaratywne podejście do manipulowania kompilacją. Jest to zwykle używane w kompilacji. Wtyczki binarne to klasy, które implementują interfejs wtyczki i przyjmują programistyczne podejście do manipulowania kompilacją. Wtyczki binarne mogą znajdować się w skrypcie kompilacji, w hierarchii projektu lub zewnętrznie w pliku JAR wtyczki.

Stosowanie wtyczek

Project.apply()Metoda API służy do zastosowania konkretnej wtyczki. Możesz używać tej samej wtyczki wiele razy. Istnieją dwa typy wtyczek, jedna to wtyczka skryptowa, a druga to wtyczka binarna.

Wtyczki skryptowe

Wtyczki skryptów można zastosować ze skryptu w lokalnym systemie plików lub w zdalnej lokalizacji. Lokalizacje systemu plików są względne w stosunku do katalogu projektu, podczas gdy zdalne lokalizacje skryptów określają adres URL HTTP. Spójrz na następujący fragment kodu. Służy do stosowaniaother.gradleplugin do skryptu budowania. Użyj tego kodu wbuild.gradle plik.

apply from: 'other.gradle'

Wtyczki binarne

Każda wtyczka jest identyfikowana przez identyfikator wtyczki, ponieważ niektóre wtyczki podstawowe używają krótkich nazw, aby ją zastosować, a niektóre wtyczki społeczności używają w pełni kwalifikowanej nazwy dla identyfikatora wtyczki. Czasami pozwala określić klasę wtyczki.

Spójrz na następujący fragment kodu. Pokazuje, jak zastosować wtyczkę java, używając jej typu. Użyj tego kodu wbuild.gradle plik.

apply plugin: JavaPlugin

Spójrz na poniższy kod, aby zastosować wtyczkę core przy użyciu krótkiej nazwy. Użyj tego kodu wbuild.gradle plik.

plugins {
   id 'java'
}

Zapoznaj się z poniższym kodem, aby zastosować wtyczkę społeczności przy użyciu krótkiej nazwy. Użyj tego kodu wbuild.gradle plik.

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

Pisanie niestandardowych wtyczek

Tworząc niestandardową wtyczkę, musisz napisać implementację wtyczki. Gradle tworzy instancję wtyczki i wywołuje instancję wtyczki za pomocą metody Plugin.apply (). Poniższy przykład zawiera wtyczkę powitania, która dodaje zadanie Hello do projektu. Spójrz na poniższy kod. Użyj tego kodu wbuild.gradle plik.

apply plugin: GreetingPlugin

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

Użyj poniższego kodu, aby wykonać powyższy skrypt.

C:\> gradle -q hello

Wynik:

Hello from the GreetingPlugin

Pobieranie danych wejściowych z kompilacji

Większość wtyczek wymaga obsługi konfiguracji ze skryptu kompilacji. Projekt Gradle ma skojarzony obiekt ExtensionContainer, który pomaga śledzić wszystkie ustawienia i właściwości przekazywane do wtyczek.

Dodajmy do projektu prosty obiekt rozszerzenia. Tutaj dodajemy do projektu obiekt rozszerzenia powitania, który umożliwia skonfigurowanie powitania. Użyj tego kodu wbuild.gradle plik.

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'
}

Użyj poniższego kodu, aby wykonać powyższy skrypt.

C:\> gradle -q hello

Wynik:

Hi from Gradle

W tym przykładzie GreetingPlugin to zwykły stary obiekt Groovy z polem o nazwie message. Obiekt rozszerzenia zostanie dodany do listy wtyczek z nazwą pozdrowienia. Ten obiekt staje się następnie dostępny jako właściwość projektu o tej samej nazwie, co obiekt rozszerzenia.

Gradle dodaje zamknięcie konfiguracji dla każdego obiektu rozszerzenia, dzięki czemu można grupować ustawienia. Spójrz na poniższy kod. Użyj tego kodu wbuild.gradle plik.

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
}

Użyj poniższego kodu, aby wykonać powyższy skrypt.

C:\> gradle -q hello

Wynik:

Hello from Gradle

Standardowe wtyczki Gradle

Istnieją różne wtyczki, które są zawarte w dystrybucji Gradle.

Wtyczki językowe

Te wtyczki dodają obsługę różnych języków, które mogą być kompilowane i wykonywane w JVM.

Inkubowanie wtyczek językowych

Te wtyczki dodają obsługę różnych języków.

Gradle udostępnia wiersz poleceń do wykonania skryptu kompilacji. Może wykonywać jednocześnie więcej niż jedno zadanie. W tym rozdziale wyjaśniono, jak wykonywać wiele zadań przy użyciu różnych opcji.

Wykonywanie wielu zadań

Możesz wykonać wiele zadań z jednego pliku kompilacji. Gradle może obsłużyć ten plik kompilacji za pomocągradle command. To polecenie skompiluje każde zadanie w kolejności, w jakiej są wymienione, i wykona każde zadanie wraz z zależnościami przy użyciu różnych opcji.

Example- Istnieją cztery zadania - zadanie1, zadanie2, zadanie3 i zadanie4. Zadanie3 i zadanie4 zależy od zadania 1 i zadania 2. Spójrz na poniższy diagram.

W powyższych 4 zadania są od siebie zależne, przedstawione za pomocą symbolu strzałki. Spójrz na poniższy kod. Kopiuj można wkleić dobuild.gradle plik.

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'
}

Możesz użyć następującego kodu do kompilacji i wykonania powyższego zadania.

C:\> gradle task4 test

Wynik:

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

BUILD SUCCESSFUL

Total time: 1 secs

Z wyłączeniem zadań

Wykluczając zadanie z wykonania możesz użyć opcji –x wraz z poleceniem gradle i podać nazwę zadania, które chcesz wykluczyć.

Użyj następującego polecenia, aby wykluczyć task4 z powyższego skryptu.

C:\> gradle task4 -x test

Wynik:

:task1
compiling source
:task4
building the distribution

BUILD SUCCESSFUL

Total time: 1 secs

Kontynuacja kompilacji w przypadku awarii

Gradle przerwie wykonywanie i zakończy kompilację, gdy tylko jakieś zadanie zawiedzie. Możesz kontynuować wykonywanie, nawet jeśli wystąpi awaria. W tym celu musisz użyć opcji –continue z poleceniem gradle. Obsługuje osobno każde zadanie wraz z ich zależnościami. Najważniejsze jest to, że wychwyci każdą napotkaną awarię i zgłosi po zakończeniu wykonywania kompilacji. Załóżmy, że jeśli zadanie się nie powiedzie, kolejne zadania zależne również nie zostaną wykonane.

Wybór kompilacji do wykonania

Po uruchomieniu polecenia gradle szuka pliku kompilacji w bieżącym katalogu. Możesz użyć opcji –b, aby wybrać konkretny plik kompilacji wraz ze ścieżką bezwzględną. Poniższy przykład wybiera projekt Hello frommyproject.gradle plik, który znajduje się w subdir/ przyjrzyj się temu.

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

Możesz użyć następującego polecenia, aby wykonać powyższy skrypt.

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

Wynik:

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

Uzyskiwanie informacji o kompilacji

Gradle udostępnia kilka wbudowanych zadań do pobierania szczegółowych informacji dotyczących zadania i projektu. Może to być przydatne do zrozumienia struktury i zależności kompilacji oraz do rozwiązywania problemów z debugowaniem. Możesz użyć wtyczki raportów projektu, aby dodać zadania do projektu, które będą generować te raporty.

Lista projektów

Możesz wyświetlić hierarchię projektów wybranego projektu i ich projektów podrzędnych za pomocą gradle –q projectsKomenda. Oto przykład, użyj następującego polecenia, aby wyświetlić listę wszystkich projektów w pliku kompilacji.

C:\> gradle -q projects

Wynik:

------------------------------------------------------------
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

Raport zawiera opis każdego projektu, jeśli został określony. Aby określić opis, możesz użyć następującego polecenia. Wklej go wbuild.gradle plik.

description = 'The shared API for the application'

Lista zadań

Możesz wyświetlić listę wszystkich zadań, które należą do wielu projektów, używając następującego polecenia.

C:\> gradle -q tasks

Wynik:

------------------------------------------------------------
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>

Możesz użyć następującego polecenia, aby wyświetlić informacje o wszystkich zadaniach.

C:\> gradle -q tasks --all

Wynik:

------------------------------------------------------------
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'.

Oto lista poleceń w opisie tabeli różnych opcji.

W tym rozdziale wyjaśniono, jak zbudować projekt Java przy użyciu pliku kompilacji Gradle.

Przede wszystkim musimy dodać wtyczkę java do skryptu kompilacji, ponieważ zapewnia zadania kompilacji kodu źródłowego Java, uruchamiania testów jednostkowych, tworzenia Javadoc i tworzenia pliku JAR. Użyj następującego wierszabuild.gradle plik.

apply plugin: 'java'

Domyślny układ projektu Java

Kiedykolwiek dodajesz wtyczkę do swojej kompilacji, zakłada ona określoną konfigurację projektu Java (podobnie jak Maven). spójrz na następującą strukturę katalogów.

• src / main / java zawiera kod źródłowy Java
• src / test / java zawiera testy Java

Jeśli zastosujesz się do tej konfiguracji, następujący plik kompilacji wystarczy do skompilowania, przetestowania i spakowania projektu Java.

Aby rozpocząć kompilację, wpisz następujące polecenie w wierszu poleceń.

C:\> gradle build

SourceSetsmożna użyć do określenia innej struktury projektu. Na przykład źródła są przechowywane w plikusrc folder zamiast w src/main/java. Spójrz na następującą strukturę katalogów.

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

wykonanie zadania init

Gradle nie obsługuje jeszcze wielu szablonów projektów. Ale oferujeinitzadanie stworzenia struktury nowego projektu Gradle. Bez dodatkowych parametrów to zadanie tworzy projekt Gradle, który zawiera pliki otoki gradle, abuild.gradle i settings.gradle plik.

Podczas dodawania --type parametr z java-library jako wartość tworzona jest struktura projektu Java, a plik build.gradleplik zawiera określony szablon Java z Junit. Spójrz na poniższy kod dlabuild.gradle plik.

apply plugin: 'java'

repositories {
   jcenter()
}

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

W sekcji repozytoria określa, gdzie znaleźć zależności. Jcentersłuży do rozwiązywania twoich zależności. Sekcja zależności służy do dostarczania informacji o zależnościach zewnętrznych.

Określanie wersji Java

Zwykle projekt Java ma wersję i docelowe środowisko JRE, w którym jest kompilowany. Plikversion i sourceCompatibility właściwość można ustawić w build.gradle plik.

version = 0.1.0
sourceCompatibility = 1.8

Jeśli artefakt jest wykonywalną aplikacją Java, plik MANIFEST.MF plik musi być świadomy klasy z metodą main.

apply plugin: 'java'

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

Example:

Utwórz strukturę katalogów, jak pokazano na poniższym zrzucie ekranu.

Skopiuj poniższy kod java do pliku App.java i zapisz w 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!" );
   }
}

Skopiuj poniższy kod java do pliku AppTset.java i zapisz w 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!" );
   }
}

Skopiuj poniższy kod do pliku build.gradle i umieść w consumerbanking\ informator.

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'
   }
}

Aby skompilować i wykonać powyższy skrypt, użyj poniższych poleceń.

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

Sprawdź wszystkie pliki klas w odpowiednich katalogach i sprawdź consumerbanking\build\lib folder dla consumerbanking.jar plik.

W tym rozdziale wyjaśniono, jak skompilować i wykonać projekt Groovy za pomocą build.gradle plik.

Wtyczka Groovy

Wtyczka Groovy dla Gradle rozszerza wtyczkę Java i zapewnia zadania dla programów Groovy. Możesz użyć następującego wiersza, aby zastosować wtyczkę groovy.

apply plugin: 'groovy'

Pełny plik skryptu kompilacji jest następujący. Skopiuj następujący kod dobuild.gradle plik.

apply plugin: 'groovy'

repositories {
   mavenCentral()
}

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

Możesz użyć następującego polecenia, aby wykonać skrypt kompilacji.

gradle build

Domyślny układ projektów Groovy Projects

Wtyczka Groovy zakłada pewną konfigurację twojego projektu Groovy.

• src / main / groovy zawiera kod źródłowy Groovy
• src / test / groovy zawiera testy Groovy
• src / main / java zawiera kod źródłowy Java
• src / test / java zawiera testy Java

Sprawdź odpowiedni katalog, w którym build.gradle miejsca na pliki dla folderu budowania.

Zadanie testowe automatycznie wykrywa i wykonuje wszystkie testy jednostkowe w zestawie źródeł testów. Generuje również raport po zakończeniu wykonywania testu. JUnit i TestNG to obsługiwane interfejsy API.

Zadanie testowe zapewnia plik Test.getDebug()metoda, którą można ustawić do uruchomienia, aby maszyna JVM czekała na debuger. Przed przystąpieniem do wykonania ustawia post debugera na5005.

Wykrywanie testu

Plik Test Taskwykrywa, które klasy są klasami testowymi, sprawdzając skompilowane klasy testowe. Domyślnie skanuje wszystkie pliki .class. Możesz ustawić niestandardowe uwzględnienia / wykluczenia, tylko te klasy będą skanowane. W zależności od używanego środowiska testowego (JUnit / TestNG), wykrywanie klasy testów wykorzystuje różne kryteria.

Korzystając z JUnit, skanujemy w poszukiwaniu klas testowych JUnit 3 i 4. Jeśli którekolwiek z poniższych kryteriów jest zgodne, klasa jest uważana za klasę testową JUnit -

• Klasa lub super klasa rozszerza TestCase lub GroovyTestCase
• Klasa lub superklasa jest oznaczona adnotacją @RunWith
• Klasa lub super klasa zawiera metodę z adnotacją @Test
• Korzystając z TestNG, skanujemy w poszukiwaniu metod z adnotacją @Test

Note- Klasy abstrakcyjne nie są wykonywane. Gradle skanuje również drzewo dziedziczenia do plików jar w ścieżce klas testowych.

Jeśli nie chcesz używać wykrywania klas testowych, możesz je wyłączyć, ustawiając scanForTestClasses fałszywe.

Grupowanie testów

JUnit i TestNG umożliwiają wyrafinowane grupowanie metod testowych. Do grupowania, klasy i metody testowe JUnit JUnit 4.8 wprowadza pojęcie kategorii. Zadanie testowe umożliwia określenie kategorii JUnit, które chcesz uwzględnić i wykluczyć.

Możesz użyć następującego fragmentu kodu w pliku build.gradle do grupowania metod testowych.

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

Uwzględnij i wyklucz określone testy

Plik Test klasa ma include i excludemetoda. Tych metod można użyć do określenia, które testy należy faktycznie uruchomić.

Uruchom tylko dołączone testy -

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

Pomiń wykluczone testy -

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

Próbka build.gradle plik, jak pokazano poniżej, pokazuje różne opcje konfiguracji.

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 )
   }
}

Możesz użyć następującej składni polecenia, aby wykonać pewne zadanie testowe.

gradle <someTestTask> --debug-jvm

Gradle z łatwością radzi sobie z najmniejszymi i największymi projektami. Małe projekty mają jeden plik kompilacji i drzewo źródłowe. Projekt, który został podzielony na mniejsze, współzależne moduły, jest bardzo łatwy do zrozumienia i zrozumienia. Gradle doskonale obsługuje ten scenariusz, jakim jest kompilacja wielu projektów.

Struktura do tworzenia wielu projektów

Takie kompilacje mają różne kształty i rozmiary, ale mają pewne wspólne cechy -

• ZA settings.gradle plik w katalogu głównym lub głównym projektu.

• ZA build.gradle plik w katalogu głównym lub głównym.

• Katalogi podrzędne, które mają własne *.gradle pliki kompilacji (niektóre kompilacje z wieloma projektami mogą pomijać skrypty budowania projektów podrzędnych).

Aby wyświetlić wszystkie projekty w pliku kompilacji, możesz użyć następującego polecenia.

C:\> gradle -q projects

Wynik:

------------------------------------------------------------
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

Raport zawiera opis każdego projektu, jeśli został określony. Aby określić opis, możesz użyć następującego polecenia. Wklej go wbuild.gradle plik.

description = 'The shared API for the application'

Określanie ogólnej konfiguracji kompilacji

W build.gradle plik w root_project, ogólne konfiguracje można zastosować do wszystkich projektów lub tylko do projektów podrzędnych.

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

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

To określa wspólne com.example.gradle grupa i 0.1.0wersja do wszystkich projektów. Pliksubprojects closure stosuje typowe konfiguracje dla wszystkich projektów podrzędnych, ale nie do projektu głównego, takiego jak allprojects zamknięcie robi.

Konfiguracje i zależności specyficzne dla projektu

Rdzeń ui i util podprojekty mogą mieć również własne build.gradle plik, jeśli mają określone potrzeby, które nie są już uwzględnione w ogólnej konfiguracji projektu głównego.

Na przykład projekt interfejsu użytkownika zwykle ma zależność od projektu podstawowego. Projekt interfejsu użytkownika potrzebuje więc własnegobuild.gradle plik, aby określić tę zależność.

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

Zależności projektu są określane za pomocą metody projektu.

Gradle oferuje kilka sposobów wdrażania repozytoriów artefaktów kompilacji. Podczas wdrażania sygnatur dla artefaktów w repozytorium Maven będziesz również chciał podpisać opublikowany plik POM.

Korzystanie z wtyczki Maven-Publishing

maven-publishwtyczka, która jest domyślnie dostarczana przez Gradle. Używany do publikowania skryptu gradle. Spójrz na poniższy kod.

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

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

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

Istnieje kilka opcji publikowania, gdy Java i maven-publishwtyczka jest stosowana. Spójrz na poniższy kod, wdroży projekt w zdalnym repozytorium.

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/"
      }
   }
}

Konwersja projektu z Maven do Gradle

Istnieje specjalne polecenie konwersji Apache Maven pom.xml pliki do plików kompilacji Gradle, jeśli wszystkie używane wtyczki Maven są znane w tym zadaniu.

W tej sekcji następujące pom.xmlKonfiguracja maven zostanie przekonwertowana na projekt Gradle. Przyjrzyj się temu.

<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>

Możesz użyć następującego polecenia w wierszu polecenia, które spowoduje następującą konfigurację Gradle.

C:\> gradle init --type pom

Plik init zadanie zależy od zadania opakowania, więc jest tworzona otoka Gradle.

Wynikowy build.gradle plik wygląda podobnie do tego -

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'
}

W tym rozdziale wyjaśniono integrację zaćmienia i Gradle. Wykonaj poniższe kroki, aby dodać wtyczkę Gradle do zaćmienia.

Krok 1 - Otwórz Eclipse Marketplace

Przede wszystkim otwórz zaćmienie, które jest zainstalowane w twoim systemie. Przejdź do pomocy -> kliknij EclipseMarketplace. Spójrz na poniższy zrzut ekranu.

Krok 2 - Zainstaluj wtyczkę Buildship

Po kliknięciu na Eclipse Marketplace znajdziesz następujący zrzut ekranu. Tutaj po lewej stronie wpisz pasek wyszukiwaniabuildship. Buildship to wtyczka integracyjna Gradle. Gdy znajdziesz statek budowlany na ekranie, kliknij zainstaluj po prawej stronie. Spójrz na poniższy zrzut ekranu.

Następnie znajdziesz następujący zrzut ekranu, który musisz potwierdzić instalację oprogramowania, klikając przycisk Potwierdź. Spójrz na poniższy zrzut ekranu.

Następnie musisz kliknąć zaakceptuj umowę licencyjną na następnym ekranie i kliknij Zakończ. Spójrz na poniższy zrzut ekranu.

Instalacja zajmie trochę czasu. Spójrz na poniższy zrzut ekranu.

Następnie poprosi o ponowne uruchomienie Eclipse. Tam wybierzeszYes.

Krok 3 - Weryfikacja wtyczki Gradle

Podczas weryfikacji utworzymy nowy projekt postępując zgodnie z podaną procedurą. W zaćmieniu przejdź do pliku -> kliknij nowy-> kliknij inne projekty. Znajdziesz tam następujący ekran. Tam wybierz projekt Gradle i kliknij dalej. Spójrz na poniższy zrzut ekranu.

Po kliknięciu następnego przycisku pojawi się następujący ekran. Tam podasz ścieżkę do katalogu domowego Gradle lokalnego systemu plików i kliknij przycisk Dalej. Spójrz na poniższy zrzut ekranu.

Spójrz na poniższy zrzut ekranu, tutaj podasz nazwę projektu Gradle. W tym samouczku używamydemoproject i kliknij przycisk Zakończ.

Spójrz na poniższy zrzut ekranu, gdzie musimy potwierdzić projekt. W tym celu na następnym ekranie kliknij przycisk Zakończ.

Krok 4 - Weryfikacja struktury katalogów

Po pomyślnej instalacji wtyczki Gradle sprawdź strukturę katalogów projektu demonstracyjnego pod kątem domyślnych plików i folderów, jak pokazano na poniższym zrzucie ekranu.