Plug-in Spring Boot Gradle

1. Vue d'ensemble

Le plugin Spring Boot Gradle nous aide à gérer les dépendances de Spring Boot, ainsi que le package et l'exécution de notre application lorsque vous utilisez Gradle comme outil de construction.

Dans ce tutoriel, nous discuterons de la façon dont nous pouvons ajouter et configurer le plugin, puis nous verrons comment créer et exécuter un projet Spring Boot.

2. Configuration du fichier de construction

Tout d'abord, nous devons ajouter le plugin Spring Boot à notre fichier build.gradle en l'incluant dans notre section plugins :

plugins { id "org.springframework.boot" version "2.0.1.RELEASE" }

Si nous utilisons une version de Gradle antérieure à 2.1 ou si nous avons besoin d'une configuration dynamique, nous pouvons l'ajouter comme ceci à la place:

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

3. Emballage de notre application

Nous pouvons empaqueter notre application dans une archive exécutable (fichier jar ou war) en la construisant à l'aide de la commande build :

./gradlew build

En conséquence, l'archive exécutable générée sera placée dans le répertoire build / libs .

Si nous voulons générer un fichier jar exécutable , nous devons également appliquer le plugin java :

apply plugin: 'java'

D'un autre côté, si nous avons besoin d'un fichier war , nous appliquerons le plugin war :

apply plugin: 'war'

La construction de l'application générera des archives exécutables pour Spring Boot 1.x et 2.x. Cependant, pour chaque version, Gradle déclenche différentes tâches.

Ensuite, examinons de plus près le processus de construction pour chaque version de démarrage.

3.1. Spring Boot 2.x

Dans Boot 2.x, les tâches bootJar et bootWar sont responsables de l'empaquetage de l'application.

La tâche bootJar est responsable de la création du fichier jar exécutable . Ceci est créé automatiquement une fois que le plugin java est appliqué.

Voyons comment nous pouvons exécuter la tâche bootJar directement:

./gradlew bootJar

De même, bootWar génère un fichier war exécutable et est créé une fois que le plugin war est appliqué.

Nous pouvons exécuter la tâche bootWar en utilisant:

./gradlew bootWar

Notez que pour Spring Boot 2.x, nous devons utiliser Gradle 4.0 ou version ultérieure.

Nous pouvons également configurer les deux tâches. Par exemple, définissons la classe principale à l'aide de la propriété mainClassName :

bootJar { mainClassName = 'com.baeldung.Application' }

Alternativement, nous pouvons utiliser la même propriété à partir du DSL Spring Boot:

springBoot { mainClassName = 'com.baeldung.Application' }

3.2. Spring Boot 1.x

Avec Spring Boot 1.x, bootRepackage est responsable de la création de l'archive exécutable ( fichier jar ou war selon la configuration.

Nous pouvons exécuter la tâche bootRepackage directement en utilisant:

./gradlew bootRepackage

Semblable à la version Boot 2.x, nous pouvons ajouter des configurations à la tâche bootRepackage dans notre build.gradle:

bootRepackage { mainClass = 'com.example.demo.Application' }

Nous pouvons également désactiver la tâche bootRepackage en définissant l' option enabled sur false:

bootRepackage { enabled = false }

4. Exécution de notre application

Après avoir construit l'application, nous pouvons simplement l'exécuter en utilisant la commande java -jar sur le fichier jar exécutable généré:

java -jar build/libs/demo.jar

Le plugin Spring Boot Gradle nous fournit également la tâche bootRun qui nous permet d'exécuter l'application sans avoir besoin de la construire au préalable:

./gradlew bootRun

La tâche bootRun peut être simplement configurée dans build.gradle.

Par exemple, nous pouvons définir la classe principale:

bootRun { main = 'com.example.demo.Application' }

5. Relation avec d'autres plugins

5.1. Plugin de gestion des dépendances

Pour Spring Boot 1.x, il appliquait automatiquement le plugin de gestion des dépendances. Cela importerait la nomenclature des dépendances Spring Boot et agirait de la même manière que la gestion des dépendances pour Maven.

Mais depuis Spring Boot 2.x, nous devons l'appliquer explicitement dans notre build.gradle si nous avons besoin de cette fonctionnalité:

apply plugin: 'io.spring.dependency-management'

5.2. Plugin Java

Lorsque nous appliquons le plugin java , le plugin Spring Boot Gradle effectue plusieurs actions telles que:

  • créer une tâche bootJar , que nous pouvons utiliser pour générer un fichier jar exécutable
  • créer une tâche bootRun , que nous pouvons utiliser pour exécuter directement notre application
  • désactivation de la tâche jar

5.3. Plugin de guerre

De même, lorsque nous appliquons le plugin war , cela se traduit par:

  • création de la tâche bootWar , que nous pouvons utiliser pour générer un fichier war exécutable
  • désactivation de la tâche de guerre

6. Conclusion

Dans ce rapide tutoriel, nous avons découvert le plugin Spring Boot Gradle et ses différentes tâches.

En outre, nous avons discuté de la façon dont il interagit avec d'autres plugins.