Spring Boot 4: A Comprehensive Guide, from New Features to Full Migration

Article written by Abdelaziz LOUARIT,
Java Developer at MARGO.

Introduction

Spring Boot 4 marks a significant milestone for the modern Java ecosystem.
After several years of stability around Spring Boot 3, this new version pursues three core objectives: simplifying developer workflows, consolidating cloud-native best practices, and further accelerating startup times and observability.

Based on Spring Framework 7.x, it builds upon the advancements of previous versions while introducing native features dedicated to resilience, observability, and performance.

Aligned with Java 17 (LTS) as the new minimum requirement and Jakarta EE 11, Spring Boot 4 is clearly targeted at cloud-native and serverless applications. It features a notable reduction in external dependencies, built-in null-safety via JSpecify, and optimised support for AOT (Ahead-of-Time) compilation and GraalVM native images.

This version emphasises simplicity and consistency: fewer implicit configurations, clearer behaviours, and better readiness for containerised, fast-startup environments.

Compared to Spring Boot 3 (Java 17 / Jakarta EE 10), official benchmarks report up to a 50% improvement in startup time in native mode and a 30% to 40% reduction in memory consumption.

Production-Ready Features

Built-in Resilience: @Retryable and @ConcurrencyLimit

Previously managed via Spring Retry (or Resilience4j), resilience is now a native feature in Spring Boot 4. These annotations leverage Project Reactor for backoff strategies and integrate Micrometer for 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; // New in Spring Boot 4

@Service
public class PaymentService {

    @Retryable(
        maxAttempts = 4, // Includes the initial attempt
        backoff = @Backoff(delay = 1000, multiplier = 2.0) // Exponential backoff with jitter
    )
    @ConcurrencyLimit(value = 5) 
    public void processPayment(String paymentId) {
        // Logic: External call (e.g., RestTemplate or WebClient)
        externalApi.call(paymentId);
    }
}

Native API Versioning

Versioning is now explicit within mappings, eliminating the need to duplicate controllers or create redundant paths. This reduces technical debt and clarifies the evolution of API contracts.

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)); } // Added 'age' field
}

Simply configure spring.mvc.versioning.strategy=header in your application.yml.

spring:
  mvc:
    versioning:
      strategy: header

Null‑safety (JSpecify)

Nullability annotations make contracts explicit: mandatory parameters, optional values, and nullable return types. IDEs leverage these to prevent NPEs (NullPointerExceptions) and guide auto-completion.

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
        // ...
    }
}

Performance: AOT & Native Builds (GraalVM)

Faster startup times and a reduced memory footprint have become first-class objectives. Spring Boot 4 strengthens AOT integration and simplifies GraalVM usage. AOT (Ahead-of-Time) compiles beans during build-time, reducing startup time by up to 90% in native mode. Enriched Maven Configuration:

<plugin>
    <groupId>org.graalvm.buildtools</groupId>
    <artifactId>native-maven-plugin</artifactId>
    <version>0.10.3</version> <!-- Version aligned with 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>

Enriched Actuator (Readiness/Liveness, SSL, Mongo)

Health endpoints are more standard: readiness/liveness probes are enabled by default, and new indicators facilitate monitoring and Kubernetes integration.

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

The transition to Jackson 3 and the full switch to `jakarta.*` modernise the ecosystem. Side effect: some third-party libraries require an update. Anticipate this early in your migration.

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

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

Migrating to Spring Boot 4

Quick Comparison: Spring Boot 3 → 4

Step-by-Step Migration Guide to Spring Boot 4

Based on the official guide: Migration Guide – Spring Boot 4.0

Phase 1 — Preparation

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