the ecosystem map
spring, quarkus, micronaut, jakarta ee, kotlin. who does what.
- chapter
- chapter 12.10
- reading time
- 6 min read
the JDK gives you the language, the runtime and a big standard library. almost everything else in a real java service comes from a small set of well-known projects: a framework that wires the app together (Spring Boot, Quarkus, Micronaut, Helidon, Jakarta EE), a data access layer on top of JDBC, a build tool, a testing stack, a few everyday libraries, and possibly another JVM language.
knowing which box a name goes in is most of the battle.
the picture
a city map, not a ranking. the JDK is the ground everything stands on. frameworks are the neighbourhoods, each with its own layout but the same roads (HTTP, JDBC, JSON). you can live in any of them, and moving between them is less dramatic than the forum threads suggest, because the java underneath is the same.
opinionated setup on top of the spring framework: dependency injection, auto-configuration, an embedded server. the most used option by far.
- by
- Broadcom (VMware Tanzu)
- since
- 2014
- latest
- 4.1.1 (spring framework 7.0.9)
one request, many layers
most server-side java follows the same path. the names change per stack, the layers don't:
hover a stage.
how the frameworks differ
the big four application frameworks do roughly the same job. the real difference is when they do the wiring:
| when wiring happens | HTTP server by default | native image | |
|---|---|---|---|
| Spring Boot | at startup, with reflection and proxies (optional AOT step for native) | tomcat | yes, with GraalVM |
| Quarkus | mostly at build time ("build-time augmentation") | vert.x based | a first-class target |
| Micronaut | at compile time, with annotation processors | netty | yes |
| Helidon | SE: no injection, plain code. MP: CDI at startup | helidon webserver (virtual threads) | yes |
wiring at startup is flexible but costs startup time and memory. wiring at build or compile time starts faster and makes native images easier, with less runtime magic. spring boot has the biggest ecosystem and the most answers on the internet. none of them is "the fast one" for every workload: measure your own, see measuring performance.
and Jakarta EE is a different kind of thing: it's a set of specifications (servlets, persistence, CDI, REST) that several servers implement. spring, quarkus and helidon all implement or use parts of it, which is why jakarta.persistence.Entity shows up everywhere.
the javax → jakarta rename
the one ecosystem event worth knowing about, because it still bites upgrades. in 2017 oracle handed java EE to the eclipse foundation, but kept the javax name. so jakarta EE 9 (2020) renamed every package: javax.persistence.Entity became jakarta.persistence.Entity, javax.servlet became jakarta.servlet. spring boot 3 (2022) moved to jakarta, so did everything else. code and libraries are on one side of that line or the other.
languages on the JVM
kotlin, scala, clojure and groovy all compile to the same bytecode as java, which is why they can use every library above, and why java can call them. kotlin is the one you're most likely to meet: it's the preferred language for android and it's common in spring and gradle projects (build.gradle.kts is kotlin). the what java is chapter shows why the JVM doesn't care which compiler made a class file.
how to pick, honestly+
for a typical team building HTTP services, the boring answer is usually right: the framework your team already knows, maven or gradle (whichever your org standardised on), JUnit + AssertJ + Mockito + Testcontainers, jackson for JSON, SLF4J + logback for logging. reach for quarkus, micronaut or helidon when startup time, memory or native images matter enough to justify the switch, and benchmark your app before believing anyone's chart. jOOQ vs hibernate is less about speed and more about whether your team thinks in SQL or in objects.
- the JDK is the ground. frameworks, data access, build, testing and libraries sit on top.
- frameworks differ mostly in when they wire your app: startup, build time, or compile time.
- Jakarta EE is specs. hibernate implements JPA. jOOQ and MyBatis are SQL-first.
javax.*enterprise packages becamejakarta.*. mixing them breaks things.- kotlin, scala, clojure and groovy share the same bytecode, so they share the ecosystem.