Création de JAR exécutables (fat JARs)

Qu'est-ce qu'un JAR exécutable (Fat JAR) ?

Traditionnellement, les applications web Java étaient packagées sous forme de fichiers WAR (Web Application Archive), destinés à être déployés sur un serveur d'applications externe (comme Tomcat, Jetty, JBoss/Wildfly). Un fichier WAR contient le code compilé de l'application, ses ressources, mais *pas* les bibliothèques (dépendances) du serveur lui-même.

Spring Boot adopte une approche différente et favorise la création de JARs exécutables, souvent appelés "Fat JARs" (ou parfois "Uber JARs"). Un Fat JAR est un fichier `.jar` unique qui contient non seulement le code compilé de votre application (`.class` files) et ses ressources (fichiers de configuration, templates, etc.), mais aussi toutes les bibliothèques dont votre application dépend (les JARs des dépendances comme Spring Core, Spring MVC, Hibernate, Jackson, etc.).

De plus, un Fat JAR Spring Boot inclut un lanceur spécial (`org.springframework.boot.loader.*`) qui sait comment charger les classes et les dépendances depuis l'intérieur du JAR lui-même, ainsi qu'un serveur web embarqué (comme Tomcat, Jetty ou Undertow, si vous développez une application web). Cela rend l'application entièrement autonome et exécutable avec une simple commande `java -jar`.

Avantages des Fat JARs

L'utilisation de Fat JARs présente plusieurs avantages significatifs, en particulier dans les architectures modernes (microservices, cloud) :

• Simplicité de déploiement : Il n'y a qu'un seul fichier à copier et à exécuter. Pas besoin d'installer et de configurer un serveur d'applications externe au préalable.
• Autonomie : L'application embarque tout ce dont elle a besoin pour fonctionner (y compris le serveur web), ce qui élimine les conflits de versions de bibliothèques entre l'application et un serveur externe.
• Cohérence : L'environnement d'exécution est exactement le même en développement, en test et en production, car il est défini par les dépendances packagées dans le JAR.
• Facilité d'utilisation : Le lancement est standardisé avec la commande `java -jar mon-app.jar`.
• Adapté aux conteneurs : Le format Fat JAR est idéal pour la conteneurisation avec Docker, car il suffit de copier le JAR dans l'image et de définir la commande `java -jar` comme point d'entrée.

Comment Spring Boot crée les Fat JARs : les plugins de build

La magie derrière la création des Fat JARs dans Spring Boot réside dans les plugins de build spécifiques fournis pour Maven et Gradle :

• Maven : `spring-boot-maven-plugin`
• Gradle : `org.springframework.boot` (plugin Gradle)

Lorsque vous générez un projet via Spring Initializr, ces plugins sont automatiquement inclus et configurés. Leur rôle principal, en ce qui concerne le packaging, est d'exécuter une tâche spécifique (`repackage` pour Maven, `bootJar` pour Gradle) après la compilation standard et la création d'un JAR "classique".

Cette tâche de "repackaging" prend le JAR initial (contenant uniquement le code de votre application) et le réorganise en intégrant :

• Les JARs de toutes les dépendances dans un répertoire interne (généralement `BOOT-INF/lib/`).
• Les classes compilées de votre application dans un autre répertoire interne (généralement `BOOT-INF/classes/`).
• Les classes du lanceur Spring Boot (`org.springframework.boot.loader.*`) à la racine du JAR.
• Un `Manifest` spécial pointant vers la classe de lancement (`JarLauncher`, `WarLauncher`, etc.).

Le résultat est un JAR exécutable directement par la JVM via `java -jar`.

Configuration avec Maven

Dans un projet Maven, la configuration essentielle se trouve dans le `pom.xml`. Le `spring-boot-starter-parent` définit généralement des configurations par défaut, mais le plugin clé est le `spring-boot-maven-plugin`.

    
        
            org.springframework.boot
            spring-boot-maven-plugin
            
            
            
            
            
                
                    
                        repackage
                    
                
            
        
    

Pour construire le Fat JAR, exécutez la commande Maven standard :

mvn package

Cela générera deux fichiers JAR dans le répertoire `target/` :

• `my-app-1.0.0.jar` : Le Fat JAR exécutable.
• `my-app-1.0.0.jar.original` : Le JAR fin original créé par Maven avant le repackaging (utile dans certains cas spécifiques).

Configuration avec Gradle

Dans un projet Gradle, le plugin `org.springframework.boot` doit être appliqué dans le fichier `build.gradle` ou `build.gradle.kts`.

Exemple (`build.gradle` - Groovy DSL):

plugins {
    id 'org.springframework.boot' version '3.x.x' // Utilisez la version appropriée
    id 'io.spring.dependency-management' version '1.x.x'
    id 'java'
}

// ... configurations de groupe, version, dépendances ...

// Le plugin Spring Boot configure automatiquement la tâche 'bootJar'
// Vous pouvez la personnaliser si nécessaire :
bootJar {
    // mainClass = 'com.example.myapp.MyApplication' // Souvent détecté automatiquement
    // archiveFileName = 'custom-app-name.jar'
}

// La tâche 'bootJar' est généralement liée à la tâche 'assemble' ou 'build'

Pour construire le Fat JAR, exécutez la tâche Gradle appropriée :

./gradlew bootJar 
# Ou souvent simplement :
./gradlew build

Cela générera le Fat JAR exécutable dans le répertoire `build/libs/`.

Exécution du Fat JAR

Une fois le Fat JAR construit, son exécution est très simple. Ouvrez un terminal, naviguez jusqu'au répertoire contenant le JAR (`target/` pour Maven, `build/libs/` pour Gradle) et lancez la commande :

java -jar my-app-1.0.0.jar

(Remplacez `my-app-1.0.0.jar` par le nom réel de votre fichier JAR).

La JVM utilisera le lanceur embarqué pour démarrer l'application Spring Boot et le serveur web intégré (si applicable). Vous verrez les logs de démarrage de Spring Boot dans la console.

Vous pouvez également passer des arguments de ligne de commande Spring Boot ou des propriétés système Java :

# Passer une propriété Spring Boot
java -jar my-app-1.0.0.jar --server.port=9090

# Passer une propriété système Java
java -Dspring.profiles.active=prod -jar my-app-1.0.0.jar

Considérations

Le principal inconvénient potentiel des Fat JARs est leur taille. Comme ils incluent toutes les dépendances, ils peuvent devenir assez volumineux (plusieurs dizaines, voire centaines de mégaoctets). Cela peut avoir un impact sur les temps de transfert et le stockage, notamment dans les environnements conteneurisés.

Pour optimiser la création d'images Docker et améliorer les temps de démarrage dans certains scénarios, Spring Boot propose des fonctionnalités comme les "Layered JARs" (ou "Exploded JARs") et l'intégration avec les Buildpacks Cloud Native, qui permettent de séparer les dépendances (qui changent moins souvent) du code applicatif. Ces techniques sont abordées plus en détail dans les sections relatives à la conteneurisation et à l'optimisation.

Néanmoins, pour de nombreuses applications, la simplicité et l'autonomie offertes par le format Fat JAR standard constituent un excellent point de départ et une méthode de packaging très efficace.