Updated April 3, 2023
Definition of Spring Boot GraalVM
Spring boot graalvm is providing support for compiling spring boot applications, as compared to the JVM (java virtual machine) spring boot graalvm images are cheaper and sustainable for hosting different types of loads. Graalvm has included the function workloads, microservices, Kubernetes, and containers. Using graalvm native images is providing many key advantages like an instant startup, reduced memory consumption, and peak performance. Graalvm is nothing but a universal virtual machine used to run an application that was written in python, ruby, javascript, and java.
What is Spring Boot GraalVM?
- It is used to compile the byte code and java into the executable file of native binary which was running without using JVM.
- This application provides support for the packaging and spring application as native images.
- Native images have a faster start-up time as compared to java virtual machines. However, developing or building image spring boot graalvm is taking time as compared to JVM.
- It is used to support the application by using the spring native. Graalvm application images are small, it will be optimized and boot quickly as compared to other images.
- We can also convert our existing application into spring boot graalvm images which were written in python, java, and kotlin.
- Maven and gradle plugins are used to transform the application into the native code.
- The maven and gradle plugin will implement the graalvm native configuration for all the spring elements which was supported by graalvm.
- The configuration of graalvm is stored in the reflect-config.json file. An example of this is if the class is annotated by @service is configured by using json file.
- Native configuration files are discovered and it resides in the META-INF folder.
- To develop an application by using graalvm we require spring native dependency need to add in pom.xml file.
- Spring JPA dependency is providing support to the graalvm application. To configure the application using spring data JPA dependency it will require extra configuration in our project.
Spring Boot GraalVM Application
- We can convert the existing spring boot application into the native image by using graalvm.
- It is nothing but a high-performance compiler that was used to increase the throughput of the application and used to reduce the latency of the application.
- It is also used to compile the application into small native binaries. Spring boot graalvm also uses libraries and multiple languages.
- This application also uses the AOT and java JIT for the code compilation.
- To compile the code of the using AOT it will use the native-image technology or also we can use the native image builder.
- It also uses the dependencies including from JDK. It will statistically analyze the data from classes and methods which was reachable during the execution of an application.
- Features are the same as java agent, it can also feed the information from the graalvm compiler.
Spring Boot GraalVM Native Image
- To develop the application and build the native image we need to add the spring native dependency in our project.
- Below are the steps to create a native image which are as follows.
1) First we need to add the spring native dependency in our project.
2) After adding the dependency plugin next step is to add the spring AOT plugin to our project.
3) After adding the AOT plugin to our project enable the native image support.
4) After enabling the native image support freeze the graalvm version.
5) After freezing the graalvm version add the maven repository.
6) After adding the maven repository build the native application.
7) After building the native application run the native application.
Project Setup
Below examples, are shown to create a graalvm project.
1) Create project template using spring initializer and give a name to project –
In the below step we have provided project group name as com. example, artifact name as springboot-graalvm, project name as
springboot-graalvm, package as jar file.
Group – com.example
Artifact name – springboot-graalvm
Name – springboot-graalvm
Description - Project for springboot-graalvm
Spring boot – 2.5.5
Project – Maven project
Package name - com.example.springboot-graalvm
Packaging – Jar
Java – 11
Dependencies – spring native, spring web, spring reactive web, PostgreSQL driver.
2) After generating project extract files and open this project by using spring tool suite –
3) After opening the project using the spring tool suite check the project and its files –
4) Add dependency packages –
Code:
<dependency> -- Start of dependency tag.
<groupId>org.springframework.experimental</groupId> -- Start and end of groupId tag.
<artifactId>spring-native</artifactId> -- Start and end of artifactId tag.
</dependency> -- End of dependency tag.
<dependency> -- Start of dependency tag.
<groupId>org.springframework.boot</groupId> -- Start and end of groupId tag.
<artifactId>spring-boot-starter-web</artifactId> -- Start and end of artifactId tag.
</dependency> -- End of dependency tag.
5) Create entity class –
Code:
public class prod {
@Id
private Integer prod_id;
private Integer prod_price;
}
6) Create service class –
Code:
@Service
public class pservice
{
@Autowired
private prepo repo;
public Flux<prod> getAllProducts ()
{
return this.repo.findAll ();
}
}
7) Create controller class –
Code:
@RestController
@RequestMapping ("prod")
public class pcontroller {
@Autowired
private pservice pser;
@PostMapping
public prod <prod> createProduct (@RequestBody mono<Product> pmono)
{
return pmono.flatMap (this.pser::createProduct);
}
@PutMapping ("{pid}")
public Mono<Product> updateProduct (@PathVariable int pId,
@RequestBody Mono<Product> pmono){
return this.pservice.updateprod (pid, pmono);
}
}
8) Configure the application.properties file –
Code:
spring.datasource.url = jdbc:postgresql://localhost/spring_boot_graalvm
spring.datasource.username = postgresql
spring.datasource.password = postgresql
spring.datasource.platform = postgresql
9) Run the application and check the time –
10) Build and run the graalvm image
Code:
docker run -p 8080:8080 -e graalvm_host = 10.11.12.13 pservice-native:0.0.1-snapshot
Conclusion
Spring boot graalvm application is providing support for the packaging and spring application as native images. Spring boot graalvm is used to compile the byte code and java into the executable file of native binary which was running without using JVM.
Recommended Articles
This is a guide to Spring Boot GraalVM. Here we discuss the Definition, What is Spring Boot GraalVM? examples with code implementation. You may also have a look at the following articles to learn more –
