{"id":691,"date":"2026-06-14T23:30:34","date_gmt":"2026-06-14T22:30:34","guid":{"rendered":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=691"},"modified":"2026-07-07T23:31:40","modified_gmt":"2026-07-07T22:31:40","slug":"helidon-4-5-der-schlanke-cloud-native-java-stack-mit-virtual-threads","status":"publish","type":"post","link":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/?p=691","title":{"rendered":"Helidon 4.5 \u2013 Der schlanke Cloud-native Java-Stack mit Virtual Threads"},"content":{"rendered":"\n

Wenn Java-Entwickler an Microservices denken, fallen zuerst Quarkus und Micronaut. Doch seit Version 4 hat Oracle’s Helidon einen bemerkenswerten Wandel vollzogen: Es ist das erste Java-Webframework, das vollst\u00e4ndig auf Virtual Threads (Project Loom) basiert \u2014 und bietet damit eine erfrischende Alternative zum reaktiven Programmiermodell.<\/p>\n\n\n\n

Dieser Artikel zeigt dir den Einstieg in Helidon 4.5 und erkl\u00e4rt, warum der \u201eBlocking-Code auf Virtual Threads“-Ansatz das Leben von Microservice-Entwicklern einfacher macht.<\/p>\n\n\n\n

Was ist Helidon?<\/h2>\n\n\n\n

Helidon (griechisch f\u00fcr Schwalbe \u2014 ein kleiner, wendiger Vogel) gibt es in zwei Flavors:<\/p>\n\n\n\n

Flavor<\/th>Beschreibung<\/th><\/tr><\/thead>
Helidon SE<\/strong><\/td>Funktionaler, expliziter Stil ohne Framework-Magie. Kleinster Footprint (~34 MB native).<\/td><\/tr>
Helidon MP<\/strong><\/td>MicroProfile-kompatibel mit CDI, JAX-RS, JSON-P\/B. F\u00fcr Jakarta-EE-erfahrene Teams.<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n

Beide teilen sich den Helidon WebServer als Kern und unterst\u00fctzen Java 21+ sowie GraalVM Native Image. Der aktuelle Release ist Helidon 4.5.0<\/strong> (Juni 2025).<\/p>\n\n\n\n

Der Clou: Virtual Threads statt Reactive<\/h2>\n\n\n\n

Das reaktive Programmierparadigma (Project Reactor, RxJava, Mutiny) hat ein echtes Problem: Der Code wird schwer lesbar, Stacktraces werden unbrauchbar, und Debugging wird zur Qual. Helidon 4 l\u00f6st das anders: Es verwendet Java Virtual Threads, die bei I\/O-Operationen automatisch vom JVM-Scheduler suspendiert werden, ohne Plattform-Threads zu blockieren.<\/p>\n\n\n\n

Das Resultat:<\/strong> Du schreibst ganz normalen, blockierenden Code \u2014 und die JVM macht ihn hochskalierend.<\/p>\n\n\n

<em>\/\/ In Spring WebFlux (reaktiv):<\/em><\/span>\nreturn<\/span> userRepository.findById(id)\n    .flatMap(user -> orderService.findOrders(user))\n    .map(orders -> new<\/span> UserWithOrders(user, orders));\n\n<em<\/span>><\/span>\/\/ In Helidon (blockierend auf Virtual Threads):<\/em<\/span>><\/span><\/span>\nvar<\/span> user = userRepository.findById(id);\nvar<\/span> orders = orderService.findOrders(user);\nreturn<\/span> new<\/span> UserWithOrders(user, orders);\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Beide Varianten skalieren auf Millionen gleichzeitiger Verbindungen \u2014 aber nur eine liest sich wie normaler Java-Code.<\/p>\n\n\n\n
Quickstart: ein REST-Endpunkt mit Helidon SE<\/h2>\n\n\n\n
Projekt mit der Helidon CLI erstellen:<\/p>\n\n\n
curl -L -O https:\/\/helidon.io\/cli\/latest\/darwin\/helidon<\/span>\nchmod +x helidon && sudo mv helidon \/usr\/local\/bin\/\n\nhelidon init --batch -Dflavor=se -Dapp-type=quickstart\ncd quickstart-se && mvn clean package -Pjre\njava -jar target\/quickstart-se.jar\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Die generierte Main.java<\/code>:<\/p>\n\n\n
import<\/span> io.helidon.webserver.WebServer;\nimport<\/span> io.helidon.webserver.http.HttpRouting;\n\npublic class<\/span> Main<\/span> <\/span>{\n    public static<\/span> void<\/span> main(String<\/span>[] args) {\n        WebServer.builder()\n            .port(8080<\/span>)\n            .addRouting(HttpRouting.builder()\n                .get(\"\/greet\"<\/span>, (req, res) -> res.send(\"Hallo Helidon!\"<\/span>))\n                .get(\"\/greet\/{name}\"<\/span>, (req, res) -> {\n                    String<\/span> name = req.path().pathParameters().get(\"name\"<\/span>);\n                    res.send(\"Hallo \"<\/span> + name + \"!\"<\/span>);\n                })\n            )\n            .build()\n            .start();\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Noch simpler geht’s kaum. Der Server startet in ~0,6 Sekunden, und jede Anfrage l\u00e4uft auf einem eigenen Virtual Thread.<\/p>\n\n\n\n
Eine kleine REST-API mit Services<\/h2>\n\n\n\n
So sieht eine vollst\u00e4ndige Todo-API mit Dependency Injection (Helidon Inject) und JSON-Serialisierung aus:<\/p>\n\n\n
<em>\/\/ Todo.java \u2014 Modell<\/em><\/span>\npublic<\/span> record Todo(String id, String task, boolean done) {}\n\n<em>\/\/ TodoService.java \u2014 Business-Logik<\/em><\/span>\n@Singleton\npublic<\/span> class<\/span> TodoService<\/span> <\/span>{\n    private<\/span> final<\/span> Map<String, Todo> todos = new<\/span> ConcurrentHashMap<>();\n\n    public<\/span> TodoService() {\n        add(new<\/span> Todo(\"1\"<\/span>, \"Helidon lernen\"<\/span>, false<\/span>));\n    }\n\n    public<\/span> List<\/span><Todo> list<\/span>() {\n        return<\/span> List<\/span>.copyOf(todos.values());\n    }\n\n    public<\/span> Todo add(Todo todo) {\n        todos.put(todo.id(), todo);\n        return<\/span> todo;\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> PHP<\/span> (<\/span>php<\/span>)<\/span><\/small><\/pre>\n\n
<em>\/\/ TodoRoutes.java \u2014 HTTP-Endpunkte<\/em><\/span>\nimport<\/span> io.helidon.webserver.http.HttpRules;\nimport<\/span> io.helidon.webserver.http.HttpService;\nimport<\/span> io.helidon.webserver.http.ServerRequest;\nimport<\/span> io.helidon.webserver.http.ServerResponse;\nimport<\/span> jakarta.json.Json;\nimport<\/span> jakarta.json.JsonArrayBuilder;\nimport<\/span> jakarta.json.JsonObject;\n\n@Singleton\npublic class<\/span> TodoRoutes<\/span> implements<\/span> HttpService<\/span> <\/span>{\n\n    private final TodoService service;\n\n    @Inject\n    public TodoRoutes(TodoService service) {\n        this<\/span>.service = service;\n    }\n\n    @Override\n    public void<\/span> routing(HttpRules rules) {\n        rules.get(\"\/todos\"<\/span>, this<\/span>::getAll)\n               .post(\"\/todos\"<\/span>, this<\/span>::create);\n    }\n\n    private void<\/span> getAll(ServerRequest req, ServerResponse res) {\n        var<\/span> json = service.list().stream()\n            .map(t -> Json.createObjectBuilder()\n                .add(\"id\"<\/span>, t.id())\n                .add(\"task\"<\/span>, t.task())\n                .add(\"done\"<\/span>, t.done())\n                .build())\n            .collect(Json.createArrayBuilder(), JsonArrayBuilder<\/span>::add, (a, b) -> {})\n            .build();\n        res.header(\"Content-Type\"<\/span>, \"application\/json\"<\/span>).send(json);\n    }\n\n    private void<\/span> create(ServerRequest req, ServerResponse res) {\n        JsonObject body = req.content().as(JsonObject.class);\n        Todo todo = service.add(new<\/span> Todo(\n            UUID.randomUUID().toString(),\n            body.getString(\"task\"<\/span>),\n            false<\/span>\n        ));\n        res.status(201<\/span>).send(todo);\n    }\n}\n<\/code><\/span>Code-Sprache:<\/span> JavaScript<\/span> (<\/span>javascript<\/span>)<\/span><\/small><\/pre>\n\n\n
Virtual-Thread-Architektur unter der Haube<\/h2>\n\n\n\n
Helidon 4’s Server (urspr\u00fcnglich unter dem Codenamen \u201eN\u00edma“ entwickelt) verwendet folgendes Thread-Modell:<\/p>\n\n\n\n
    \n
  1. Socket-Listener<\/strong>\u00a0laufen auf Plattform-Threads (ein Thread pro Server-Socket)<\/li>\n\n\n\n
  2. HTTP\/1.1<\/strong>: Ein Virtual Thread pro Verbindung (bearbeitet Routing + alle Requests)<\/li>\n\n\n\n
  3. HTTP\/2<\/strong>: Ein Virtual Thread pro Stream \u2014 jeder Stream bekommt Routing auf einem eigenen Thread<\/li>\n\n\n\n
  4. Der JVM-Scheduler multiplexiert Millionen Virtual Threads auf wenige OS-Threads<\/li>\n<\/ol>\n\n\n\n
    Das bedeutet: Du kannst Code wie Thread.sleep()<\/code> oder blockingRepository.findById()<\/code> ganz normal aufrufen, ohne Angst vor Thread-Pool-Ersch\u00f6pfung. Der Virtual Thread wird suspendiert, der Carrier-Thread arbeitet weiter an einem anderen Virtual Thread, und sobald das I\/O bereit ist, l\u00e4uft dein Code weiter.<\/p>\n\n\n\n
    Performance & GraalVM Native Image<\/h2>\n\n\n\n
    Helidon SE gl\u00e4nzt mit beeindruckenden Werten:<\/p>\n\n\n\n
    Metrik<\/th>JVM<\/th>Native Image<\/th><\/tr><\/thead>
    Speicher (RSS)<\/td>~70 MB<\/td>~34 MB<\/td><\/tr>
    Startup-Zeit<\/td>0,6 s<\/td>0,06 s<\/td><\/tr>
    Artefaktgr\u00f6\u00dfe<\/td>333 MB<\/td>38 MB<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n
    Mit GraalVM Native Image lassen sich sub-100ms Startup-Zeiten erreichen \u2014 ideal f\u00fcr Serverless und Auto-Scaling. Das native Image baust du mit:<\/p>\n\n\n
    mvn package -Pnative\n<\/code><\/span><\/pre>\n\n\n
    Helidon SE vs. Helidon MP: Wann welchen Flavor?<\/h2>\n\n\n\n
      \n
    • Helidon SE<\/strong>\u00a0eignet sich f\u00fcr Teams, die maximale Kontrolle und minimalen Footprint wollen. Keine Annotation-Magie, kein CDI-Overhead, direkte APIs.<\/li>\n\n\n\n
    • Helidon MP<\/strong>\u00a0ist ideal f\u00fcr Teams mit Jakarta-EE-Hintergrund oder wenn MicroProfile-Standards (Health, Metrics, OpenAPI, Config) gefordert sind.<\/li>\n<\/ul>\n\n\n\n
      Maven BOM f\u00fcr eigene Projekte<\/h2>\n\n\n
      <dependencyManagement<\/span>><\/span>\n    <dependencies<\/span>><\/span>\n        <dependency<\/span>><\/span>\n            <groupId<\/span>><\/span>io.helidon<\/groupId<\/span>><\/span>\n            <artifactId<\/span>><\/span>helidon-bom<\/artifactId<\/span>><\/span>\n            <version<\/span>><\/span>4.5.0<\/version<\/span>><\/span>\n            <type<\/span>><\/span>pom<\/type<\/span>><\/span>\n            <scope<\/span>><\/span>import<\/scope<\/span>><\/span>\n        <\/dependency<\/span>><\/span>\n    <\/dependencies<\/span>><\/span>\n<\/dependencyManagement<\/span>><\/span>\n<\/code><\/span>Code-Sprache:<\/span> HTML, XML<\/span> (<\/span>xml<\/span>)<\/span><\/small><\/pre>\n\n\n
      Fazit<\/h2>\n\n\n\n
      Helidon 4 beweist, dass Java-Microservices nicht reaktiv sein m\u00fcssen, um hochskalierend zu sein. Virtual Threads erlauben sauberen, debuggaren Code mit vergleichbarer Performance. Besonders Helidon SE besticht durch seine Einfachheit: Keine Reflexion, keine Annotation-Prozessoren, keine Framework-Magie \u2014 nur Java, so wie du es kennst.<\/p>\n\n\n\n
      F\u00fcr den n\u00e4chsten Microservice solltet ihr Helidon definitiv auf der Shortlist haben.<\/p>\n","protected":false},"excerpt":{"rendered":"
      Wenn Java-Entwickler an Microservices denken, fallen zuerst Quarkus und Micronaut. Doch seit Version 4 hat Oracle’s Helidon einen bemerkenswerten Wandel vollzogen: Es ist das erste Java-Webframework, das vollst\u00e4ndig auf Virtual Threads (Project Loom) basiert \u2014 und bietet damit eine erfrischende Alternative zum reaktiven Programmiermodell. Dieser Artikel zeigt dir den Einstieg in Helidon 4.5 und erkl\u00e4rt, […]<\/p>\n","protected":false},"author":1,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[4],"tags":[],"class_list":["post-691","post","type-post","status-publish","format-standard","hentry","category-plain_java"],"_links":{"self":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/691","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcomments&post=691"}],"version-history":[{"count":1,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/691\/revisions"}],"predecessor-version":[{"id":692,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=\/wp\/v2\/posts\/691\/revisions\/692"}],"wp:attachment":[{"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fmedia&parent=691"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Fcategories&post=691"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/www.xn--javaeinfacherklrt-4qb.de\/index.php?rest_route=%2Fwp%2Fv2%2Ftags&post=691"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}