Spring Boot application with GraalVM Native Image

As a JAVA developer, processes can suffer from longer startup time and relatively high memory usage at times 😞. We will be looking for an exciting solution to this.

In this article, we will be going over a simple Spring Boot application, and then convert it to a Native Image using GraalVM.

If you are not aware of GraalVM, don’t worry. We will be discussing this in a while. For now, just keep in mind that it is a JVM that provides ahead-of-time compilation, in conjunction with compiling just-in-time at runtime.

Let’s first discuss the Spring Boot application we are going to code today. (We will be using Maven here, but you can use Gradle as well).

The application will expose two REST endpoints, both of which will accept HTTP GET requests.

• The first endpoint should provide the information corresponding to a Github user ( /users/{githubUserName} ).
• The second endpoint should provide the information corresponding to the contributors of a Github repository
  ( /contributors/{githubOrgName}/{githubRepoName} ).

The GithubController can be defined as follows —

We have autowired a class GithubClient in the controller, and use it for fetching the user or contributor details.

Here, we use RestTemplate to invoke the Github APIs.

Now, let’s have a look at the User DTO class, which will be used as the REST Response.

This can definitely be enough for doing the task, but let’s add some more spice to our application.

The Github API imposes a rate limit, owing to which you can’t make more than 60 requests in an hour from a given IP. We can increase this rate limit using Github authentication tokens.

Let’s define GithubProperties as the Spring Boot ConfigurationProperties.

So, now we can add a property named github.token in the application.properties / application.yaml . Since @ Validated and
@ Pattern annotations are used, on the startup of the application — it will be ensured that the property follows the mentioned regular expression.

Now, how to use this token when trying to invoke the Github API? Well, let’s implement a Spring RestTemplate interceptor.

Here, the intercept function of GithubAppTokenInterceptor adds an Authorization request header with the encoded value of the token provided.

The intercept function of the RateLimitHeaderInterceptor extracts the
X-RateLimit-Remaining response header and provides a log statement to provide the information regarding the rate limit remaining.

For using these two interceptors, we just need to provide these while initializing the restTemplate object

The final piece of the code is the entry point of the application.

The code which we discussed so far can be found here —

shivamgarg7276/graal-spring-native

Now, build using mvn clean install . Then run mvn spring-boot:run command and the application will start at port 8080 .

Hitting http://localhost:8080/users/shivamgarg7276 gives —

{
    "login": "shivamgarg7276",
    "name": "Shivam Garg",
    "company": "Nutanix",
    "avatarUrl": "https://avatars.githubusercontent.com/u/49524850?v=4",
    "blogUrl": "https://www.linkedin.com/in/shivam-garg-067b46141/",
    "numPublicRepos": 1,
    "htmlUrl": "https://github.com/shivamgarg7276"
}

So, the startup on my machine took around 1.5 sec and the memory consumption was around 200 MB . This gets the task done, but we will see how can we massively improve this using GraalVM.

What is GraalVM, and why it is the future of JAVA applications?

“GraalVM — Byte code to Bit Code” 😀😀

GraalVM is a high-performance polyglot compiler, which helps achieve -

1. Increase application throughput and reduce latency
2. Compile applications into small self-contained native binaries
3. Seamlessly use multiple languages and libraries

It can be used both for Java JIT as well as for AOT compilation.

For AOT compilation, it uses Native Image Builder or native-image technology to ahead-of-time compile the Java code to a standalone executable. It processes all classes of an application and their dependencies, including those from the JDK. It statically analyzes these data to determine which classes and methods are reachable during the application execution.

You can install GraalVM on your system using the steps I have highlighted here —

shivamgarg7276/graal-spring-native

Spring Native Beta

Some time back, the Spring team announced Spring Native Beta project to enable compilation of Spring applications to native images with GraalVM.

The memory consumption is promised to be much lower, and the startup is almost instant.

Now, let’s switch gears, and do some changes in our original Spring Boot application to transform it into a native executable Spring application. 😉

Once you install GraalVM on your machine, you need to do these changes in the original application —

• Add the org.springframework.experimental:spring-native-image maven dependency.

<dependency>
  <groupId>org.springframework.experimental</groupId>
  <artifactId>spring-native</artifactId>
  <version>0.9.2</version>
</dependency>

• Add Spring AOT plugin

<plugin>
  <groupId>org.springframework.experimental</groupId>
  <artifactId>spring-aot-maven-plugin</artifactId>
  <version>0.9.2</version>
  <executions>
    <execution>
      <id>test-generate</id>
      <goals>
        <goal>test-generate</goal>
      </goals>
    </execution>
    <execution>
      <id>generate</id>
      <goals>
        <goal>generate</goal>
      </goals>
    </execution>
  </executions>
</plugin>

• Add GraalVM native-image profile that triggers plugin during package phase

<profiles>
  <profile>
    <id>native-image</id>
    <build>
      <plugins>
        <plugin>
          <groupId>org.graalvm.nativeimage</groupId>
          <artifactId>native-image-maven-plugin</artifactId>
          <version>21.0.0.2</version>
          <configuration>
            <!-- The native image build needs to know the entry point to your application -->
            <mainClass>com.example.graal.restserver.main.RestApplicationWithAOT</mainClass>
            <buildArgs>
              <buildArg>--enable-https</buildArg>
            </buildArgs>
          </configuration>
          <executions>
            <execution>
              <goals>
                <goal>native-image</goal>
              </goals>
              <phase>package</phase>
            </execution>
          </executions>
        </plugin>
      </plugins>
    </build>
  </profile>
</profiles>

Here the mainClass argument is provided which points to the entry point of the application i.e the class annotated with SpringBootApplication .
Also, buildArgs have --enable-https as we invoke HTTPS based Github URLs using RestTemplate .

The code changes we discussed so far can be found here —

shivamgarg7276/graal-spring-native

You can build the module simply by using this command -
mvn -Pnative-image clean package

This will create a native executable comprising the Spring Boot application under the target folder of the module.

Simply invoke -
target/com.example.graal.restserver.main.restapplicationwithaot

This will start the Spring Boot server at port 8081.

If you see now, the startup time on my machine was 0.093 sec 😳 😯

That was super fast.

Also, the memory consumption shows to be under 40 MB . 👌

You can also generate an optimized container image using GraalVM + Spring Native, which can be easily deployed and comprises a minimal OS layer.

Conclusion

Obviously, you should test on your machine to compare these numbers. But, this clearly demonstrates the true power of GraalVM and the reason why this will be the future of Java applications. 😄

As mentioned by some industry experts —

There are many aspects of the native image which I have not discussed yet and will do in the upcoming parts of this post. We will look into some corner cases which require advanced configuration setups, and also some other optimizations.

Check out cool stuff at https://www.graalvm.org/.

You can express your opinions and give suggestions in the comments.

Thanks 😊

Edit: Check out Part 2 of this article —

Issues with Spring, how Micronaut solves it, and latter’s support for GraalVM