Spring Boot 4 — What’s New and Why It Matters

Spring Boot 4 marks a significant step forward in the Spring ecosystem, introducing performance boosts, fresh developer-experience improvements, and updated integration capabilities across the entire stack. This release builds on the foundations of Spring Framework 7 and brings the platform closer to the future of cloud-native, reactive, and AI-assisted development.

Below is a clear overview of the most important new features explained and accompanied by code examples where helpful.

1. Faster Startup and Lower Memory Usage

Spring Boot 4 starts noticeably faster thanks to optimizations in the underlying Spring Framework 7. These improvements come from more efficient classpath scanning, enhanced invocation mechanisms, and memory-optimized internal metadata structures.

For example, a typical microservice can now start in 20–30% less time without requiring any code changes from the developer.

You can easily measure startup time using Actuator: 
java -jar demo.jar --management.metrics.export.simple.enabled=true

You can easily measure startup time using Actuator: 
java -jar demo.jar --management.metrics.export.simple.enabled=true

2. First-Class Virtual Thread Support (Project Loom)

Spring Boot 4 integrates seamlessly with Java Virtual Threads, making it possible to scale blocking workloads with far less operational overhead. This helps systems that handle large numbers of concurrent requests, such as APIs or backend jobs, without switching to reactive programming.

Here is how you can enable virtual threads in Spring Boot 4:

spring.threads.virtual.enabled=true

spring.threads.virtual.enabled=true

When this property is enabled, Spring Boot will:

use virtual threads for task execution / scheduling
use virtual threads for web request handling (MVC + WebFlux)
use a virtual-thread–per-task executor for @Async
integrate Tomcat/Jetty/Undertow with Loom’s virtual thread scheduler

3. Simplified and More Secure Spring Security Configuration

Spring 7 introduces a more streamlined security DSL. Configuration is now more intuitive and reduces boilerplate.

@Bean
SecurityFilterChain security(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
        )
        .oauth2Login(Customizer.withDefaults())
        .csrf(csrf -> csrf.disable());
    return http.build();
}

@Bean
SecurityFilterChain security(HttpSecurity http) throws Exception {
    http
        .authorizeHttpRequests(auth -> auth
            .requestMatchers("/public/**").permitAll()
            .anyRequest().authenticated()
        )
        .oauth2Login(Customizer.withDefaults())
        .csrf(csrf -> csrf.disable());
    return http.build();
}

This wiring avoids deeply nested lambdas and supports better compile-time hints.

4. HTTP Interface Clients Become Production-Ready

Spring Boot 4 treats the declarative HTTP Interface Client API as a fully supported feature, offering an experience similar to Feign but integrated directly into Spring.

@HttpExchange("/posts")
public interface PostClient {

    @GetExchange("/{id}")
    Post getPost(@PathVariable int id);

    @PostExchange
    Post createPost(@RequestBody Post post);
}

@Bean
public PostClient postClient(RestClient.Builder builder) {
    return builder
        .baseUrl("https://jsonplaceholder.typicode.com")
        .build()
        .create(PostClient.class);
}

@HttpExchange("/posts")
public interface PostClient {

    @GetExchange("/{id}")
    Post getPost(@PathVariable int id);

    @PostExchange
    Post createPost(@RequestBody Post post);
}

@Bean
public PostClient postClient(RestClient.Builder builder) {
    return builder
        .baseUrl("https://jsonplaceholder.typicode.com")
        .build()
        .create(PostClient.class);
}

This approach reduces boilerplate and aligns with modern REST client APIs.

5. New “spring boot test slices” and Better Test Performance

Spring Boot 4 refines its test slicing system to ensure that tests load only the minimal configuration needed for execution. This reduces test startup time and improves CI pipeline speed.

@WebMvcTest(controllers = GreetingController.class)
class GreetingControllerTest {

    @Autowired
    private MockMvc mvc;

    @Test
    void shouldReturnGreeting() throws Exception {
        mvc.perform(get("/greet"))
           .andExpect(status().isOk())
           .andExpect(content().string("Hello!"));
    }
}

@WebMvcTest(controllers = GreetingController.class)
class GreetingControllerTest {

    @Autowired
    private MockMvc mvc;

    @Test
    void shouldReturnGreeting() throws Exception {
        mvc.perform(get("/greet"))
           .andExpect(status().isOk())
           .andExpect(content().string("Hello!"));
    }
}

This example loads only MVC components, cutting initialization time dramatically.

Each slice also now has its own dedicated test starter, for example:

spring-boot-starter-webmvc-test
spring-boot-starter-webflux-test
spring-boot-starter-data-jpa-test
spring-boot-starter-jdbc-test
spring-boot-starter-restclient-test
spring-boot-starter-json-test

This significantly reduces the test classpath because only slice relevant classes are loaded and initialized.

6. Updated Observability with Micrometer 2 and OpenTelemetry 2

Spring Boot 4 enhances observability through better metric naming conventions, improved tracing context propagation, and built-in compatibility with OpenTelemetry 2. This makes distributed tracing easier to configure.

management:
  tracing:
    enabled: true
    sampling:
      probability: 1.0
  metrics:
    tags:
      application: blog-service

management:
  tracing:
    enabled: true
    sampling:
      probability: 1.0
  metrics:
    tags:
      application: blog-service

With this configuration, you can send traces to Jaeger, Zipkin, or OTEL collectors without additional setup.

7. Improved Native Image Support (GraalVM)

Spring Boot 4 dramatically improves native compilation times, reduces required hints, and enhances reflection analysis. As a result, building native microservices becomes far more predictable.

./mvnw -Pnative native:compile

./mvnw -Pnative native:compile

A typical Spring Boot 4 service now produces a native binary up to 35% faster than before. The produced binary also has a faster startup time and is significantly smaller than with Spring Boot 3.

8. Enhanced AI Integration Support

Spring Boot 4 embraces the growing AI ecosystem by providing easier integration hooks for model clients, embedding stores, and vector database connections. Although Spring does not ship AI models itself, it provides a consistent and secure framework for implementing AI-powered services.

Spring Boot 4 now auto-configures connectors for major AI platforms:

OpenAI (ChatGPT models, Assistants API)
Azure OpenAI
Anthropic (Claude)
Groq (extremely fast inference)
HuggingFace Inference API
Ollama (local LLMs)
Amazon Bedrock models
Local GGUF models via llama.cpp bindings

You only need to configure the relevant credentials to access your LLM of choice in the application.properties to tell Spring Boot 4 to autoconfigure all relevant beans.

spring.ai.openai.api-key=...
spring.ai.openai.model=gpt-4.1

spring.ai.openai.api-key=...
spring.ai.openai.model=gpt-4.1

Final Thoughts

Spring Boot 4 delivers real progress across performance, security, modularity, testability, observability, and cloud-native readiness. Its improved virtual thread support, native compilation upgrades, and modernized web capabilities make it a strong choice for both new applications and large enterprise migrations.

If you are maintaining Spring Boot 2 or 3 applications, this release provides compelling reasons to consider an upgrade — especially if performance and maintainability matter to your project.