Überblick

Dieser Artikel ist eine Zusammenstellung dessen, was Gradle-Unerfahrene über die Funktionsweise und Verwendung von Gradle gelernt haben.

Umgebung

Windows 10 Professional
Gradle 4.4
- Groovy 2.4.12
Java 1.8.0_144

Referenz

Installation

Die Installation wurde manuell ohne Verwendung des Paketmanagers durchgeführt. Laden Sie die Archivdatei von der Seite Install herunter und extrahieren Sie sie an einen geeigneten Speicherort. Fügen Sie den Bin im extrahierten Verzeichnis zum Pfad der Umgebungsvariablen hinzu.

** Versionsprüfung **

> gradle -v

------------------------------------------------------------
Gradle 4.4
------------------------------------------------------------

Build time:   2017-12-06 09:05:06 UTC
Revision:     cf7821a6f79f8e2a598df21780e3ff7ce8db2b82

Groovy:       2.4.12
Ant:          Apache Ant(TM) version 1.9.9 compiled on February 2 2017
JVM:          1.8.0_144 (Oracle Corporation 25.144-b01)
OS:           Windows 10 10.0 amd64

Usage

gradle [option...] [task...]

Wie lese ich build.gradle

Aus SPRING INITIALIZR, das eine Vorlage für eine Anwendung generiert, die Spring Boot verwendet, wird eine Vorlage für eine Webanwendung generiert, die Gradle für die Erstellung verwendet, und die Erstellung. Ich lese gradle.

Als Referenz wurde unter den gleichen Bedingungen eine Vorlage mit Maven erstellt, deren pom.xml unten aufgeführt ist.

Maven

`pom.xml`


<?xml version="1.0" encoding="UTF-8"?>
<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</groupId>
	<artifactId>demo</artifactId>
	<version>0.0.1-SNAPSHOT</version>
	<packaging>jar</packaging>

	<name>demo</name>
	<description>Demo project for Spring Boot</description>

	<parent>
		<groupId>org.springframework.boot</groupId>
		<artifactId>spring-boot-starter-parent</artifactId>
		<version>1.5.9.RELEASE</version>
		<relativePath/> <!-- lookup parent from repository -->
	</parent>

	<properties>
		<project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
		<project.reporting.outputEncoding>UTF-8</project.reporting.outputEncoding>
		<java.version>1.8</java.version>
	</properties>

	<dependencies>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-thymeleaf</artifactId>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-web</artifactId>
		</dependency>

		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-devtools</artifactId>
			<scope>runtime</scope>
		</dependency>
		<dependency>
			<groupId>org.projectlombok</groupId>
			<artifactId>lombok</artifactId>
			<optional>true</optional>
		</dependency>
		<dependency>
			<groupId>org.springframework.boot</groupId>
			<artifactId>spring-boot-starter-test</artifactId>
			<scope>test</scope>
		</dependency>
	</dependencies>

	<build>
		<plugins>
			<plugin>
				<groupId>org.springframework.boot</groupId>
				<artifactId>spring-boot-maven-plugin</artifactId>
			</plugin>
		</plugins>
	</build>

</project>

Gradle

`build.gradle`


// 1
buildscript {
	ext {
		springBootVersion = '1.5.9.RELEASE'
	}
	repositories {
		mavenCentral()
	}
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
	}
}

// 2
apply plugin: 'java'
apply plugin: 'eclipse'
apply plugin: 'org.springframework.boot'

// 3
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

// 4
repositories {
	mavenCentral()
}

// 5
dependencies {
	compile('org.springframework.boot:spring-boot-starter-thymeleaf')
	compile('org.springframework.boot:spring-boot-starter-web')
	runtime('org.springframework.boot:spring-boot-devtools')
	compileOnly('org.projectlombok:lombok')
	testCompile('org.springframework.boot:spring-boot-starter-test')
}

1. Einstellungen, die zum Ausführen des Skripts erforderlich sind

pom.xml ist eine Konfigurationsdatei für Maven-Builds, während gradle build.gradle eine Build-Skriptdatei ist, die in einer Programmiersprache namens Groovy geschrieben ist.

In diesem Teil namens Buildscript habe ich das Spring-Boot-Gradle-Plugin hinzugefügt, das beim Ausführen der Skriptdatei für die Abhängigkeit erforderlich ist, wodurch das Plug-In org.springframework.boot verfügbar wird.

Ein solches "{...}" wird auch als Skriptblock bezeichnet, und es gibt andere Repositorys und Abhängigkeiten.

buildscript {
	// A
	ext {
		springBootVersion = '1.5.9.RELEASE'
	}
	// B
	repositories {
		mavenCentral()
	}
	// C
	dependencies {
		classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
	}
}

ext ist ein Skriptblock, der als zusätzliche Eigenschaften bezeichnet wird. Definieren Sie hier die Eigenschaft.

Ich richte ein Repository ein, um das Spring-Boot-Gradle-Plugin zu erhalten. In diesem Beispiel wird das zentrale Repository von maven verwendet.

Wir fügen die Abhängigkeiten hinzu, die zum Ausführen dieser Skriptdatei erforderlich sind. Die Beschreibung in diesem Teil bedeutet, dass beim Ausführen des Skripts dem Klassenpfad eine Abhängigkeit namens spring-boot-gradle-plugin hinzugefügt wird.

43.6. External dependencies for the build script

If your build script needs to use external libraries, you can add them to the script’s classpath in the build script itself.

2. Anwenden des Plug-Ins

Sobald Sie ein Plugin angewendet haben, können Sie die darin enthaltenen Aufgaben ausführen.

// A
apply plugin: 'java'
// B
apply plugin: 'eclipse'
// C
apply plugin: 'org.springframework.boot'

[Java Plug-In] Durch Anwenden (https://docs.gradle.org/4.4/userguide/java_plugin.html) können Sie Aufgaben wie das Kompilieren von Java-Quellcode und das Ausführen von Komponententests ausführen.

Ich wende das Eclipse-Plug-In an. Durch Ausführen der Eclipse-Task dieses Plug-Ins wird eine Eclipse-Projektdatei generiert. Dieses Plug-In ist ein Standard-Gradle-Plug-In.

> gradle eclipse

Wenn Sie die Projektdatei löschen möchten, führen Sie die cleanEclipse-Task aus.

> gradle cleanEclipse

Ich wende das Spring Boot Plug-In an. Sie können die mit Spring Boot entwickelte Anwendung ausführen, indem Sie die BootRun-Task dieses Plug-Ins ausführen.

> gradle bootRun

Außerdem wird eine Aufgabe namens bootRepackage hinzugefügt, die von der Assemble-Aufgabe abhängt.

> gradle help --task bootRepackage

> Task :help
Detailed task information for bootRepackage

Path
     :bootRepackage

Type
     RepackageTask (org.springframework.boot.gradle.repackage.RepackageTask)

Description
     Repackage existing JAR and WAR archives so that they can be executed from the command line using 'java -jar'

Group
     build

Überprüfen Sie die verfügbaren Aufgaben

Mit der Aufgabenaufgabe können Sie sehen, welche Aufgaben Sie in Ihrem Projekt ausführen können.

> gradle tasks

Unterstützte Programmiersprachen

Neben Java unterstützt Gradle auch Groovy, Scala usw. (Nicht nur das)

Groovy

apply plugin: 'groovy'

Scala

apply plugin: 'scala'

3. Festlegen von Eigenschaften, auf die beim Ausführen des Skripts verwiesen wird

Gruppe und Version sind projektbezogene Eigenschaften, und sourceCompatibility sind Eigenschaften, die vom Java-Plug-In verwendet werden.

group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8

Der vom Projekt referenzierte Eigenschaftstyp ist Projekt in der DSL-Referenz und der vom Java-Plug-In verwendete Eigenschaftstyp. Weitere Informationen finden Sie im Benutzerhandbuch, Kapitel 48. Das Java-Plugin (https://docs.gradle.org/4.4/userguide/java_plugin.html).

Sie können sehen, welche Eigenschaften Ihr Projekt in der eigentlichen Aufgabe hat.

> gradle properties

Definieren Sie Ihre eigenen Eigenschaften

Eindeutige Eigenschaften werden in einem Skriptblock namens ext definiert.

`Beispiel`


ext {
  limitDate = '2017-12-01'
}

4. Repository-Einstellungen

Legen Sie in Repositorys das Repository so fest, dass Buildabhängigkeiten aufgelöst und Artefakte hochgeladen werden. In diesem Beispiel ist die Quelle der als Abhängigkeit festgelegten Bibliothek das zentrale Repository von maven.

repositories {
	mavenCentral()
}

Bei Verwendung eines lokalen Maven-Repositorys

mavenLocal()

Bei Verwendung des JCenter-Repositorys

jcenter()

5. Fügen Sie externe Abhängigkeiten hinzu

Fügen Sie Einstellungen für die Bibliothek hinzu, von der die Projekterstellung abhängt. Kompilieren, Laufzeit usw. werden als Abhängigkeitskonfigurationen bezeichnet. Beispielsweise legt Kompilieren die Bibliotheken fest, die beim Kompilieren des Quellcodes erforderlich sind.

dependencies {
	compile('org.springframework.boot:spring-boot-starter-thymeleaf')
	compile('org.springframework.boot:spring-boot-starter-web')
	runtime('org.springframework.boot:spring-boot-devtools')
	compileOnly('org.projectlombok:lombok')
	testCompile('org.springframework.boot:spring-boot-starter-test')
}

Das Obige ist eine verkürzte Beschreibungsmethode (group: name: version), und die Abhängigkeit kann auch wie folgt beschrieben werden. Das Versionsattribut kann abhängig vom zu verwendenden Repository weggelassen werden.

dependencies {
	compile group: 'org.springframework.boot', name: 'spring-boot-starter-thymeleaf'
	compile group: 'org.springframework.boot', name: 'spring-boot-starter-web'
	runtime group: 'org.springframework.boot', name: 'spring-boot-devtools'
	compileOnly group: 'org.projectlombok', name: 'lombok'
	testCompile group: 'org.springframework.boot', name: 'spring-boot-starter-test'
}

Um eine beliebige Version anzugeben, geben Sie sie wie unten gezeigt mit dem Versionsattribut an.

compileOnly group: 'org.projectlombok', name: 'lombok', version: '1.16.18'

Sie können die Projektabhängigkeiten in der Abhängigkeitsaufgabe überprüfen.

> gradle dependencies

Sie können auch nur bestimmte Abhängigkeiten ausgeben, indem Sie die optionale --configuration angeben.

> gradle dependencies --configuration compileOnly

> Task :dependencies

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

compileOnly - Compile only dependencies for source set 'main'.
\--- org.projectlombok:lombok: -> 1.16.18

BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed

Optionale Abhängigkeiten

Spring Boot-Referenz [B.3 Generieren eigener Metadaten mit dem Anmerkungsprozessor](https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#configuration- Es wird im Metadaten-Annotations-Prozessor beschrieben.

In der Abhängigkeitseinstellung in maven können Sie optional angeben, wie unten gezeigt.

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-configuration-processor</artifactId>
    <optional>true</optional>
</dependency>

Um dasselbe mit Gradle zu tun, müssen Sie propdeps-plugin verwenden und die folgenden Einstellungen vornehmen.

buildscript {
	repositories {
		maven { url 'http://repo.spring.io/plugins-release' }
	}
	dependencies {
		classpath('io.spring.gradle:propdeps-plugin:0.0.9.RELEASE')
	}
}

apply plugin: 'propdeps'

dependencies {
    optional("org.springframework.boot:spring-boot-configuration-processor")
}

compileJava.dependsOn(processResources)

Eine Aufgabe ausführen

Folgende Aufgaben werden vom Java-Plug-In hinzugefügt und häufig verwendet.

clean: Löscht das Build-Verzeichnis des Projekts
build: Erstelle das Projekt
test: Führen Sie einen Komponententest durch

Führen Sie die Build-Task aus, um das Projekt zu erstellen.

> gradle clean build

Überprüfen Sie die Aufgabenabhängigkeiten

Die Ausführung einer Aufgabe kann von anderen Aufgaben abhängen. Unten finden Sie eine Baumansicht der Abhängigkeiten der Build-Task. (Ich habe ein Plugin namens com.dorongold.task-tree verwendet, um den Baum anzuzeigen.)

In diesem Baum können Sie sehen, dass die Build-Aufgabe von den Assembler- und Check-Tasks abhängt.

> gradle build taskTree --no-repeat

> Task :taskTree

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

:build
+--- :assemble
|    +--- :bootRepackage
|    |    +--- :findMainClass
|    |    |    \--- :classes
|    |    |         +--- :compileJava
|    |    |         \--- :processResources
|    |    \--- :jar
|    |         \--- :classes *
|    \--- :jar *
\--- :check
     \--- :test
          +--- :classes *
          \--- :testClasses
               +--- :compileTestJava
               |    \--- :classes *
               \--- :processTestResources


(*) - subtree omitted (printed previously)

Aufgabendefinition

Sie können Ihre eigenen Aufgaben in build.gradle definieren und ausführen. Unten finden Sie eine grundlegende Beispielaufgabendefinition.

task myTask {
    description = 'My Task description'
    group = 'My Tasks'

    doLast {
        println "running ${name}"
    }
}

Protokollierung

Protokollstufe

ERROR
QUIET
WARNING
LIFECYCLE
INFO
DEBUG

Protokollausgabe

Verwenden Sie den Logger, um das Protokoll auszugeben.

task logOutput {

	doLast {
		logger.error('error log message')
		logger.quiet('quiet log message')
		logger.warn('warning log message')
		logger.lifecycle('lifecycle log message')
		logger.info('info log message')
		logger.debug('debug log message')
		logger.trace('trace log message')
		println('log message via println')
	}

}

Sie können die Ausgabeprotokollebene in den Befehlszeilenoptionen auswählen. Wenn nicht angegeben, ist der Standardwert LIFECYCLE. Die Standardprotokollstufe von println ist auf QUIET eingestellt.

> gradle logOutput

> Task :logOutput
error log message
quiet log message
warning log message
lifecycle log message
log message via println

BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed

Folgende Optionen können angegeben werden

-q (--quiet): RUHIG oder höher
-w (--warn): WARNUNG und höher
-i (--info): INFO und höher
-d (--debug): DEBUG und höher

Fügen Sie die folgenden Einstellungen hinzu, um die Protokollstufe von println zu ändern.

logging.captureStandardOutput LogLevel.INFO

Ergänzung

Andere Aufgaben

buildEnvironment

Zeigt Informationen zur Build-Umgebung des Projekts an.

> gradle buildEnvironment

components

Zeigt detaillierte Informationen zur Komponente an.

> gradle components

dependencies

Projektabhängigkeiten in einer Baumansicht anzeigen.

> gradle dependencies

dependencyInsight

> gradle dependencyInsight --dependency org.springframework:spring-webmvc

> Task :dependencyInsight
org.springframework:spring-webmvc:4.3.13.RELEASE (selected by rule)
\--- org.springframework.boot:spring-boot-starter-web:1.5.9.RELEASE
     +--- compileClasspath
     \--- org.springframework.boot:spring-boot-starter-thymeleaf:1.5.9.RELEASE
          \--- compileClasspath

(*) - dependencies omitted (listed previously)


BUILD SUCCESSFUL in 1s
1 actionable task: 1 executed

projects

> gradle projects

properties

> gradle properties

tasks

> gradle tasks

> gradle tasks --all

help

> gradle help --task <task name>

Build Init Plugin

currently incubating

Chapter 17. Build Init Plugin

Usage

Es ist keine explizite Anwendung des Plug-Ins erforderlich.

The Build Init plugin is an automatically applied plugin, which means you do not need to apply it explicitly.

Tasks

init
wrapper

Init-Aufgabe

Erstellen Sie eine Vorlage für Ihr Projekt. JUnit wird als Testframework ausgewählt.

> gradle init --type java-library

Sie können TestNG oder Spock anstelle von JUnit wählen.

> gradle init --type java-library --test-framework testng

> gradle init --type java-library --test-framework spock

Wrapper Plugin

currently incubating

Chapter 23. Wrapper Plugin

Tasks

wrapper

wrapper

Generieren Sie eine Ausführungsumgebung für Gradle.

> gradle wrapper

> gradle wrapper --gradle-version=4.4

> gradle wrapper --distribution-type=ALL --gradle-version=4.4

Project Report Plugin

Chapter 29. The Project Report Plugin

Usage

apply plugin: 'project-report'

Tasks

dependencyReport
htmlDependencyReport
propertyReport
taskReport
projectReport

dependencyReport

> gradle dependencyReport

> gradle dependencyReport --configuration default

htmlDependencyReport

> gradle htmlDependencyReport

propertyReport

> gradle propertyReport

taskReport

> gradle taskReport

> gradle taskReport --all

projectReport

> gradle projectReport

Build Dashboard Plugin

currently incubating

Chapter 30. The Build Dashboard Plugin

Usage

apply plugin: 'build-dashboard'

Tasks

buildDashboard

buildDashboard

> gradle buildDashboard

3rd party Plugin

Plugins von Drittanbietern finden Sie unter Gradle --Plugins.

Spring Boot Gradle plugin

Usage

apply plugin: 'org.springframework.boot'

Tasks

bootRepackage
bootRun

Flyway Gradle plugin

Usage

plugins {
    id "org.flywaydb.flyway" version "5.0.3"
}

Tasks

flywayInfo
flywayBaseline
flywayMigrate
flywayRepair
flywayValidate
flywayClean

[JAVA] Lernen Sie den rudimentären Mechanismus und die Verwendung von Gradle 4.4 kennen

Überblick

Installation

Wie lese ich build.gradle

pom.xml

build.gradle

1. Einstellungen, die zum Ausführen des Skripts erforderlich sind

2. Anwenden des Plug-Ins

Überprüfen Sie die verfügbaren Aufgaben

Unterstützte Programmiersprachen

3. Festlegen von Eigenschaften, auf die beim Ausführen des Skripts verwiesen wird

Definieren Sie Ihre eigenen Eigenschaften

Beispiel

4. Repository-Einstellungen

5. Fügen Sie externe Abhängigkeiten hinzu

Optionale Abhängigkeiten

Eine Aufgabe ausführen

Überprüfen Sie die Aufgabenabhängigkeiten

Aufgabendefinition

Protokollierung

Protokollstufe

Protokollausgabe

Ergänzung

Andere Aufgaben

Init-Aufgabe

`pom.xml`

`build.gradle`

`Beispiel`