Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until end-of-day today:


NPI – Lightrun – Spring (partner)

We rely on other people’s code in our own work. Every day. It might be the language you’re writing in, the framework you’re building on, or some esoteric piece of software that does one thing so well you never found the need to implement it yourself.

The problem is, of course, when things fall apart in production - debugging the implementation of a 3rd party library you have no intimate knowledge of is, to say the least, tricky. It’s difficult to understand what talks to what and, specifically, which part of the underlying library is at fault.

Lightrun is a new kind of debugger.

It's one geared specifically towards real-life production environments. Using Lightrun, you can drill down into running applications, including 3rd party dependencies, with real-time logs, snapshots, and metrics. No hotfixes, redeployments, or restarts required.

Learn more in this quick, 5-minute Lightrun tutorial:

>> The Essential List of Spring Boot Annotations and Their Use Cases

1. Overview

As microservice architecture gains popularity, giant monolithic applications are becoming a thing of the past. Java isn't staying stagnant and instead is adapting to modern needs. For example, Oracle, Red Hat, BellSoft, and other contributors are actively developing the GraalVM project. In addition, the microservices-specific framework Quarkus was released a year ago. As far as Spring Boot is concerned, VMware has been working on the Spring Native project for two years.

As a result, thanks to the collaboration between VMware and BellSoft, Spring Native became an end-to-end native image solution, which includes the Liberica Native Image Kit, a tool based on the GraalVM source code. Spring Native and Liberica NIK allow developers to create native executables of Spring Boot applications that optimize resource consumption and minimize startup time.

In this tutorial, we’ll discover how to use the native image technology with Spring Boot applications by building and running the same app in three ways—as a classic JAR file; as a native image container with Liberica JDK and Spring Native; and as a native image with Liberica Native Image Kit. Then we'll compare their startup speeds. In every case, we'll use the petclinic JDBC application from the Spring Native project as an example.

2. Installation of Liberica JDK

First, let’s install the Java runtime for your system. We can visit the Liberica JDK download page and select the version for our platform. Let's use JDK 11, the x86 Linux Standard JDK package.

There are two ways to install Liberica JDK. One is through a package manager or by downloading the .tar.gz package (or .zip package for Windows).

The latter is a more advanced method, but don’t worry, it takes four steps only. We first need to change to the directory in which we want to install:

cd directory_path_name

Without leaving the directory, we can run:

wget https://download.bell-sw.com/java/

If we don’t have a wget command, we can install it through brew install wget (for Linux and Mac).

This way, we'll unpack the runtime into the directory we're in:

tar -zxvf bellsoft-jdk11.0.14.1+1-linux-amd64.tar.gz

After the installation has been completed, we can delete the .tar.gz file if we want to save the disc space.

Finally, we need to set up the JAVA_HOME variable by pointing at the Liberica JDK directory:

export JAVA_HOME=$(pwd)/jdk-

Please note: macOS and Windows users can refer to the Liberica JDK Installation Guide for instructions.

3. Getting the Spring Native Project

We can get the Spring Native project with petclinic app samples by running:

git clone https://github.com/spring-projects-experimental/spring-native.git

4. Building the JAR File

We want to work with one sample from the whole Spring Native project, so go to the directory with spring petclinic JDBC by running:

export PROJECT_DIR=$(pwd)/spring-native/samples/petclinic-jdbc && cd $PROJECT_DIR

To build the JAR file, we can apply this command:

./mvnw clean install

This will get us a 24 MB target/petclinic-jdbc-0.0.1-SNAPSHOT.jar. We'll test it by running:

java -jar target/petclinic-jdbc-0.0.1-SNAPSHOT.jar

5. Build a Native Image Container with Liberica JDK

Now let’s containerize our app.

Make sure that our Docker daemon is running. Note that we need to allocate at least 8 GB of memory to Docker if we use Windows or macOS x86. From the Spring petclinic JDBC application directory, we need to input the command:

./mvnw spring-boot:build-image

This will build the native image container with Spring Boot that we can launch with:

docker run -it docker.io/library/petclinic-jdbc:0.0.1-SNAPSHOT

If we work with Apple M1, this step will be unavailable to us due to the absence of a necessary buildpack for Docker. However, the latest version of Liberica Native Image Kit is fully compatible with Apple Silicon, so we can move to the next step and build a native image with NIK.

6. Build a Native Image with Liberica NIK

We'll use Liberica Native Image Kit to build another version of the petclinic native image. Below we can find the steps for installing NIK for Linux. For macOS or Windows, let's refer to the Liberica NIK Installation Guide.

We first need to change to the directory in which we want to install:

cd directory_path_name

Then we download Liberica NIK Core for our platform. It contains Liberica VM and GraalVM-based native image toolkit without additional languages, and so is a great tool to build Java native images.

In our case, we'll get the version of NIK for Java 11 for Linux:

wget https://download.bell-sw.com/vm/

We then unpack the file by running:

tar -xzf bellsoft-liberica-vm-openjdk11-

Define the $JAVA_HOME variable by pointing at Liberica NIK:

export JAVA_HOME=$(pwd)/bellsoft-liberica-vm-openjdk11-

Now, we go to the petclinic JDBC application directory:


And we can create a native image by running the following command:

./mvnw -Pnative install

It involves the “native” profile for the build and results in the target/petclinic-jdbc binary file 102.3 MB in size.

7. Compare Startup Time

Now let’s test the speed of our application and images. We used an Intel(R) Core(TM) i7-8750H CPU PC with SSD for running them:

  • the JAR file starts in about 3.3 seconds
  • the first container we built starts in about 0.07 seconds
  • the native image made with NIK Core starts in 0.068 seconds.

8. Conclusion

The Spring native images are built and work great even when the project is still in Beta. The startup time reduction is massive.

We can expect even better results when the Spring Native is released with the Liberica Native Image Kit used as the end-to-end solution for building native images.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until end-of-day today:


Generic footer banner
Comments are closed on this article!