GraalVM and Native Image Technology in Spring Boot Applications

Written by Vitelco | Oct 9, 2025 11:03:08 AM

GraalVM and Native Image Technology in Spring Boot Applications

Spring Boot is one of the most popular frameworks for developing fast and flexible Java applications. Large Spring Boot applications are often associated with two main challenges:

High memory consumption
Long startup times

To overcome these challenges, enhance performance, and unify different languages, Oracle introduced GraalVM, a polyglot virtual machine and execution environment.

GraalVM extends the JVM architecture in several ways.

Polyglot VM

While the JVM can only run Java or JVM-based languages (such as Kotlin and Scala), GraalVM is a Polyglot VM capable of running multiple programming languages (including Java, JavaScript, Python, R, etc.).

Native Image Technology

One of the most significant—and perhaps the most important—features of GraalVM is its ability to compile Java applications into native images.

Feature	JVM	GraalVM Native Image
Compilation Management	JIT (Just-in-Time)	AOT (Ahead-of-Time)
Execution Environment	Requires JVM	Runs directly on the OS
Startup Speed	Slower than Native Image	Faster
Memory Consumption	Higher	Lower

The Importance of Native Images in Spring Boot

The shift to Native Image technology is preferred in modern architectures for the following reasons:

Startup times are reduced to milliseconds, enabling extremely fast scalability.
Low resource consumption: Memory usage significantly decreases as JVM overhead is eliminated.

However, leveraging the Native Image structure requires certain trade-offs and introduces a few challenges:

Longer compilation time: The AOT process analyzes all code and transforms it into machine code, which can take significantly longer than a standard .jar build. This can slow down the development cycle.
GraalVM loads everything it needs at compile time and performs no class loading at runtime. Special configurations are required for projects that heavily use dynamic features in Java, such as reflection.
High-level JIT optimizations performed at runtime are not available. For long-running, CPU-intensive applications, the final peak performance might be slightly lower than with a traditional JVM.
Debugging can be slightly more complex.

Managing Reflection in GraalVM

The biggest challenge with Native Image technology is its difference from Java's reflection mechanism.

Reflection allows a Java program to inspect and change its own structure at runtime. Modern frameworks like Spring Boot heavily use reflection to provide flexibility.

GraalVM's structure conflicts with the dynamic nature of reflection:

The GraalVM (AOT Compiler) cannot know which class or method will be called via reflection at runtime when compiling your code.
GraalVM removes code that is deemed unused from the image. If that code is intended to be called via reflection, GraalVM considers it "dead code" and discards it. When the native image runs, the application crashes at runtime because the class or method intended for reflection is not found.

To overcome this issue, GraalVM relies on a reflection configuration file that it must consider during compilation. Through this file, you can instruct GraalVM which dynamic elements to preserve and not to consider "dead."

Example GraalVM Reflection Configuration File (reflect-config.json)

Goal:

Include the class native.TestService in the Native Image.
Enable runtime access to all declared constructors of the class.
Enable runtime access to the no-argument method named getMessage of the class.

[
{
   "name": "com.native.TestService",
"allDeclaredConstructors": true,
   "methods": [
     {
       "name": "getMessage",
       "parameterTypes": []
     }
   ],
   "fields": [
     {
       "name": "message",
       "allowWrite": false,
       "allowUnsafeAccess": true
     }
   ]
}
]

Field	Purpose
name	The fully qualified name of the class to be accessed via Reflection.
allDeclaredConstructors	Enables Reflection access to all constructors of the class.
methods	A list of methods to be called via Reflection.
parameterTypes	An array of the fully qualified Java names of the method's parameters. Use an empty array ([]) if there are no arguments.
fields	A list of fields to be accessed via Reflection.

If you are using Spring Boot 3+ (and Spring Native), it auto-generates this configuration file for you. During the AOT (Ahead-of-Time) phase of your application, Spring analyzes all its components and popular libraries, detects all necessary dynamic usages, and provides the required JSON configuration to the compiler. This largely eliminates the burden of manual configuration for the developer.

Manual configuration is only required in the following cases:

When you write non-standard, very dynamic code.
When you use an older or niche third-party library that has not yet been optimized for Native Image.

Steps to Compile a Spring Boot Application with GraalVM

GraalVM Installation: Install an Oracle GraalVM or an Eclipse Temurin-compiled GraalVM distribution. (e.g., from https://www.graalvm.org/downloads/#)
native-image Tool: Ensure the native-image feature, which is part of GraalVM, is installed.
Project Setup: When creating a new project via Spring Initializr (start.spring.io), be sure to add the "GraalVM Native Support" dependency. This automatically includes the necessary Spring Boot Maven/Gradle Plugin extensions.

<build>
      <plugins>
      <plugin>
            <groupId>org.graalvm.buildtools</groupId>
            <artifactId>native-maven-plugin</artifactId>
      </plugin>
      <plugin>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-maven-plugin</artifactId>
      </plugin>
      </plugins>
</build>

Compilation: After creating your project, you can compile it with a single command line:

mvn clean package -Pnative

This command uses AOT (Ahead-of-Time) compilation to turn the application into a Native Image.
Execution: Once the compilation is complete, you will have a directly executable file in the target directory that does not require a JVM:

./target/application_name

Your application will now run as a Native Image.

Conclusion

GraalVM Native Image is a powerful technology that allows Spring Boot to redefine industry standards for speed and efficiency, making it the ideal choice for Cloud Native, microservices, and serverless architectures. While there are underlying complexities like reflection management, the automatic AOT and configuration support provided by Spring Boot 3+ allow developers to largely benefit from these advantages without significant manual effort.

This article has been written by Taha Yiğit.

View full post