TOC

Spring Boot Gradle Plugin

Spring Plug Gradle Plugin

1. Vue d'ensemble

Le plugin Spring Boot Gradle nous aide à gérer les dépendances de Spring Boot, ainsi qu'à empaqueter et à exécuter notre application lorsque vous utilisez Gradle comme outil de construction.

Dans ce didacticiel, nous verrons comment ajouter et configurer le plug-in, puis nous verrons comment créer et exécuter un projet Spring Boot.

2. Configuration du fichier de construction

Tout d'abord, le fichierwe need to add the Spring Boot plugin to our build.gradle en l'incluant dans notre sectionplugins: 

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

./gradlew build

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

Si nous voulons générer un fichier exécutablejar, nous devons également appliquer le pluginjava: 

apply plugin: 'java'

D'un autre côté, si nous avons besoin d'un fichierwar, nous appliquerons le pluginwar: 

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 compilation pour chaque version de démarrage.

3.1. Spring Boot 2.x

Dans Boot 2.x, les tâchesbootJar etbootWar sont responsables de l'empaquetage de l'application.

La tâchebootJar est responsable de la création du fichier exécutablejar. Celui-ci est créé automatiquement une fois le pluginjava appliqué.

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

./gradlew bootJar

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

Nous pouvons exécuter la tâchebootWar 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 en utilisant la propriétémainClassName: 

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

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

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

3.2. Spring Boot 1.x

FichierWith Spring Boot 1.x, bootRepackage is responsible for creating the executable archive(jar ouwar selon la configuration.

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

./gradlew bootRepackage

Similaire à la version Boot 2.x, nous pouvons ajouter des configurations à la tâchebootRepackage dans nosbuild.gradle: 

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

Nous pouvons également désactiver la tâchebootRepackage en définissant l'optionenabled surfalse: 

bootRepackage {
    enabled = false
}

4. Lancer notre application

Après avoir construit l'application,we can just run it by using the java -jar command sur le fichier jar exécutable généré: 

java -jar build/libs/demo.jar

Spring Boot Gradle plugin also provides us with the bootRun task qui nous permet d'exécuter l'application sans avoir besoin de la construire au préalable: 

./gradlew bootRun

La tâchebootRun peut être simplement configurée enbuild.gradle.

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

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

5. Relation avec d'autres plugins

5.1. Plug-in de gestion des dépendances

Pour Spring Boot 1.x, il appliquait automatiquement le plug-in 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 nosbuild.gradle si nous avons besoin de cette fonctionnalité: 

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

5.2. Plugin Java

Lorsque nous appliquons le pluginjava, le plugin Spring Boot Gradle effectue plusieurs actions comme:

  • création de la tâchea bootJar, que nous pouvons utiliser pour générer un fichier jar exécutable

  • création de la tâchea bootRun, que nous pouvons utiliser pour exécuter directement notre application

  • désactivation de la tâchejar

5.3. Plugin de guerre

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

  • création de la tâchebootWar, que nous pouvons utiliser pour générer un fichier war exécutable

  • désactivation de la tâchewar

6. Conclusion

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

Nous avons également discuté de la façon dont il interagit avec les autres plugins.

Related