Spring Framework 6.0: What's New, Release History & EOL Status

What Is New in Spring Framework 6.0

Spring Framework 6.0 is a major release that establishes a new foundation for the next decade of Spring applications. It shifts the baseline to modern Java and Jakarta EE standards while introducing transformative features for ahead-of-time compilation and new programming models.

Why is Java 17 the new minimum requirement?

Spring 6.0 requires Java 17 as its baseline to leverage modern language features and ensure long-term support alignment. This jump from Java 8 allows the framework to use records, sealed classes, and enhanced performance optimizations internally. In practice, this pushes the ecosystem forward but requires active LTS Java versions for development and deployment.

Jakarta EE 9+ Namespace Change

All EE APIs now use the jakarta.* namespace, a breaking change from javax.*. This affects imports for Servlet, Persistence (JPA), Transaction, and more. You'll need to update your codebase and ensure compatible versions of all connected servers and libraries.

How does AOT change Spring application deployment?

The new Ahead-of-Time (AOT) compilation engine transforms Spring applications into highly optimized native executables using GraalVM. This moves runtime bean discovery and configuration processing to build time, resulting in faster startup and lower memory footprint. It matters for microservices and serverless functions where instant scale is critical.

@SpringBootApplication
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}
// Build for Native: ./mvnw spring-boot:build-image -Dspring-boot.build-image.imageName=myapp

What are HTTP Interfaces and when should I use them?

HTTP Interfaces provide a declarative way to call remote HTTP services, similar to Feign or Retrofit. You define a Java interface with annotated methods, and Spring generates the implementation at runtime. This is ideal for modern service-to-service communication in a microservices architecture, offering a cleaner alternative to RestTemplate.

@HttpExchange(url = "/api/v1/users", accept = "application/json")
public interface UserClient {
    @GetExchange("/{id}")
    User getUser(@PathVariable Long id);
    @PostExchange
    User create(@RequestBody User user);
}

How is data binding and validation improved?

Data binding now uses a new DataBinder implementation that fully supports constructor-based binding for immutable objects, like Java records. The validation process is more tightly integrated, reducing boilerplate. This aligns with modern domain modeling where immutable data objects are preferred.

Problem Details RFC 7807

A new ProblemDetail class standardizes error responses according to RFC 7807. Controllers can now return ProblemDetail for machine-readable error details, improving API consistency. This is a welcome addition for REST API design, replacing ad-hoc error response structures.

What's new for Kotlin developers?

Kotlin coroutines are now a first-class citizen for reactive and non-blocking flows across Spring WebFlux and Data modules. Support is extended for Kotlin 1.7+ features like context receivers. The Spring ecosystem feels more native to Kotlin, with improved null-safety and concise DSLs for bean definition and routing.

Which older features were removed?

Several legacy modules and supports have been pruned to reduce the framework's footprint. This includes removal of JUnit 4 support (migrate to JUnit 5), the Tiles view technology, JasperReports, Portlet, Velocity, XMLBeans, and JDO. If you're upgrading, check your dependencies and replace these with modern alternatives.