Cet article est une compilation de ce que les personnes inexpérimentées de Gradle ont appris sur le fonctionnement de Gradle et sur son utilisation.
environnement
référence
L'installation a été effectuée manuellement sans utiliser le gestionnaire de packages. Téléchargez le fichier d'archive à partir de la page Installer et extrayez-le à un emplacement approprié. Ajoutez le bac du répertoire extrait au chemin de la variable d'environnement.
** Vérification de la version **
> 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...]
À partir de SPRING INITIALIZR qui génère un modèle pour une application qui utilise Spring Boot, un modèle pour une application Web qui utilise Gradle pour la construction est généré et la construction. J'ai lu gradle.
Aussi, pour référence, un modèle utilisant Maven a été généré dans les mêmes conditions, et son pom.xml est posté ci-dessous.
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')
}
pom.xml est un fichier de configuration pour les builds maven, tandis que gradle build.gradle est un fichier de script de build écrit dans un langage de programmation appelé Groovy.
Dans cette partie appelée buildscript, j'ai ajouté le plugin spring-boot-gradle-plugin requis lors de l'exécution du fichier de script à la dépendance, ce qui rend le plugin org.springframework.boot disponible.
De plus, un tel {...} est appelé un bloc de script, et il existe d'autres dépôts et dépendances.
buildscript {
// A
ext {
springBootVersion = '1.5.9.RELEASE'
}
// B
repositories {
mavenCentral()
}
// C
dependencies {
classpath("org.springframework.boot:spring-boot-gradle-plugin:${springBootVersion}")
}
}
A
ext est un bloc de script appelé propriétés supplémentaires. Définissez la propriété ici.
B
Je mets en place un référentiel pour obtenir spring-boot-gradle-plugin. Cet exemple utilise le référentiel central de maven.
C
Nous ajoutons les dépendances nécessaires pour exécuter ce fichier de script. La description dans cette partie signifie ajouter une dépendance appelée spring-boot-gradle-plugin au chemin de classe lors de l'exécution du script.
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.
Une fois que vous avez appliqué un plugin, vous pourrez effectuer les tâches qu'il fournit.
// A
apply plugin: 'java'
// B
apply plugin: 'eclipse'
// C
apply plugin: 'org.springframework.boot'
A
[plug-in java] L'application (https://docs.gradle.org/4.4/userguide/java_plugin.html) vous permettra d'effectuer des tâches telles que la compilation du code source java et l'exécution de tests unitaires.
B
J'applique le plug-in eclipse. L'exécution de la tâche eclipse de ce plug-in générera un fichier de projet eclipse. Ce plug-in est un plug-in Gradle standard.
> gradle eclipse
Exécutez la tâche cleanEclipse si vous souhaitez effacer le fichier projet.
> gradle cleanEclipse
C
J'applique le plug-in Spring Boot. Vous pouvez exécuter l'application développée avec Spring Boot en exécutant la tâche bootRun de ce plug-in.
> gradle bootRun
Il ajoute également une tâche appelée bootRepackage qui dépend de la tâche d'assemblage.
> 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
Vous pouvez voir quelles tâches vous pouvez effectuer dans votre projet avec la tâche de tâches.
> gradle tasks
En plus de Java, Gradle prend également en charge Groovy, scala, etc. (Pas seulement ceci)
apply plugin: 'groovy'
apply plugin: 'scala'
groupe et version sont des propriétés liées au projet, et sourceCompatibility sont des propriétés utilisées par le plug-in java.
group = 'com.example'
version = '0.0.1-SNAPSHOT'
sourceCompatibility = 1.8
Le type de propriété référencé par le projet est Project dans la référence DSL et le type de propriété utilisé par le plug-in java. Se trouvent dans le Guide de l'utilisateur Chapitre 48. Le plugin Java.
Vous pouvez voir les propriétés de votre projet dans la tâche appropriée.
> gradle properties
Les propriétés uniques sont définies dans un bloc de script appelé ext.
Exemple
ext {
limitDate = '2017-12-01'
}
Dans les référentiels, définissez le référentiel pour résoudre les dépendances de construction et télécharger les artefacts. Dans cet exemple, la source de la bibliothèque définie comme dépendance est le référentiel central de maven.
repositories {
mavenCentral()
}
Lors de l'utilisation d'un référentiel maven local
mavenLocal()
Lors de l'utilisation du référentiel JCenter
jcenter()
Ajoutez des paramètres pour la bibliothèque dont dépend la construction du projet. compile, runtime, etc. sont appelés configurations de dépendances. Par exemple, compile définit les bibliothèques requises lors de la compilation du code source.
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')
}
Ce qui précède est une méthode de description abrégée (groupe: nom: version), et la dépendance peut également être décrite comme suit.
L'attribut version peut être omis en fonction du référentiel à utiliser.
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'
}
Pour spécifier une version arbitraire, spécifiez-la avec l'attribut version comme indiqué ci-dessous.
compileOnly group: 'org.projectlombok', name: 'lombok', version: '1.16.18'
Vous pouvez vérifier les dépendances du projet dans la tâche des dépendances.
> gradle dependencies
Vous pouvez également afficher uniquement des dépendances spécifiques en spécifiant l'option optionnelle --configuration.
> 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
Référence Spring Boot [B.3 Génération de vos propres méta-données à l'aide du processeur d'annotation](https://docs.spring.io/spring-boot/docs/1.5.9.RELEASE/reference/htmlsingle/#configuration- Il est décrit dans metadata-annotation-processor).
Dans le paramètre de dépendance dans maven, vous pouvez spécifier facultatif comme indiqué ci-dessous.
<dependency>
<groupId>org.springframework.boot</groupId>
<artifactId>spring-boot-configuration-processor</artifactId>
<optional>true</optional>
</dependency>
Pour faire la même chose avec Gradle, vous devez utiliser propdeps-plugin et effectuer les réglages suivants.
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)
Les tâches ajoutées par le plug-in Java et fréquemment utilisées sont les suivantes.
Exécutez la tâche de génération pour générer le projet.
> gradle clean build
L'exécution d'une tâche peut dépendre d'autres tâches. Vous trouverez ci-dessous une arborescence des dépendances des tâches de construction. (J'ai utilisé un plugin appelé com.dorongold.task-tree pour afficher l'arbre.)
Dans cette arborescence, vous pouvez voir que la tâche de construction dépend des tâches d'assemblage et de vérification.
> 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)
Vous pouvez définir et exécuter vos propres tâches dans build.gradle. Voici un exemple de définition de tâche de base.
task myTask {
description = 'My Task description'
group = 'My Tasks'
doLast {
println "running ${name}"
}
}
Utilisez un enregistreur pour sortir le journal.
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')
}
}
Vous pouvez sélectionner le niveau du journal de sortie dans les options de ligne de commande. S'il n'est pas spécifié, la valeur par défaut est LIFECYCLE. Le niveau de journalisation par défaut de println est défini sur QUIET.
> 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
Les options pouvant être spécifiées sont
Pour modifier le niveau de journalisation de println, ajoutez les paramètres suivants.
logging.captureStandardOutput LogLevel.INFO
Affiche des informations sur l'environnement de construction du projet.
> gradle buildEnvironment
Affiche des informations détaillées sur le composant.
> gradle components
Affichez les dépendances du projet dans une arborescence.
> gradle dependencies
> 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
Usage
Aucune application explicite du plug-in n'est requise.
The Build Init plugin is an automatically applied plugin, which means you do not need to apply it explicitly.
Tasks
Créez un modèle pour votre projet. JUnit est sélectionné comme cadre de test.
> gradle init --type java-library
Vous pouvez choisir TestNG ou spock au lieu de JUnit.
> gradle init --type java-library --test-framework testng
> gradle init --type java-library --test-framework spock
Wrapper Plugin
currently incubating
Tasks
wrapper
Générez un environnement d'exécution pour 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
> 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
> gradle buildDashboard
3rd party Plugin
Des plugins tiers peuvent être trouvés sur Gradle --Plugins.
Usage
apply plugin: 'org.springframework.boot'
Tasks
Usage
plugins {
id "org.flywaydb.flyway" version "5.0.3"
}
Tasks
Recommended Posts