The article walks through building a Spring Boot 3.2 application with JDK 21 as a GraalVM native image, compares binary and jar deployments, benchmarks against Go and Rust implementations, and concludes that AOT‑processed native images dramatically reduce startup time and memory usage despite long compile times.
This article walks through seven concrete Spring Boot startup optimizations—including lazy initialization, precise component scanning, JVM tuning, auto‑configuration slimming, class‑loading reduction, delayed database connections, and AOT/native compilation—showing real‑world benchmarks that cut launch times by around 70%.
The article compares Spring Boot and Quarkus, explaining how Quarkus’s build‑time optimizations, native image support, and container‑first design dramatically reduce startup time and memory usage, while also discussing development experience, extension mechanisms, and the trade‑offs involved in adopting the framework.
Spring Boot’s heavy runtime, driven by reflection and classpath scanning, incurs long cold starts and high memory usage, making it costly for serverless and edge deployments; lightweight frameworks like Quarkus, Micronaut, and Helidon shift work to compile time and offer native images, but introduce trade‑offs in dynamism, ecosystem coverage, and build complexity.
This article walks through converting a Spring Boot order‑query microservice to a GraalVM Native Image, detailing environment setup, common build pitfalls with concrete code fixes, Docker multi‑stage packaging, K8s scaling comparison, performance benchmarks, CI/CD integration, and guidance on when Native Image is appropriate.
Spring Boot 4.0.2, launched on January 22, brings more than 20 critical bug fixes, restores Kafka transaction auto‑configuration, improves startup performance by up to 15%, stabilizes native‑image support, refines test behavior, upgrades core dependencies, and introduces a few breaking changes, making it a must‑upgrade for production users.
A performance comparison of SpringBoot 4.0 with virtual threads shows Tomcat achieving up to fifteen times higher QPS than Jetty, while startup times remain similar, and provides step‑by‑step instructions for building native Docker images and switching containers.
This article presents seven concrete Spring Boot startup optimization techniques—including lazy bean initialization, precise component scanning, JVM flag tuning, auto‑configuration pruning, class‑loading shortcuts, lazy database connections, and GraalVM native compilation—backed by real‑world benchmarks that reduce launch times by up to 71% across e‑commerce, micro‑service, logistics and payment services.
The article outlines twelve concrete shifts—cloud‑native defaults, Project Loom virtual threads, selective reactive use, AI‑assisted coding, API‑first design, built‑in observability, modular monoliths, security‑by‑design, native images, confidence‑driven testing, DDD revival, and a move from code writing to system judgment—that will define Java backend engineering by 2026.
The article analyzes how Spring Boot 2026 reshapes Java backend development by embracing virtual threads, GraalVM native images, built‑in observability, modern security practices, immutable records, and cloud‑native defaults, urging developers to abandon legacy coding habits in favor of these emerging trends.
A detailed benchmark shows that enabling Java virtual threads in Spring Boot 4.0 makes Tomcat handle up to fifteen times more requests than Jetty, while startup times remain similar, and the article explains the test setup, configuration steps, native image builds, and the reasons behind Jetty's limitation.
The article debunks the myth that Spring Boot cannot scale, showing that with WebFlux, Netty, Reactive Redis, GraalVM Native Image and horizontal scaling a Spring Boot service can reliably achieve 500,000 queries per second, backed by concrete benchmark data and a full demo implementation.
This comprehensive guide explains why reflection configuration is essential for GraalVM native compilation, details Spring Boot 3's reflection mechanisms, enumerates common pitfalls with concrete solutions, and presents best‑practice strategies and tooling to reliably build native images for Java back‑ends.
Learn to compile a Spring Boot 3.5.6 application into a fast-starting native binary using GraalVM, configure the environment, add Maven plugins, write simple test code, and package the result into a lightweight Docker image, achieving dramatically reduced startup time and image size.
Oracle’s March 2025 release of JDK 24 and GraalVM 24 introduces a new Class‑File API and Premain support for Java agents, allowing static compilation of agents, improving observability, reducing native image size, and delivering measurable startup‑time and memory‑usage gains.
This article compares Spring Boot and Quarkus across architecture, startup speed, memory usage, and native image support, presents a JMeter‑based performance test suite, shares migration tips for Spring developers, and provides concrete Java code examples for building reactive microservices on both frameworks.
This guide walks through the prerequisites, GraalVM installation, Maven setup, and step‑by‑step packaging of a Spring Boot 3 application into a native executable using AOT compilation, runtime hints, and Docker, demonstrating dramatically faster startup times.
This article explains how to prepare the environment, configure GraalVM, use Maven plugins, and apply Spring Boot 3.0 AOT and RuntimeHints to compile a Spring Boot application into a fast‑starting native executable, including Docker packaging and underlying AOT principles.
This article evaluates the startup speed, memory consumption, and request‑handling throughput of a Spring Boot application built as a GraalVM native binary, a regular JAR, and equivalent services written in Go and Rust, highlighting the trade‑offs of AOT compilation for backend development.
The article benchmarks a Spring Boot 3 service as a GraalVM native image, a traditional JAR, and Go and Rust versions, showing the native binary starts in under a second with ~70 MB memory and 7 k requests/s, the JAR needs seconds and 200 MB, while Go and Rust use 10 MB and 3 MB respectively with throughput, illustrating native images’ fast startup and lower runtime footprint despite longer compilation.
This guide explains the challenges of Java cold‑start and high runtime memory in cloud‑native environments, introduces GraalVM static compilation and a novel static Java Agent instrumentation solution, and provides step‑by‑step instructions—including dependency installation, Maven configuration, pre‑run collection, and native image building—to enable observable, high‑performance Java applications.
This article demonstrates how to quickly build and benchmark a Spring Boot 2.x application as a native binary, compares its startup time, memory usage, and request throughput with equivalent implementations in Go and Rust, and concludes that AOT‑processed Java offers impressive performance despite longer compilation times.
This article explains how Alibaba Cloud engineers tackled the challenges of long startup times and high memory usage in Java serverless workloads by designing a static Java Agent instrumentation that works with GraalVM Native Image, preserving OpenTelemetry observability while dramatically improving performance.
GraalVM Native Image now supports Native Memory Tracking (NMT), allowing developers to monitor off‑heap memory allocations, compare Java and native execution, integrate with JFR, and assess performance impact through detailed reports and experimental events.
Spring Boot 3.2 now fully supports Java 21, Project Loom virtual threads, and GraalVM native images, and this guide walks through installing Java 21‑GraalVM, configuring virtual threads, building sample controllers, async and scheduled tasks, and creating a native executable to achieve faster startup and lower memory usage.
This article demonstrates how to use Spring Boot 3.2 with Java 21, enabling virtual threads and GraalVM native images, providing step‑by‑step setup, configuration, and sample code for controllers, async tasks, and scheduled jobs, and discusses performance benefits and considerations.
This article evaluates the startup speed, memory consumption, and request‑handling performance of a simple Spring Boot "Hello World" service when run on the traditional JVM compared with a GraalVM‑compiled native binary, using a MacBook M1 and Bombardier for load testing.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, providing step‑by‑step instructions, configuration details, and runnable code examples that showcase building, running, and profiling a Spring Boot application with these modern technologies.
This article demonstrates how Spring Boot 3.2 fully supports Java 21, Project Loom virtual threads, and GraalVM native images, guiding you through installation, configuration, sample code, and performance benefits of running a Spring application on virtual threads and native compilation.
This article compares Spring Boot and Quarkus, detailing their architectures, reactive capabilities, native image support, and performance metrics from JMeter and VisualVM tests, while also offering migration guidance for developers moving from Spring to the Kubernetes‑native Quarkus framework.
This article compares Spring Boot and Quarkus across startup time, memory usage, CPU consumption, and response latency, presents benchmark results from JMeter and VisualVM tests, and provides practical guidance for migrating Java developers from Spring to the cloud‑native Quarkus framework.
This article introduces Spring Native, explains how it uses GraalVM to compile Spring Boot apps into native executables with sub‑100 ms startup and lower memory usage, provides step‑by‑step setup and Docker build instructions, and compares its performance against traditional Spring Boot launches.
The new GraalVM for JDK 21 brings full virtual‑thread support, native‑image capabilities without preview flags, performance improvements, early Java Vector API optimizations, and a high‑performance runtime for Java and other languages, with download links and additional resources for developers.
This article explains why Java applications should migrate from JDK 8 to JDK 17, introduces GraalVM native‑image technology, provides detailed upgrade procedures, Maven configuration, code examples, and a summary of performance benefits and typical issues encountered during the migration.
Oracle GraalVM’s new release for JDK 17 and JDK 20 adds free‑to‑use native‑image features—including profile‑guided optimizations, G1 GC, object‑header compression, ML‑driven PGO, and SBOM support—delivering up to 46% faster startup, 2‑3× lower memory usage, and up to 1.6× higher peak throughput compared with traditional JIT, while also introducing new tooling such as native‑image bundles, build reports, enhanced AWT support, and experimental monitoring.
The recent GraalVM community survey reveals that 65% of respondents already use or plan to use GraalVM in production, with native image creation, polyglot APIs, and Java being the most popular use cases, while challenges include library support and better error diagnostics.
This guide walks through setting up GraalVM on Ubuntu, configuring environment variables, handling native-image agent pitfalls, fixing H2 database class‑loading issues, and finally producing a compact native executable for a Solon‑based Java service with memory‑optimisation tips.
This tutorial walks through installing GraalVM, configuring Spring Native, building a native Spring Boot application using Buildpacks or the native‑image plugin, creating Docker containers, and comparing startup speed and memory usage against traditional Java execution, providing full pom.xml examples and official documentation links.
This article explains what Spring Native is, how to set up the required environment, the two main ways to build a native Spring Boot image using either Buildpacks or the GraalVM native-image Maven plugin, and demonstrates container deployment and performance comparison with traditional JVM execution.
Spring Boot 3.0 RC1 introduces 135 enhancements, native executable support via Maven/Gradle plugins, migration to Jakarta EE 9, Java 17 baseline, and new features such as flexible Spring Data JDBC auto‑configuration, Prometheus example auto‑configuration, and Log4j2 improvements, with full details in the release notes.
Spring Boot 3.0 RC1 arrives with 135 enhancements, native image generation via GraalVM, JakartaEE 9 migration, Java 17 upgrade, and new auto‑configuration features for Spring Data JDBC, Prometheus, and Log4j2, while the 2.7.5 and 2.6.13 releases focus on bug fixes and dependency updates.
This article introduces Spring Native, explains how native images built with GraalVM can reduce Spring Boot startup time to under 100 ms, walks through environment setup, project initialization, Docker image creation, performance testing, and provides troubleshooting tips for common issues.
This article walks through writing a simple Java program, compiling it with javac, then using GraalVM's native-image tool to produce a JVM‑independent executable, compares file size and startup speed, discusses native-image limitations, and shows how Spring Boot can be built as a native image for dramatically faster startup.
GraalVM 21.2 introduces major updates across its ecosystem, including new Gradle and Maven plugins for Native Image with JUnit 5 support, enhanced compiler optimizations, expanded Truffle language capabilities, improved JavaScript, Ruby, Python, LLVM, and upgraded tooling such as VisualVM and JFR integration.
This guide walks through building the mica-mqtt MQTT component with GraalVM native-image, covering dependency setup, Caffeine configuration, Maven plugin settings, binary compression with UPX, and performance comparisons that demonstrate millisecond‑level startup versus traditional JAR execution.
In this interview, Mercyblitz shares his background, discusses Java's role in cloud‑native computing, explains recent Dubbo advancements and plans for native support, and offers insights on technology selection, architectural challenges, and his upcoming GIAC talk on Java cloud‑native ecosystems.
This tutorial demonstrates how to create a Micronaut microservice, compile it into a GraalVM Native Image, and apply advanced optimizations such as G1 GC, profile‑guided compilation, and UPX packing to achieve faster startup, lower memory usage, and higher throughput in cloud environments.
This article walks through building a Spring Native application with GraalVM, demonstrates how to generate native‑image configuration files, and shows step‑by‑step integration of Mica components such as ip2region, captcha, and caffeine using Spring Native hints and custom resource configurations.
This guide walks you through installing GraalVM, configuring Spring Native with Maven, building a native executable, and compressing it with UPX, demonstrating how to create high‑performance Java microservices in just a few minutes.
This guide introduces GraalVM’s key capabilities—including a high‑performance JIT compiler, native‑image generation for low‑memory binaries, and seamless polyglot support—while providing essential command‑line options and code examples for Java, native, and multiple language development.
This guide summarizes GraalVM's key capabilities—including a high‑performance JIT compiler, native‑image generation for instant startup and low memory, and polyglot support for multiple languages—while providing essential command‑line options and code examples for developers.
The Spring Native beta release lets developers compile Spring applications into GraalVM native images via start.spring.io, offering near‑instant startup, peak performance, and lower memory usage while outlining usage, collaboration, supported scope, AOT transformation, and future roadmap.
This article provides a concise, English‑language guide to GraalVM, covering its high‑performance JIT compiler, native‑image generation for instant‑start binaries, and polyglot capabilities for running Java, JVM languages, JavaScript, Python, Ruby, R, and more, with key commands and options.
This article explains how to install GraalVM and its native‑image component, configure a Spring Boot 2.4 project for native compilation, and compare startup time and memory usage between traditional JVM and GraalVM‑compiled executables, demonstrating significant performance gains.
This guide walks through installing GraalVM, adding the native‑image tool, creating a Spring Boot 2.4 project, configuring it for GraalVM, building a native executable, and comparing startup time and memory usage, showing how GraalVM can reduce startup from over a second to 0.2 seconds and memory from 480 MB to 25 MB.
