Which Java Microservice Framework Wins in 2020? A Deep Performance Comparison

Framework Overviews

Spring – Introduced in 2003, Spring provides dependency injection and aspect‑oriented programming via runtime reflection. It offers a large ecosystem, extensive documentation, and mature libraries (Spring Boot, Spring Data). The reflection‑based approach increases startup time and memory usage and makes native GraalVM images difficult.

Micronaut – Created in 2018, Micronaut performs dependency injection, AOP, and configuration at compile time using annotation processors. This yields faster startup and lower memory footprints. Its API is similar to Spring’s, but the ecosystem is newer.

Quarkus – Developed by Red Hat in 2019, Quarkus is Kubernetes‑native and builds on MicroProfile, Vert.x, Netty, and Hibernate. A custom Maven plugin does most work at compile time, aiming for rapid container startup and minimal memory usage. The project is relatively young, so some extensions are still evolving.

Helidon MP – Oracle’s 2018 implementation of the MicroProfile specification. It inherits JEE stability but lacks many modern connectors that replace Spring Data and Spring Security, making it harder to use for typical microservice needs.

Comparison Methodology

For each framework a simple CRUD application exposing a REST API and connecting to a database (via JDBC, JPA, or Spring Data) was built. All applications were containerised with an OpenJDK Docker image; where supported, native GraalVM images were also generated. Tests ran on a Google Cloud VM (4‑core Intel Haswell, 15 GB RAM, Ubuntu 19.01) and were repeated to minimise variance.

Key metrics measured:

Implementation effort – difficulty of creating the sample application.

Compilation time – total time to build the Docker image (including native image generation when applicable).

Startup latency – time from docker up to first successful HTTP response, plus idle memory usage.

High‑load throughput – requests per second under a JMeter load (25 % writes, 75 % reads) and associated memory consumption.

Results

Development Usability

Spring Boot offers the smoothest onboarding experience due to its extensive documentation and mature ecosystem. Micronaut’s documentation is also strong and its API mirrors Spring’s, making the transition easy for Spring developers. Quarkus has a steeper learning curve and less mature database connectors, while Helidon MP proved the hardest to get running.

Compilation

OpenJDK builds took between 6.98 s (Spring with JDBC) and 10.7 s (Quarkus). Native GraalVM image generation was significantly slower, ranging from 231.2 s (Micronaut with JDBC) to 351.7 s (Micronaut with JPA), which can be prohibitive for rapid development cycles.

Startup

Spring Boot with Spring Data started in 8.16 s; removing Spring Data reduced this to 5.8 s. Micronaut started in 3.8 s (JDBC) or 5.08 s (JPA), and Quarkus in 5.7 s. Helidon MP was the slowest among the OpenJDK runs at 8.27 s. Native GraalVM images were the fastest: 1.39 s for Quarkus and 1.46 s for Micronaut (JDBC).

Memory usage after startup was similar across frameworks. Spring used 420 MB (with Spring Data) or 261 MB (JDBC). Micronaut used 262 MB (JPA) or 178 MB (JDBC). Quarkus used 197 MB, while Helidon MP consumed about 414 MB.

High‑Load Performance

Under heavy load, Spring Boot with Spring Data handled 342 req/s (581 MB RAM) and 216 req/s (JDBC, 484 MB RAM). Helidon MP performed the worst, processing only 175 req/s while exceeding 1 GB RAM. Other frameworks ranged from 197 req/s (OpenJDK Quarkus) to 400 req/s (GraalVM Quarkus). Micronaut’s performance varied slightly between JDBC and JPA and improved when using native images.

In terms of memory efficiency at high load, Quarkus on OpenJDK was the best (255 MB), whereas its GraalVM native image consumed more (≈368 MB).

Conclusion

Newer frameworks like Micronaut and Quarkus provide faster startup and lower idle memory compared to legacy options such as Spring and MicroProfile, but these advantages are most visible in idle or low‑load scenarios. Native GraalVM images amplify the benefits but introduce long compilation times, making them suitable mainly for serverless or rapid‑scale‑out workloads.

Overall, Spring remains the most developer‑friendly choice for Java microservices despite its slower startup, thanks to its comprehensive ecosystem and tooling. Micronaut Data’s automatic code generation stands out as a feature that could improve Spring Data.

References

https://micronaut.io/

https://quarkus.io/

https://github.com/oracle/helidon/tree/master/microprofile

https://medium.com/javarevisited/reactive-database-access-with-r2dbc-micronaut-and-graalvm-ee9b5853260

https://github.com/lizzyTheLizard/medium-Java-framework-compare

https://github.com/lizzyTheLizard/medium-Java-framework-compare/tree/master/compare