The best Java microframeworks to learn now

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:

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.