I stole it all!

This chapter will show you how to modify the pingpong-service-simple and

• Make it use GraalVM
• Compile it into a binary
• Package it into a Docker image
• Run it and compare that to a regular Java application

Here I must dedicate the code pretty much entirely to Josh Long who covers most of these steps in his Spring Tips: Spring and GraalVM (pt. 2) article!

You'll find the complete source code of the new GraalVM pingpong-service-simple under pingpong-service-simple-graalvm if you're a cheater that doesn't have the time to read on.

Startup the old one with AdoptOpenJDK

Before we get started with any conversion we should check out the startup performance of the existing Spring Boot App, using AdoptOpenJDK, just to get an idea of how long it takes to start up that one.

Let's do it from console after having compiled the source code using Maven. This should avoid any IDE-clutter. Go to you local checkout root folder of pingpong-service repository, use SDKMAN to switch to AdoptOpenJDK if necessary, and compile the project using mvn clean install. The result should be a fat-JAR under the /target-folder of each Maven-module, one of them being the pingpong-service-simple.

Let's go to the folder of that module and start up the application using the produced fat-JAR:

java -jar target/target/pingpong-service-simple.jar

This should launch the application and if you're on a reasonably fast computer like me (a Macbook Pro) it'll take somewhere between 3-4 seconds. That's not too bad but remember that this is a very simple application. From personal experience when having integrations that need to be bootstrapped, such as databases, caches and so forth, something like 10-20 seconds is not uncommon on a powerful multi-CPU machine. It gets even worse in a resource limited container in the Cloud.

Either way, if you're an end user requesting a page and it takes 3-4 seconds for the service to produce that page to start up, it's gonna be painful after a while. Or if a system experiences a dramatic increase in load and it takes 30 seconds for a new instance to start up that load might be gone already or the present services are crashing from overload.

Converting it and starting it with GraalVM

Ok, so let's being the journey towards GraalVM and see what that can do for us. I recommend that you use the source code of the simple-application without GraalVM and do this step by step rather than using the already pre-fabricated GraalVM folder in a backwards way. Otherwise you might accidentally "get too far too fast".

The first thing to try out is obviously to just compile and run the application as is using a console with GraalVM in use. Switch using SKDMAN by typing sdk use java 20.1.0.r11-grl then again compile, either the entire project or just the module if you like, with mvn clean install.

Make sure your Maven installation is obeying the instructions of SDKMAN. You can check the underlying Java in use by typing mvn --version in the GraalVM configured console. It should, among other things, output something similar to Java version: 11.0.7, vendor: GraalVM Community, runtime: /Users/andreas/.sdkman/candidates/java/20.1.0.r11-grl.

After this, assuming that you followed my advice to modify the simple-application, again run:

java -jar target/target/pingpong-service-simple.jar

To no ones surprise it will start and the startup time is really no different from the one using AdoptOpenJDK. So just using the runtime and SDK itself doesn't really improve anything, at least not in this case.

But now we're gonna begin adding Spring Graal stuff into the application which will, in the end allow us to build the native-image.

Using spring-graalvm-native

Compiling it and starting it as a native-image

Packaging it and starting it as a Docker image

Comparisons