What's new in Spring Boot 4.0.0: A deep dive into Spring Framework 7.0.0

Spring Boot 4.0.0 preview is finally here, and it's packed with features that will change how we build Java applications. This release runs on Spring Framework 7.0.0 and brings together better performance, cleaner code, and an improved developer experience. Let's walk through the major changes that make this release worth your attention.

Release overview and timeline

The Spring Boot 4.0.0 preview is now available through Spring Initializr. This is a major step forward for the entire Spring ecosystem. The team built this preview on Spring Framework 7.0.0 to give developers early access to features that will shape the future of Spring applications.

Key release timeline:

• Spring Boot 4.0.0 preview: Available now (May 2025)

• Spring Framework 7.0.0 GA: November 2025

• Spring Boot 4.0.0 GA: November 2025, aligned with Spring Framework 7.0.0

This preview version needs Java 17 as the minimum baseline and supports up to Java 25. The team recommends Java 21 for the best performance and long-term support.

Core infrastructure upgrades

Spring Boot 4.0.0 completely updates its foundation with modern technologies. The framework now requires Java 17 as minimum but recommends Java 21 for best performance. It also moves to Jakarta EE 11 and Jackson 3.0, dropping support for older versions. These changes provide better performance, security, and access to latest Java features that make your applications run faster and more efficiently.

Java 21 as the new performance baseline

Spring Boot 4.0.0 makes Java 21 the recommended baseline instead of just a supported version. This change unlocks powerful modern Java features that boost application performance and make development more enjoyable.

Key benefits:

• Virtual threads (Project Loom): Handle millions of concurrent tasks with lightweight threads

• Pattern matching and record patterns: Write safer code with better type checking

• Sealed classes: Build better domain models with controlled inheritance

• Modern syntax improvements: Get better performance from the latest JVM optimizations

Jakarta EE 11 modernization

The framework now fully supports Jakarta EE 11, keeping up with the latest enterprise Java standards. This means dropping support for the old javax.* packages.

Major components:

• Tomcat 11: The latest servlet container with better performance

• Hibernate ORM 7: Modern ORM with improved speed and features

• Hibernate Validator 9: Better validation with improved null safety

Jackson 3.0 integration

Spring Framework 7.0.0 uses Jackson 3.0 by default, which brings significant performance improvements and modern JSON processing capabilities.

Key changes:

• New package structure: Jackson 3.x uses tools.jackson package instead of com.fasterxml.jackson

• Backward compatibility: Common annotations like @JsonView and @JsonTypeInfo still use the familiar com.fasterxml.jackson package

• Performance improvements: Faster serialization and deserialization

• Migration timeline: Jackson 2.x support deprecated in 7.0, auto-detection disabled in 7.1, complete removal in 7.2

Revolutionary performance features

This release brings game-changing performance improvements that will transform how your applications run. Virtual threads allow handling millions of concurrent operations without the traditional thread limitations. GraalVM native compilation is now production-ready, offering 90% faster startup times and 80% less memory usage. These features make Spring Boot applications incredibly efficient and suitable for modern cloud environments where speed and resource efficiency matter most.

Virtual threads: Million-scale concurrency

Virtual threads are one of the biggest performance breakthroughs in Java history. Spring Boot 4.0.0 provides excellent support for this game-changing feature.

Configuration:

spring:
  threads:
    virtual:
      enabled: true

Benefits:

• Lightweight: Run millions of virtual threads simultaneously vs. thousands of platform threads

• Zero-cost blocking: I/O operations don't waste OS threads anymore

• Backward compatible: Existing Spring applications work without code changes

• Auto-configuration: Tomcat, Jetty, @Async methods, and WebClient automatically use virtual threads

Performance impact:

• Throughput: Handle 10x more concurrent requests with the same hardware

• Latency: Less overhead from context switching

• Memory efficiency: Much lower memory usage per concurrent operation

GraalVM native image: Production-ready performance

Spring Boot 4.0.0 makes GraalVM native compilation production-ready instead of experimental. This delivers amazing performance improvements.

Key features:

• Cold startup optimization: 90% reduction in startup time

• Memory efficiency: 80% reduction in memory usage

• AOT compilation: Ahead-of-time compilation for maximum performance

• Docker optimization: Smaller container sizes with native executables

Implementation:

<dependency>
    <groupId>org.springframework.experimental</groupId>
    <artifactId>spring-native</artifactId>
    <version>0.12.0</version>
</dependency>

Build command:

./mvnw -Pnative native:compile

Elegant API design and developer experience

Spring Boot 4.0.0 makes building APIs much simpler and more elegant. The new built-in API versioning removes the need for complex custom solutions, letting you manage different API versions with simple annotations. The @HttpExchange feature transforms HTTP client development by using declarative interfaces instead of manual client code. These improvements reduce boilerplate code significantly and make your codebase cleaner and easier to maintain.

Revolutionary API versioning

Spring Boot 4.0.0 introduces built-in API versioning support. No more complex custom versioning logic needed.

Modern implementation:

@RestController
@RequestMapping("/api/user")
public class UserController {
    
    @GetMapping(version = "1")
    public UserV1 getUserV1(@RequestParam Long id) {
        return new UserV1(id, "User_V1");
    }
    
    @GetMapping(version = "2") 
    public UserV2 getUserV2(@RequestParam Long id) {
        return new UserV2(id, "User_V2", "user@example.com");
    }
}

Flexible version resolution:

• Header-based: X-API-Version: 2

• Parameter-based: ?version=2

• Path-based: Automatic routing based on version specification

• Default fallback: Graceful handling of unspecified versions

Declarative HTTP clients with @HttpExchange

Spring Boot 4.0.0 changes how we build HTTP clients with declarative interfaces that reduce boilerplate code by up to 60%.

Interface definition:

@HttpExchange(accept = "application/json")
public interface UserService {
    
    @GetExchange("/users/{id}")
    User getUser(@PathVariable Long id);
    
    @PostExchange("/users")
    User createUser(@RequestBody User user);
}

Auto-configuration:

@Bean
public HttpServiceProxyFactory proxyFactory(RestClient.Builder builder) {
    return HttpServiceProxyFactory.builderFor(
        RestClientAdapter.create(builder.build())
    ).build();
}

Benefits:

• Reduced complexity: Interface-based approach similar to Spring Data repositories

• Type safety: Compile-time validation of HTTP operations

• Automatic proxy generation: Spring generates implementation at runtime

• Seamless integration: Works with RestClient, WebClient, and RestTemplate

Enhanced type safety and null safety

Spring Boot 4.0.0 brings industry-standard null safety through JSpecify annotations, replacing Spring's custom annotations. This provides better IDE support and static analysis for catching null pointer exceptions at compile time. The new BeanRegistrar interface allows dynamic bean registration based on runtime conditions. These features make your code more robust and help prevent common runtime errors before they reach production.

JSpecify annotations for robust null safety

Spring Boot 4.0.0 adopts JSpecify annotations as the standard for null safety. This provides industry-standard null safety guarantees.

Migration example:

// Old Spring annotations
import org.springframework.lang.Nullable;
import org.springframework.lang.NonNull;

// New JSpecify annotations
import org.jspecify.annotations.Nullable;
import org.jspecify.annotations.NonNull;

@NullMarked
public class UserService {
    
    public @NonNull User createUser(@Nullable String name) {
        // Compile-time null safety validation
        return new User(name != null ? name : "Anonymous");
    }
}

Key benefits:

• Standardization: Industry-wide adoption of consistent null safety annotations

• IDE integration: Better IDE support with real-time null safety warnings

• Static analysis: Better integration with tools like NullAway

• Framework-wide: Complete null safety across all Spring modules

Programmatic bean registration

Spring Framework 7.0.0 introduces the new BeanRegistrar interface for dynamic bean registration. This enables complex configuration scenarios.

Implementation:

@Configuration
@Import(MyBeanRegistrar.class)
public class AppConfiguration {
}

public class MyBeanRegistrar implements BeanRegistrar {
    
    @Override
    public void register(BeanRegistry registry, Environment env) {
        // Register beans programmatically
        registry.registerBean("dynamicBean", DynamicService.class);
        
        // Conditional registration
        if (env.matchesProfiles("production")) {
            registry.registerBean("prodService", ProductionService.class, 
                spec -> spec.supplier(context -> 
                    new ProductionService(context.bean(DynamicService.class))
                )
            );
        }
        
        // Loop-based registration
        for (String serviceName : getServiceNames()) {
            registry.registerBean(serviceName, GenericService.class);
        }
    }
}

Revolutionary capabilities:

• Dynamic configuration: Register beans based on runtime conditions

• Loop-based registration: Generate multiple beans programmatically

• Conditional logic: Environment-based bean registration

• Type safety: Full compile-time validation with dependency injection

Advanced HTTP client improvements

HTTP client handling gets a major upgrade with intelligent auto-detection of the best available client library. Spring Boot now automatically chooses between Apache HTTP Components, Jetty, Reactor Netty, or JDK clients based on your classpath. Class Data Sharing (CDS) support dramatically improves startup performance by 20-30%. These improvements make HTTP communication more efficient and reduce the overhead of establishing connections.

Enhanced RestClient and WebClient

Spring Boot 4.0.0 delivers major improvements to HTTP client capabilities with better auto-configuration and performance.

Auto-detection priority:

1. Apache HTTP Components (HttpComponentsClientHttpRequestFactory)

2. Jetty Client (JettyClientHttpRequestFactory)

3. Reactor Netty HttpClient (ReactorClientHttpRequestFactory)

4. JDK HttpClient (JdkClientHttpRequestFactory)

5. Simple JDK HttpURLConnection (SimpleClientHttpRequestFactory)

Configuration options:

spring:
  http:
    client:
      factory: reactor  # http-components, jetty, reactor, jdk, simple
      redirects: dont-follow  # follow, dont-follow

Benefits:

• Automatic client selection: Best available client chosen automatically

• Flexible configuration: Easy switching between different HTTP clients

• Performance optimization: Optimized client selection based on classpath

• Redirect handling: Consistent redirect behavior across all clients

Class Data Sharing (CDS) support

Spring Boot 4.0.0 introduces complete Class Data Sharing support for dramatically improved startup performance.

CDS archive creation:

# Extract application
java -Djarmode=tools -jar my-app.jar extract --destination application

# Create CDS archive
java -XX:ArchiveClassesAtExit=application.jsa \
     -Dspring.context.exit=onRefresh \
     -jar my-app.jar

Using CDS archive:

java -XX:SharedArchiveFile=application.jsa -jar my-app.jar

Performance benefits:

• Startup time: 20-30% faster application startup

• Memory efficiency: Reduced memory footprint through shared class metadata

• Container optimization: Excellent performance in containerized environments

• Production ready: Minimal configuration required for maximum benefit

Modern development experience

The developer experience gets significant improvements with enhanced SpEL (Spring Expression Language) that includes null-safe navigation and better Optional support. Observability and monitoring are now built-in with complete metrics, tracing, and health check capabilities. These features help developers write safer code with less boilerplate and monitor applications more effectively. The integration with modern tools like Micrometer and OpenTelemetry makes monitoring setup almost effortless.

Enhanced SpEL (Spring Expression Language)

Spring Framework 7.0.0 introduces major improvements to SpEL with better null safety and enhanced Optional support.

New features:

// Null-safe navigation
@Value("#{user?.address?.street ?: 'N/A'}")
private String street;

// Elvis operator for defaults
@Value("#{systemProperties['mail.port'] ?: 25}")
private int mailPort;

// Optional unwrapping
@Value("#{@userService.findById(1).orElse(defaultUser)}")
private User user;

Benefits:

• Null safety: Safe navigation through object hierarchies

• Default values: Elegant fallback handling

• Optional support: Seamless integration with Java Optional

• Concise syntax: Less boilerplate in configuration

Improved observability and monitoring

Spring Boot 4.0.0 delivers better observability capabilities with out-of-the-box integration for modern monitoring solutions.

Key features:

• Metrics: Complete application metrics with Micrometer

• Tracing: Distributed tracing with OpenTelemetry

• Logging: Structured logging with enhanced formatting

• Health checks: Advanced health check capabilities

• Prometheus integration: Native Prometheus metrics export

Migration path and compatibility

Upgrading to Spring Boot 4.0.0 is designed to be straightforward with a clear migration path from version 3.x. The main requirements are updating to Java 17+ and migrating to Jakarta EE 11 dependencies. Most existing configuration and APIs remain compatible, making the transition smooth for most applications. The team has maintained backward compatibility where possible while still enabling access to modern features and performance improvements.

Smooth upgrade strategy

Spring Boot 4.0.0 is designed with a smooth migration path from Spring Boot 3.x applications.

Migration steps:

1. Update Java version: Ensure Java 17+ (Java 21 recommended)

2. Update dependencies: Migrate to Jakarta EE 11 dependencies

3. Review null safety: Adopt JSpecify annotations

4. Update Jackson usage: Migrate to Jackson 3.0 APIs

5. Test thoroughly: Validate application behavior

Breaking changes:

• Minimum Java version: Java 17 baseline (was Java 17 in Spring Boot 3.0+)

• Jakarta EE: Complete migration to Jakarta EE 11

• Jackson: Jackson 2.x support deprecated

• Null safety: Migration to JSpecify annotations

Backward compatibility

Despite being a major version upgrade, Spring Boot 4.0.0 maintains strong backward compatibility:

• Configuration: Most existing configuration remains valid

• APIs: Core Spring Boot APIs remain consistent

• Annotations: Gradual migration path for annotations

• Dependencies: Managed dependency upgrades

Future-ready architecture

Spring Boot 4.0.0 prepares your applications for the future with support for cutting-edge technologies like Project Leyden for faster JVM startup. The framework fully embraces modern Java features including pattern matching, records, sealed classes, and text blocks. These architectural improvements ensure your applications can take advantage of future Java enhancements and remain performant as the ecosystem evolves. The focus on cloud-native and serverless architectures makes it ideal for modern deployment patterns.

Project Leyden integration

Spring Boot 4.0.0 provides foundational support for Project Leyden, Oracle's initiative for faster JVM startup and optimization.

Benefits:

• Faster startup: Significant reduction in cold start times

• Memory efficiency: Optimized memory usage patterns

• Container optimization: Better performance in containerized environments

• Cloud-native: Ideal for serverless and microservices architectures

Modern Java feature support

Spring Boot 4.0.0 fully embraces modern Java features:

• Pattern matching: Enhanced switch expressions and pattern matching

• Records: First-class support for record types

• Sealed classes: Improved domain modeling

• Text blocks: Better string handling and JSON processing

Getting started with Spring Boot 4.0.0 preview

Getting started with the preview is straightforward using Spring Initializr with the snapshot version. The essential configuration involves enabling virtual threads and setting up the HTTP client factory for optimal performance. Maven dependencies are minimal, requiring just the standard Spring Boot starters plus JSpecify for null safety. The preview gives you immediate access to all the new features so you can start experimenting and preparing for the November GA release.

Creating your first application

# Using Spring Initializr
curl https://start.spring.io/starter.zip \
  -d dependencies=web,data-jpa,actuator \
  -d javaVersion=21 \
  -d bootVersion=4.0.0-SNAPSHOT \
  -d name=my-spring-boot-4-app \
  -o my-app.zip

Essential configuration

# application.yml
spring:
  threads:
    virtual:
      enabled: true
  http:
    client:
      factory: reactor
  jackson:
    default-property-inclusion: non_null

Maven dependencies

<properties>
    <java.version>21</java.version>
    <spring-boot.version>4.0.0-SNAPSHOT</spring-boot.version>
</properties>

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <dependency>
        <groupId>org.jspecify</groupId>
        <artifactId>jspecify</artifactId>
        <version>1.0.0</version>
    </dependency>
</dependencies>

Looking ahead: The future of Spring

Spring Boot 4.0.0 is a major upgrade that brings modern Java development to the next level. With virtual threads for handling millions of concurrent requests, GraalVM native compilation for lightning-fast startup times, and cleaner API design that reduces code complexity, this release makes Spring the top choice for building high-performance Java applications. The November 2025 GA release will transform enterprise Java development by combining cutting-edge features with Spring's trademark simplicity, making it perfect for microservices, cloud-native apps, and traditional enterprise systems alike.

Ready to experience the future of Spring? Start exploring Spring Boot 4.0.0 preview today and join the revolution in modern Java development!

For more information, check out:

• Spring Boot Official Documentation

• Spring Framework 7.0.0 Release Notes

• Spring Boot 4.0.0 Migration Guide

• Virtual Threads Performance Guide

• GraalVM Native Image Documentation