Tagged articles
Native Image
65 articles · Page 1 of 1
This article explains how Spring Boot 3's Ahead-of-Time (AOT) processing resolves reflection registration issues when compiling Spring applications to GraalVM native images, covering build-time artifact generation, RuntimeHints API, and the @RegisterReflectionForBinding annotation.
AOTCloud Native JavaGraalVM
0 likes · 15 min read

The article explains why Quarkus is gaining adoption over Spring Boot for cloud-native Java, detailing its build-time processing architecture that eliminates runtime reflection, resulting in 1.3s JVM startup, 200ms native startup, 2.5x lower memory, and 2.7x higher throughput, with trade-offs like ecosystem maturity and Native Image complexity.
Build-Time ProcessingJavaNative Image
0 likes · 19 min read

This article analyzes why Quarkus is gaining adoption over Spring Boot for cloud-native Java, detailing its build-time processing architecture that eliminates runtime reflection, delivering 2.7x higher throughput, 2.3x faster startup, and 2.2x lower memory usage, with benchmarks, code examples, and migration trade-offs.
ArCBuild-Time ProcessingGraalVM
0 likes · 19 min read


java1234Sep 20, 2026 · Artificial Intelligence
This article explores Quarkus's AI integration via the LangChain4j extension, demonstrating declarative AI services, function calling with tools, retrieval-augmented generation (RAG), and Model Context Protocol (MCP) support, all while retaining Quarkus's cloud-native benefits like fast startup and native compilation.
AILangChain4jMCP
0 likes · 13 min read

This article analyzes how GraalVM Native Image 23.0 and Spring Boot 3.5 enable millisecond cold starts, 80% smaller containers, and production-ready serverless Java across AWS, Alibaba Cloud, Tencent Cloud, and Azure — with benchmarks, migration steps, and pitfall solutions.
AOT CompilationDockerGraalVM
0 likes · 19 min read


java1234Aug 9, 2026 · Backend Development
Spring Boot 3 raises its minimum Java version to 17 because Spring Framework 6 moves to Jakarta EE 9+, ending support for the javax.* namespace, and Oracle stopped free updates for JDK 8, making migration essential for security, ecosystem compatibility, and to leverage new language features and Spring‑Boot‑specific improvements.
JDK 17Jakarta EEJava Records
0 likes · 10 min read

The article reviews the JVM series finale, explaining how GraalVM Native Image, Project Loom, Project Valhalla, and Project Panama each address Java’s historic shortcomings—startup latency, heavyweight threads, object overhead, and clumsy native interop—while weighing their trade‑offs and future impact.
GraalVMJVMJava performance
0 likes · 12 min read

Spring Data AOT in Spring Boot 4 moves all repository parsing, reflection and query generation to compile time, dramatically cutting startup time, reducing memory and Metaspace usage, enabling compile‑time SQL validation, simplifying GraalVM native‑image configuration, and providing measurable performance gains backed by real‑world benchmarks.
AOTGraalVMJava
0 likes · 17 min read

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.
GoGraalVMJDK 21
0 likes · 9 min read

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%.
AOTAuto-configurationJVM tuning
0 likes · 9 min read

This article details compiling Spring Boot 3 applications to GraalVM native images, covering static analysis constraints, RuntimeHints configuration, build pipeline setup, performance benchmarks showing 0.14s startup and 115MB RSS, monitoring without JFR, and production pitfalls like HTTPS and Netty, with a phased rollout strategy for cloud-native deployments.
AOT CompilationGraalVMMaven
0 likes · 14 min read

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.
JavaKubernetesMicroProfile
0 likes · 14 min read

The article explores Feat's attempt to build a reflection‑free ORM that preserves MyBatis‑like developer experience by moving all mapping work to compile time, discusses the challenges posed by Java's AOT shift, and argues why such an experiment is both risky and worthwhile.
AOTGraalVMJava
0 likes · 6 min read

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.
HelidonMicronautNative Image
0 likes · 10 min read

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.
CI/CDDockerGraalVM
0 likes · 12 min read

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.
KafkaNative Imagedependency-upgrade
0 likes · 8 min read

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.
DockerJettyNative Image
0 likes · 10 min read


java1234Jan 27, 2026 · Backend Development
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.
Auto-configurationClass LoadingDatabase Connection
0 likes · 9 min read

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.
AI codingJavaNative Image
0 likes · 8 min read

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.
GraalVMNative ImageObservability
0 likes · 8 min read

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.
DockerJettyNative Image
0 likes · 10 min read

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.
Horizontal ScalingNative ImageNetty
0 likes · 10 min read

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.
GraalVMJavaNative Image
0 likes · 5 min read

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.
GraalVMMavenNative Image
0 likes · 8 min read

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.
ARMSGraalVMJava
0 likes · 7 min read

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.
JavaKubernetesNative Image
0 likes · 13 min read

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.
AOTDockerGraalVM
0 likes · 12 min read

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.
AOTGraalVMJava
0 likes · 12 min read

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.
GoGraalVMJava
0 likes · 7 min read

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.
GoGraalVMJava
0 likes · 9 min read

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.
GraalVMJava AgentNative Image
0 likes · 17 min read

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.
BackendGoNative Image
0 likes · 7 min read

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.
GraalVMJava AgentNative Image
0 likes · 13 min read

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.
GraalVMJFRNative Image
0 likes · 17 min read

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.
GraalVMJava 21Native Image
0 likes · 9 min read

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.
GraalVMJava 21Native Image
0 likes · 8 min read

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.
JavaNative Imagebenchmark
0 likes · 9 min read

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.
GraalVMJava 21Native Image
0 likes · 8 min read

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.
GraalVMJava 21Native Image
0 likes · 9 min read

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.
KubernetesNative ImageQuarkus
0 likes · 17 min read

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.
JavaKubernetesNative Image
0 likes · 15 min read

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.
DockerGraalVMJava
0 likes · 6 min read

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.
GraalVMJDK21Java
0 likes · 4 min read


JD TechJul 10, 2023 · Backend Development
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.
GraalVMMavenNative Image
0 likes · 13 min read

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.
GraalVMJava performanceNative Image
0 likes · 18 min read

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.
BackendGraalVMJava
0 likes · 10 min read

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.
GraalVMJavaNative Image
0 likes · 13 min read

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.
BuildpacksDockerGraalVM
0 likes · 12 min read

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.
DockerMavenNative Image
0 likes · 10 min read

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.
GraalVMJakarta EENative Image
0 likes · 2 min read

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.
JakartaEEJavaNative Image
0 likes · 3 min read

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.
DockerGraalVMNative Image
0 likes · 8 min read

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.
AOT CompilationGraalVMJava
0 likes · 12 min read

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.
Compiler OptimizationsGraalVMMulti-language
0 likes · 18 min read

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.
GraalVMJavaNative Image
0 likes · 8 min read

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.
DubboJavaNative Image
0 likes · 7 min read

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.
G1 GCGraalVMJava
0 likes · 21 min read

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.
GraalVMJavaNative Image
0 likes · 7 min read

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.
GraalVMNative ImageSpring Native
0 likes · 7 min read

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.
GraalVMJIT compilerJava
0 likes · 10 min read

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.
GraalVMJIT compilerJava
0 likes · 10 min read

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.
GraalVMNative ImageSpring Native
0 likes · 11 min read

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.
GraalVMJITJava
0 likes · 10 min read

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.
GraalVMJavaNative Image
0 likes · 6 min read

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.
GraalVMJavaNative Image
0 likes · 8 min read
