- Spring Boot : commandes et guide complet CLI Java

spring

Spring Boot CLI - Interface en ligne de commande

spring --version

Affiche la version de Spring Boot CLI

spring init

Initialise un nouveau projet Spring Boot via Spring Initializr

spring init --dependencies=web,data-jpa,security myapp

Crée un projet avec dépendances web, JPA et sécurité

spring init --dependencies=web,actuator --build=maven myapp

Crée un projet Maven avec web et actuator

spring init --dependencies=web,devtools --build=gradle myapp

Crée un projet Gradle avec web et devtools

spring init --list

Liste toutes les dépendances Spring Boot disponibles

spring init --extract myapp.zip

Extrait le projet généré dans le dossier courant

spring init --java-version=17 myapp

Crée un projet avec Java 17

spring init --packaging=war myapp

Crée un projet au format WAR

spring run app.groovy

Exécute un script Groovy Spring Boot

spring jar app.jar *.groovy

Crée un JAR exécutable depuis des scripts Groovy

spring shell

Lance le shell interactif Spring Boot

spring encrypt monsecret

Chiffre une valeur avec Spring Crypto

spring decrypt {cipher}...

Déchiffre une valeur chiffrée

mvn spring-boot:run

Lance l'application Spring Boot avec Maven

mvn spring-boot:start

Démarre l'application en arrière-plan (pour tests d'intégration)

mvn spring-boot:stop

Arrête l'application démarrée avec spring-boot:start

mvn spring-boot:test-run

Lance l'application pour les tests

mvn spring-boot:build-image

Construit une image Docker OCI avec Cloud Native Buildpacks

mvn spring-boot:build-info

Génère le fichier build-info.properties

mvn spring-boot:help

Affiche l'aide des goals Spring Boot Maven

mvn spring-boot:repackage

Repackage le JAR/WAR en exécutable

mvn clean package

Compile et package l'application Spring Boot

mvn clean install

Compile, teste et installe l'artefact dans le dépôt local

mvn test

Lance les tests unitaires Maven

mvn dependency:tree

Affiche l'arbre des dépendances Maven

mvn dependency:analyze

Analyse les dépendances inutilisées ou déclarées

mvn versions:display-dependency-updates

Affiche les mises à jour disponibles des dépendances

mvn versions:display-plugin-updates

Affiche les mises à jour des plugins Maven

mvn versions:use-latest-releases

Met à jour les dépendances vers les dernières releases

./gradlew bootRun

Lance l'application Spring Boot avec Gradle

./gradlew bootJar

Crée un JAR exécutable avec Gradle

./gradlew bootWar

Crée un WAR exécutable avec Gradle

./gradlew bootBuildImage

Construit une image Docker avec Buildpacks (Gradle)

./gradlew bootRun --args='--server.port=9000'

Lance sur un port personnalisé

./gradlew build

Compile, teste et package l'application

./gradlew test

Lance les tests Gradle

./gradlew clean

Nettoie le répertoire de build

./gradlew dependencies

Affiche l'arbre des dépendances Gradle

./gradlew dependencyUpdates

Vérifie les mises à jour des dépendances (plugin versions)

java -jar target/myapp.jar

Exécute l'application Spring Boot packagée

java -jar myapp.jar --server.port=8081

Lance sur le port 8081

java -jar myapp.jar --spring.profiles.active=dev

Lance avec le profil 'dev'

java -jar myapp.jar --spring.config.location=file:./custom.yml

Lance avec un fichier de configuration externe

java -jar myapp.jar --debug

Lance en mode debug (logs détaillés)

java -jar myapp.jar --trace

Lance en mode trace (logs très détaillés)

java -Dserver.port=9000 -jar myapp.jar

Définit le port via propriété système

java -Xmx512m -Xms256m -jar myapp.jar

Lance avec mémoire JVM personnalisée

nohup java -jar myapp.jar &

Lance en arrière-plan avec nohup

./mvnw spring-boot:run

Utilise le wrapper Maven (mvnw) pour lancer l'application

./mvnw clean package

Package avec le wrapper Maven

./gradlew bootRun

Utilise le wrapper Gradle (gradlew) pour lancer l'application

docker build -t myapp .

Construit l'image Docker de l'application

docker run -p 8080:8080 myapp

Lance le conteneur Docker Spring Boot

docker run -e SPRING_PROFILES_ACTIVE=prod -p 8080:8080 myapp

Lance avec profil 'prod' via variable d'environnement

docker-compose up

Lance avec Docker Compose

docker-compose down

Arrête les conteneurs Docker Compose

mvn flyway:migrate

Exécute les migrations Flyway

mvn flyway:clean

Nettoie la base de données (supprime tous les objets)

mvn flyway:info

Affiche les informations de migration Flyway

mvn flyway:validate

Valide les migrations Flyway

mvn flyway:repair

Répare la table d'historique Flyway

mvn flyway:undo

Annule la dernière migration (version payante)

./gradlew flywayMigrate

Exécute les migrations Flyway avec Gradle

./gradlew flywayClean

Nettoie la base de données (Gradle)

mvn liquibase:update

Exécute les changements Liquibase

mvn liquibase:rollback

Annule les changements Liquibase

mvn liquibase:status

Affiche le statut des changements Liquibase

mvn liquibase:diff

Génère un diff entre base de données et changelog

mvn liquibase:generateChangeLog

Génère un changelog depuis la base de données

mvn jib:build

Construit une image Docker avec Jib (sans Docker daemon)

mvn jib:dockerBuild

Construit une image Docker locale avec Jib

mvn jib:buildTar

Sauvegarde l'image au format tar

./gradlew jib

Construit une image Docker avec Jib (Gradle)

./gradlew jibDockerBuild

Construit une image Docker locale avec Jib (Gradle)

mvn spring-javaformat:apply

Formate le code avec Spring JavaFormat

mvn spring-javaformat:validate

Valide le formatage du code

./gradlew format

Formate le code avec Spotless (Gradle)

./gradlew spotlessCheck

Vérifie le formatage avec Spotless

./gradlew spotlessApply

Applique le formatage Spotless

mvn checkstyle:check

Vérifie le style de code avec Checkstyle

./gradlew checkstyleMain

Vérifie le style du code source principal (Gradle)

./gradlew checkstyleTest

Vérifie le style du code de test (Gradle)

mvn pmd:pmd

Analyse statique du code avec PMD

mvn pmd:cpd

Détecte le code dupliqué avec CPD

./gradlew pmdMain

Analyse PMD du code source principal

mvn spotbugs:spotbugs

Détecte les bugs potentiels avec SpotBugs

mvn spotbugs:gui

Ouvre l'interface graphique SpotBugs

./gradlew spotbugsMain

Analyse SpotBugs du code principal (Gradle)

mvn jacoco:report

Génère le rapport de couverture JaCoCo

mvn jacoco:check

Vérifie les seuils de couverture JaCoCo

./gradlew jacocoTestReport

Génère le rapport JaCoCo (Gradle)

./gradlew jacocoTestCoverageVerification

Vérifie les seuils JaCoCo (Gradle)

mvn sonar:sonar

Analyse le projet avec SonarQube

./gradlew sonar

Analyse SonarQube avec Gradle

mvn spring-boot:run -Dspring-boot.run.profiles=dev,local

Lance avec plusieurs profils

mvn spring-boot:run -Dspring-boot.run.jvmArguments="-Xdebug -Xrunjdwp:transport=dt_socket,server=y,suspend=n,address=5005"

Lance avec débogueur distant

./gradlew bootRun --debug-jvm

Lance avec débogueur distant (Gradle)

mvn spring-boot:build-image -Dspring-boot.build-image.imageName=myregistry/myapp:latest

Construit et tague une image Docker

mvn spring-boot:build-image -Dspring-boot.build-image.publish=true

Construit et publie l'image vers un registre

mvn spring-boot:build-image -Dspring-boot.build-image.builder=paketobuildpacks/builder:full

Utilise un builder personnalisé

mvn test -Dtest=UserControllerTest

Lance une classe de test spécifique

mvn test -Dtest=UserControllerTest#testCreateUser

Lance une méthode de test spécifique

./gradlew test --tests UserControllerTest

Lance une classe de test spécifique (Gradle)

./gradlew test --tests "UserControllerTest.testCreateUser"

Lance une méthode de test spécifique (Gradle)

mvn spring-boot:run -Dspring-boot.run.arguments="--server.port=9090 --app.name=MyApp"

Passe des arguments à l'application

./gradlew bootRun --args='--server.port=9090 --app.name=MyApp'

Passe des arguments (Gradle)

mvn dependency:copy-dependencies

Copie toutes les dépendances dans target/dependency

mvn help:effective-pom

Affiche le POM effectif avec tous les héritages

mvn help:effective-settings

Affiche les settings Maven effectifs

mvn help:active-profiles

Affiche les profils Maven actifs

mvn help:all-profiles

Affiche tous les profils Maven disponibles

mvn dependency:purge-local-repository

Supprime les dépendances du dépôt local

mvn clean compile -U

Force la mise à jour des snapshots

mvn clean compile -o

Mode offline (pas de téléchargement)

mvn clean compile -X

Mode debug (logs très détaillés)

mvn clean compile -q

Mode silencieux (peu de logs)

mvn clean compile -T 4

Build parallèle avec 4 threads

mvn clean compile -T 1C

Build parallèle (1 thread par cœur CPU)

./gradlew build --parallel

Build parallèle avec Gradle

./gradlew build --scan

Génère un scan de build (Build Scan)

./gradlew build --profile

Génère un profil de performance du build

./gradlew build --dry-run

Simule le build sans exécuter

./gradlew build -x test

Build en excluant les tests

./gradlew build --refresh-dependencies

Rafraîchit les dépendances

./gradlew build --no-build-cache

Désactive le cache de build

./gradlew build --continuous

Mode continu (rebuilde sur changement)

./gradlew tasks

Liste toutes les tâches Gradle disponibles

./gradlew properties

Affiche toutes les propriétés Gradle

./gradlew wrapper --gradle-version=8.5

Met à jour le wrapper Gradle

mvn wrapper:wrapper

Génère le wrapper Maven

mvn wrapper:wrapper -Dmaven=3.9.6

Génère le wrapper Maven avec version spécifique

sdk install springboot

Installe Spring Boot CLI via SDKMAN

sdk use springboot 3.2.0

Utilise une version spécifique de Spring Boot CLI

brew install springboot

Installe Spring Boot CLI via Homebrew (macOS)

choco install springboot

Installe Spring Boot CLI via Chocolatey (Windows)

curl https://start.spring.io/starter.zip -o myapp.zip

Télécharge un projet depuis Spring Initializr

curl https://start.spring.io/starter.zip -d dependencies=web,data-jpa -d javaVersion=17 -o myapp.zip

Télécharge avec dépendances spécifiques

mvn release:prepare

Prépare une release Maven

mvn release:perform

Exécute la release Maven

mvn release:rollback

Annule une release Maven

mvn release:clean

Nettoie les fichiers de release

./gradlew release

Exécute une release avec le plugin Gradle Release

mvn git-commit-id:revision

Génère les informations Git dans le build

mvn spring-boot:run -Dspring-boot.run.fork=false

Lance sans forker (même JVM)

mvn spring-boot:run -Dspring-boot.run.workingDirectory=/path/to/dir

Lance avec un répertoire de travail spécifique

mvn spring-boot:run -Dspring-boot.run.skip=true

Ignore l'exécution du plugin

mvn spring-boot:test-run -Dspring-boot.run.arguments="--server.port=0"

Lance pour tests sur port aléatoire

mvn spring-boot:build-info -Dspring-boot.build-info.skip=false

Génère build-info.properties