Spring Boot vs Quarkus: Performance, Native Images, and Migration Guide

1 Overview

Spring Boot is a well‑known Java framework; Quarkus is a Kubernetes‑native Java framework optimized for OpenJDK HotSpot and GraalVM, marketed as “Supersonic Subatomic Java”. This article compares the two frameworks and measures their performance.

2 SpringBoot

Spring Boot is a Java‑based framework focused on enterprise applications. It integrates the entire Spring ecosystem and provides many out‑of‑the‑box features, reducing configuration and boilerplate code through “convention over configuration”.

3 Quarkus

Quarkus follows a similar approach but adds faster startup, lower memory usage, and smaller artifacts. It is optimized for cloud, serverless, and container environments while integrating well with popular Java libraries.

4 Comparison

Both frameworks integrate with other projects, but their internal implementations differ. Spring Boot offers blocking (Servlet) and non‑blocking (WebFlux) web stacks. Quarkus also supports both, allowing simultaneous use, and embeds a reactive programming model.

Test Application

The sample application implements three APIs (create, lookup, and city‑based query) using reactive methods of Spring WebFlux and Quarkus, with PostgreSQL as the database.

Test Plan

JMeter runs a 5‑minute test, warming up the database, then increasing concurrency up to 1,500 users while invoking all APIs. VisualVM monitors resource usage.

All tests run on a machine with the specifications shown below.

5 Results

Both frameworks perform well, but Spring Boot has richer documentation. Performance results show that Quarkus is almost twice as fast as Spring Boot in startup time for both JVM and native builds, and its build time is significantly shorter.

Artifact sizes: Quarkus native image 75 MB vs Spring Boot 109 MB; JVM artifact 4 KB vs 26 MB.

CPU

JVM versions consume more CPU during warm‑up; after that CPU usage stabilizes across all versions.

Memory

Both JVM versions reserve more heap memory, but Quarkus starts with less memory and lower utilization during startup. Native versions show higher peaks but overall lower memory consumption.

Response Time

Spring Boot slightly outperforms Quarkus in response time and thread usage, especially in JVM mode, likely due to JIT optimizations.

Conclusion

Both frameworks are solid choices. Native builds are fast and resource‑efficient, ideal for serverless or short‑lived workloads. JVM builds have higher overhead but offer stability and high throughput for long‑running applications.

6 Migrating from Spring to Quarkus

Quarkus was created by engineers with deep Java expertise, including those who support Spring Boot on Red Hat Runtime, ensuring good Spring API compatibility.

7 Why Spring developers should choose Quarkus

Containerization and Kubernetes drive the need for faster startup and lower memory usage. Quarkus addresses these by delivering near‑double instance density on the same RAM and up to seven‑fold increase when compiled to native binaries.

8 Benefits for Spring developers

Function‑as‑a‑Service: native binaries start in ~0.0015 s.

Live coding without restarts.

Support for both reactive and imperative models.

Compile‑time detection of DI errors.

Combination of best‑of‑breed frameworks and standards.

9 How to start learning Quarkus

Read the Quarkus getting‑started guide.

Follow the Spring DI, Spring Web, and Spring Data JPA guides.

Generate a project at code.quarkus.io.

10 Code Examples

import java.util.List;
import java.util.Optional;
import org.springframework.web.bind.annotation.*;

@RestController
@RequestMapping("/person")
public class PersonController {
    @GetMapping(path = "/greet/{id}", produces = "text/plain")
    public String greetPerson(@PathVariable(name = "id") long id) {
        String name = "";
        // ...
        return name;
    }

    @GetMapping(produces = "application/json")
    public Iterable<Person> findAll() {
        return personRepository.findAll();
    }
}

package org.acme.springmp;

import java.util.List;
import org.springframework.data.repository.CrudRepository;

public interface PersonRepository extends CrudRepository<Person, Long> {
    List<Person> findByAge(int age);
}

import org.eclipse.microprofile.faulttolerance.Fallback;
import org.eclipse.microprofile.faulttolerance.Timeout;
import org.eclipse.microprofile.rest.client.inject.RestClient;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.stereotype.Service;

@Service
public class PersonService {
    @Autowired
    @RestClient
    SalutationMicroProfileRestClient salutationRestClient;

    @Value("${fallbackSalutation}")
    String fallbackSalutation;

    @CircuitBreaker(delay = 5000, failureRatio = .5)
    @Fallback(fallbackMethod = "salutationFallback")
    public String getSalutation() {
        return salutationRestClient.getSalutation();
    }
}

11 References

Baeldung comparison article.

Quarkus blog for Spring developers.

LogicMonitor performance analysis.