Spring Boot 3 New Features: What Every Java Developer Should Know

Observability API (Micrometer Observation)

Spring Boot 3 replaced the old @Timed / manual MeterRegistry patterns with a unified Observation API built on Micrometer:

@Service
public class OrderService {

    private final ObservationRegistry registry;

    public Order process(String id) {
        return Observation.createNotStarted("order.process", registry)
                .lowCardinalityKeyValue("status", "new")
                .observe(() -> fetchAndEnrich(id));
    }
}

One Observation call emits a timer metric, a distributed trace span, and an event log — all from a single instrumentation point. This is the right abstraction for LLMops and microservice observability: you get Prometheus metrics, Zipkin/OTLP traces, and logs without instrumenting three separate APIs.

Spring Boot auto-configures it with sensible defaults for HTTP, JDBC, and Spring Data — most instrumentation comes for free on upgrade.

HTTP Interface clients (declarative REST)

Spring Boot 3.1+ ships HTTP Interface clients — a declarative, annotation-driven alternative to RestTemplate / raw WebClient:

@HttpExchange("https://api.partner.com")
interface PartnerClient {

    @GetExchange("/orders/{id}")
    Order getOrder(@PathVariable String id);

    @PostExchange("/orders")
    Order createOrder(@RequestBody CreateOrderRequest request);
}

// Register as a bean
@Bean
PartnerClient partnerClient(WebClient.Builder builder) {
    WebClient client = builder.baseUrl("https://api.partner.com").build();
    return HttpServiceProxyFactory
            .builderFor(WebClientAdapter.create(client))
            .build()
            .createClient(PartnerClient.class);
}

This feels like Spring Data repositories but for HTTP — less boilerplate than WebClient, testable with mocks, and fully compatible with virtual threads (use RestClient adapter for blocking).

Problem Details (RFC 9457)

Spring Boot 3 adds built-in support for Problem Details — the RFC 9457 standard for machine-readable error responses:

// Enable in application.yaml
spring:
  mvc:
    problemdetails:
      enabled: true

With this on, Spring's built-in exceptions automatically produce structured JSON errors:

{
  "type": "about:blank",
  "title": "Not Found",
  "status": 404,
  "detail": "Order 'abc' was not found",
  "instance": "/orders/abc"
}

You can extend it with custom ProblemDetail for your own exceptions. No more hand-rolling error response shapes across services.

Migration checklist

1. Update Java to 17+ (or 21 for virtual threads) — and verify your runtime, not just build target.
2. Rename javax.* → jakarta.* — your IDE can do a project-wide replace; watch for transitive dependencies.
3. Upgrade Spring Boot from 2.x → 3.x — follow the official migration guide.
4. Check library compatibility — Spring Security 6, Hibernate 6, Flyway 9+ are required.
5. Enable virtual threads if on Java 21 — immediate win for I/O-bound services.
6. Opt in to Problem Details and Observation API — both are opt-in by default.

FAQ

Is the migration painful? The namespace change (javax → jakarta) is the only big disruptive step. For most apps, it's a couple hours of search-and-replace plus dependency updates. The payoff is years of support and all the features above.

Do I need GraalVM to use Spring Boot 3? No — GraalVM native compilation is optional. You can run Spring Boot 3 on a standard JVM exactly as before.

What's the minimum Java version? Java 17 for Spring Boot 3.0+; Java 21 for virtual threads (3.2+). Java 21 is the recommended target — it's the current LTS with the most features.

Should I upgrade to 3.0 or jump straight to the latest 3.x? Jump to the latest 3.x patch release directly — there's no value in stopping at 3.0 first.

Spring Boot 3 is the right foundation for the next several years of Java backend development — native images for startup-sensitive workloads, virtual threads for concurrency without complexity, unified observability, cleaner HTTP clients, and standardized error responses. The Jakarta namespace migration is the cost of admission; everything above is the return.

More: virtual threads in depth, modern Java features, Spring AI for enterprise, and microservices best practices.

Modernizing a Spring Boot service and want an architecture review? Let's talk.