Spring Boot 4 : Tout Comprendre, des Nouveautés à la Migration Complète

Article rédigé par Abdelaziz LOUARIT,
Développeur Java chez MARGO.

Introduction

Spring Boot 4 marque une étape importante pour l’écosystème Java moderne.
Après plusieurs années de stabilisation autour de Spring Boot 3, cette nouvelle version poursuit trois objectifs : simplifier la vie des équipes, consolider les bonnes pratiques cloud-native et accélérer encore le démarrage et l’observabilité.

Basé sur Spring Framework 7.x, il consolide les avancées des versions précédentes tout en introduisant des fonctionnalités natives dédiées à la résilience, l’observabilité et la performance.

Aligné sur Java 17 (LTS) désormais requis comme minimum et sur Jakarta EE 11, Spring Boot 4 vise clairement les applications cloud-native et serverless, avec une réduction notable des dépendances externes, une null-safety intégrée via JSpecify, et un support optimisé pour l’AOT (Ahead-of-Time) ainsi que pour les images natives GraalVM.

Cette version met l’accent sur la simplicité et la cohérence : moins de configurations implicites, des comportements plus clairs et une meilleure préparation pour les environnements conteneurisés et à démarrage rapide.

Par rapport à Spring Boot 3 (Java 17 / Jakarta EE 10), les benchmarks officiels annoncent jusqu’à 50 % de gain sur le temps de démarrage en mode natif et une réduction de 30 à 40 % de la consommation mémoire.

Nouveautés utiles en production

Résilience intégrée : @Retryable et @ConcurrencyLimit

Auparavant gérée via Spring Retry (ou Resilience4j), la résilience est maintenant native dans Spring Boot 4. Ces annotations s'appuient sur Project Reactor pour les backoffs et intègrent Micrometer pour le monitoring.

import org.springframework.retry.annotation.Retryable;
import org.springframework.retry.annotation.Backoff;
import org.springframework.stereotype.Service;
import java.io.IOException;
import java.util.concurrent.TimeoutException;
import org.springframework.service.annotation.ConcurrencyLimit; // Nouveau dans spring-boot 4

@Service
public class PaymentService {

    @Retryable(
        maxAttempts = 4, // Inclut la tentative initiale
        backoff = @Backoff(delay = 1000, multiplier = 2.0), // Backoff exponentiel avec jitter
       
    @ConcurrencyLimit(value = 5) 
    public void processPayment(String paymentId) {
        // Logique : appel externe (e.g., RestTemplate ou WebClient)
        externalApi.call(paymentId);
    }
}

Versioning d’API natif

Le versioning devient explicite au niveau des mappings : plus besoin de dupliquer les contrôleurs ou de multiplier les chemins. Cela réduit la dette technique et clarifie l’évolution des contrats.

import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.GetMapping;
import java.util.List;

@RestController
@RequestMapping("/api")
public class UserController {

    @GetMapping(path = "/users", version = "1", produces = "application/vnd.app.v1+json")
    public List getUsersV1() { return List.of(new UserV1("Alice", "ADMIN")); }

    @GetMapping(path = "/users", version = "2", produces = "application/vnd.app.v2+json")
    public List getUsersV2() { return List.of(new UserV2("Alice", "ADMIN", 30)); } // Ajout champ 'age'
}

Configurez spring.mvc.versioning.strategy=header dans application.yml.

spring:
  mvc:
    versioning:
      strategy: header

Null‑safety (JSpecify)

Les annotations de nullité rendent les contrats explicites : paramètre obligatoire, valeur optionnelle, retour nullable. Les IDE s’appuient dessus pour prévenir les NPE et guider l’autocomplétion.

import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;

public final class EmailService {

    public void send(@NonNull String to, @Nullable String cc, @NonNull String body) {
        java.util.Objects.requireNonNull(to); // Compile-time check via plugins
        // ...
    }
}

Performances : AOT & builds natifs (GraalVM)

Le démarrage plus rapide et l’empreinte mémoire réduite deviennent des objectifs de premier ordre. Spring Boot 4 renforce l’intégration AOT et simplifie l’usage de GraalVM. AOT compile les beans au build-time, réduisant le startup de 90% en native. Configuration Maven enrichie :

 <plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
    <version>0.10.3</version> <!-- Version alignée Boot 4 -->
    <executions>
        <execution>
            <goals><goal>compile</goal><goal>build</goal></goals>
            <phase>package</phase>
        </execution>
    </executions>
    <configuration>
        <imageName>myapp</imageName>
        <buildArgs>--no-fallback --initialize-at-build-time</buildArgs>
    </configuration>
</plugin>

Actuator enrichi (Readiness/Liveness, SSL, Mongo)

Les endpoints de santé sont plus standards : readiness/liveness activés par défaut, de nouveaux indicateurs facilitent la supervision et l’intégration Kubernetes.

management:
  endpoints:
    web:
      exposure:
        include: health,info,metrics,env  
   endpoint:
    health:
      probes:
        enabled: true      
     show-details: always 
    ssl:
      enabled: true

Jackson 3 & Jakarta EE 11

Le passage à Jackson 3 et la bascule complète vers `jakarta.*` modernisent l’écosystème. Effet de bord : certaines bibliothèques tierces nécessitent une mise à jour. Anticipez ce sujet tôt dans la migration.

import jakarta.validation.constraints.NotBlank;
import jakarta.validation.constraints.Email;

public record CreateUserRequest(@NotBlank String name, @Email String email) {}

Migration vers Spring Boot 4

Comparatif rapide Spring Boot 3 → 4

Guide de migration concret Spring Boot 4

Basé sur le guide officiel : Guide Migration - Spring Boot 4.0

Phase 1 — Préparer le terrain

<dependencyManagement>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-dependencies</artifactId>
            <version>4.0.0-RC2</version>
            <type>pom</type>
            <scope>import</scope>
        </dependency>
    </dependencies>
</dependencyManagement>