Java microframeworks are generally lightweight and minimalistic, characterized by their emphasis on performance, cloud-native capabilities, and developer experience. They are designed for building lightweight web applications, and they’re particularly well-suited to microservices architectures. Although Spring Boot is the most common choice in this arena, different frameworks cater to different needs. This article is a quick look at seven Java microframeworks prized for their unique combination of features and simplicity.

Here’s a review of the frameworks, with Spring Boot included for reference:

Performance notes

Many of the Java microframeworks covered here rely on GraalVM to produce native binaries. These binaries are highly optimized for the target platform, meaning fast startup and shutdown, good memory efficiency, and runtime performance (including ahead-of-time compilation/AOT). These traits are hugely beneficial for production environments, especially serverless environments where processes are often started and stopped in response to changing demands.

A well-designed Java application compiled to binary with GraalVM is one of the most high-performance runtimes anywhere. You can install GraalVM using SDKMan; for example, with a command like this one: sdk install java 24.0.2-graalce.

Another killer feature of modern Java and JVM languages is virtual threads. Every framework discussed here has a relationship to this feature, which was considered stable and production ready in Java 21.

Now, let’s take a look at these frameworks.

Quarkus

Quarkus is a modern, cloud-native framework that has an excellent development mode, a pluggable architecture with many features, and offers simple native builds with GraalVM or Mandrel. It’s an especially good fit for developers who are familiar with Spring and want fast startups and native compilation.

Quarkus also has a command-line interface (CLI) that will scaffold your applications for you. Once Quarkus is installed (sdk install quarkus) you can scaffold an app using quarkus create. If you launch the app in development mode (quarkus dev) it will hot-deploy code changes and produce a dev console:

Matthew Tyson

Quarkus offers many extensions, like logging, metrics, auth, and datastores. You can use the UI to manage them and the CLI to add and remove them.

Quarkus supports both imperative and reactive-style programming, which it enables via Vert.x. It allows you to use the two programming styles side-by-side in the same application. It has direct support for virtual threads on endpoints.

Quarkus also provides a CDI injection framework based on the Jakarta EE standard and resolves these dependencies at build-time to avoid slowdowns due to runtime resolution. This improves performance for both native and JVM builds.

Here’s a simple endpoint in Quarkus:

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/hello")
public class GreetingResource {

    @GET
    @Produces(MediaType.TEXT_PLAIN)
    public String hello() {
        return "Hello from InfoWorld!";
    }
}

Quarkus hits the sweet spot by supporting development and bringing in the extras when you need them. If you want a simple but versatile framework that cares about developer experience, Quarkus is a worthy choice.

Vert.x

Vert.x is one of the first and most mature reactive frameworks in Java. It’s a full-scale reactive container with everything you need to create high-performance, reactive pipelines. It’s especially well suited to projects that require dialed-in performance for high-throughput data streams.

Vert.x is not so much a frameworks as a set of tightly refined tools for composing reactive streams, which is an advantage if you are looking for maximum flexibility. Various tools and frameworks, including Quarkus, build on top of Vert.x. Whether you use it as a toolkit or framework, Vert.x is exceptionally capable and wide ranging.

Vert.x technology is built on an event loop architecture, designed to minimize idle CPU resources. On top of this architecture, Vert.x provides various ways of handling asynchronous programming. It also supports RxJava for a huge range of operators and sophisticated reactive constructs.

Although it uses an event loop, Vert.x is not limited to a single thread, so you get both asynchronous handling and multi-threading. This is called multi-reactors, and usually gives you an event thread per-CPU core (a big advantage over something like Node). Also, you can fine-tune the way your app creates multiple instances of its handler classes (called verticles), for scaling inside a single node.

Vert.x is also built for Kotlin, and lets you natively use Kotlin coroutines for asynchronous event handling. Other languages Vert.x supports include Groovy, Ruby, Java (of course), and even JavaScript on the client, via websockets.

Here’s an example of a Vert.x endpoint:

import io.vertx.core.AbstractVerticle;
import io.vertx.core.Promise;

public class MainVerticle extends AbstractVerticle {

  @Override
  public void start(Promise startPromise) throws Exception {
    vertx.createHttpServer().requestHandler(req -> {
      req.response()
        .putHeader("content-type", "text/plain")
        .end("Hello from Vert.x!");
    }).listen(8888, http -> {
      if (http.succeeded()) {
        startPromise.complete();
        System.out.println("HTTP server started on port 8888");
      } else {
        startPromise.fail(http.cause());
      }
    });
  }
}

Vert.x also provides a sophisticated event bus for communicating within and across the nodes of a microservices application. Think of the event bus as a lightweight distributed messaging system for Vert.x nodes. If you need to graduate to a persistent message broker, Vert.x supports several integrations, including RabbitMQ.

Vert.x also has well-designed and performant connectors for many popular databases (for example MongoDB) and an authorization and authentication component that integrates with these datastores.

Similar to Spring Initializr, Vert.x gives you a web-based tool for constructing new apps:

Matthew Tyson

If you need to consume, connect and produce realtime streams of data, Vert.x is a great choice. It is hands-down one of the most advanced and mature reactive platforms for Java.

Ktor

Ktor is a unique framework built by JetBrains expressly for Kotlin, a modern language with full access to the wonders of the JVM. Ktor offers a range of composable features aimed at web development and leverages Kotlin coroutines for asynchronous programming. It is the official mechanism for building web apps in Kotlin.

The Ktor CLI includes a fully-featured creator wizard, which you can use to launch a new application (ktor new):

Matthew Tyson

Ktor is a modular framework that supports plugins, called “features.” Options include a DI (dependency injection) engine (koin) and other needful things like monitoring, administration, datastore connectors, and security. These are all brought together under Ktor’s unified framework.

Ktor gives you considerable power, including a Kotlin DSL for generating HTML—a very idiomatic and simple way to produce data-driven markup. Possibly the most powerful thing about Ktor is its implicit use of Kotlin’s coroutines to transparently make non-blocking asynchronous operations look synchronous; for example, something like this appears to be blocking (on the client.get() call) but is fully asynchronous under the hood:

import io.ktor.client.*
//... other imports

routing {
  get("/") {
    try {
      // Implicit coroutine use:
      val book = client.get("https://anapioficeandfire.com/api/books/1").body()
      call.respond(book)
    } catch (e: Exception) {
      call.respondText("Error fetching book: ${e.message}")
    }
  }
}

Ktor is a well-rounded set of tools for building all kinds of server-side Kotlin functionality. Although it’s best known for bringing coroutines to the web server, it can handle anything you throw at it. While anyone can use it, Ktor is especially great for Kotlin developers seeking a full-featured web application framework.

Also see: Intro to Ktor: The server-side stack.

Dropwizard

Dropwizard is a mature, lightweight framework geared for modern RESTful services in a cloud environment. It embeds a Jetty server inside your application for a standalone runnable and brings together Jackson for JSON and Jersey for endpoint definitions. Along with that basic setup, you can add components to handle persistence and other common application requirements.

One of Dropwizard’s most compelling features is its built-in operational metrics based on Metrics, a library built by the Dropwizard team. Metrics is a full-featured monitoring tool that integrates with your application. It also integrates with common library dependencies and back ends like Graphite.

Dropwizard is basically a glue framework that ties together a host of other projects in one easy-to-use package. It lets you use these projects intelligently, without having to orchestrate them yourself:

Matthew Tyson

Here’s an endpoint mapping in Dropwizard:

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;

@Path("/hello")
@Produces(MediaType.TEXT_PLAIN)
public class HelloResource {

    @GET
    public String sayHello() {
        return "Hello from InfoWorld!";
    }
}

As you can see, Dropwizard largely offloads to Jersey, a Jakarta project for route handling.

Dropwizard brings together a collection of best-in-class tools in a lightweight, unified framework that is cloud ready. It is also intensely focused on stability and monitoring, so it’s the perfect choice for those priorities.

Javalin

Javalin is the microframework for developers who want extreme simplicity and no “magic.”

Javalin is the code-heir to SparkJava, one of the first open source microframeworks for the JVM. It is geared for simplicity and flexibility. Unlike many modern frameworks, Javalin strives to be unopinionated, more a library than a framework. As the developer, you decide how best to use it. Because Javalin focuses on avoiding hidden dependencies (i.e., “magic”) and having everything explicitly described in code, it does not offer DI or code scanning. Javalin servers tend to be very concise.

Like Dropwizard, Javalin embeds a Jetty server, which gives you a familiar HTTP platform known for reliability and performance:

Matthew Tyson

It’s also a polyglot framework that supports both Java and Kotlin. Here’s a simple Hello World server written in Kotlin:

import io.javalin.Javalin

fun main() {
    val app = Javalin.create(/*config*/)
        .get("/") { ctx -> ctx.result("Hello World") }
        .start(7070)
}

And here it is in Java:

import io.javalin.Javalin;

public class App {
    public static void main(String[] args) {
        var app = Javalin.create()
            .get("/", ctx -> ctx.result("Hello World"))
            .start(7070);
    }
}

Notice the fluent method changing and clean code, allowing us to describe the server definition and endpoints together.

Javalin avoids bloat and any unnecessary dependency syntax. If you are looking for a minimalist framework to get the job done, Javalin may be the framework for you.

Micronaut

Micronaut is a great option when startup time is paramount, and/or if you want a multi-language, full-stack framework for building microservices and serverless apps. It gives you an AOT compiler that provides performance and dependency injection without reflection. It can run in the JVM or compile down to native images with GraalVM.

The way the Micronaut IoC (inversion of control) container works means all dependencies are resolved during compilation. That makes for fast startup times, which are essential for microservices. Micronaut’s design also means lower memory use for dependency injection.

Micronaut is polyglot, with support for Java, Groovy, and Kotlin, with plans to support Scala.

Matthew Tyson

Micronuat is designed for the cloud. It has automated integration for service discovery with providers like Kubernetes and tracing like Jaeger. This lets you avoid hardcoding and design microservices with automated discovery and tracing via configuration. It also supports distributed config like Consul.

Micronaut has built-in datastore connectors and support for data access layers. It also supports OpenAPI descriptors.

Despite its advanced features, Micronaut’s endpoints are simple and readable:

import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;

@Controller("/hello")
public class HelloController {

    @Get("/{name}")
    public String hello(String name) {
        return "Hello, " + name;
    }
}

As its name implies, Micronaut is ideal for microservices, and really tries to make your life as easy as possible when developing them. It is possibly the most fine-tuned microservices framework for Java.

Also see: Intro to Micronaut: A cloud-native Java framework.

Helidon

Helidon is worth considering if you want to stick to the Java standards, be enterprise ready, and appreciate having your choice of framework types.

Helidon is both the newest framework covered here and an official project of Oracle. It was designed from the ground up for virtual threads and build-time dependency injection (similar to Micronaut). It also has recently added features targeting AI.

Matthew Tyson

Helidon comes in two varieties:

• SE (Standard Edition): The baseline collection of tools for building functional programming (FP) microservices. Focused on extremely small footprint and fast startup. As of Helidon 4, it uses virtual threads by default.
• MP (MicroProfile): Built on top of SE for value-added features. Adds in dependency injection and some other Jakarta EE component like JAX-RS and JSON-P.

Helidon SE resembles Javalin while Helidon MP is like Quarkus in terms of philosophy and feature set. The adoption of virtual threads means it has dispensed with complicated concurrency models, making it easier to understand and manage application nodes.

Here is an endpoint in Helidon SE:

import io.helidon.webserver.WebServer;
import io.helidon.webserver.http.HttpRouting;

public class Main {
  public static void main(String[] args) {
    HttpRouting routing = HttpRouting.builder()
      .get("/hello", (req, res) -> res.send("Hello from InfoWorld!"))
      .build();

    WebServer.builder()
      .routing(routing)
      .port(8080)
      .build()
      .start();
  }
}

Helidon’s killer feature is likely that it’s the Oracle standard and offers you the choice of model, whether you want to go more barebones DIY with SE or prefer an opinionated, all-in framework with MP.

Also see: The best Java and JVM language frameworks.

Conclusion

Java offers an extensive range of options for building everything in the modern cloud, from simple APIs to sophisticated microservices clusters, serverless deployments, and full-stack applications. Each of the Java microframeworks discussed in this article is solid, so there’s no need to be overwhelmed by choice. You can get started by identifying one or two that seem to meet your needs, then dip your toes into the code and choose the one that feels best. The nice thing about these frameworks is they all prioritize developer experience, leaving it up to you to decide which developer experience suits you best.