Spring Boot – how to build jar?

Introduction – Building a JAR with Spring Boot

Building a Java Archive (JAR) file is a common task in Java development, but when dealing with Spring Boot applications, there are specific steps that simplify packaging and deploying your application. In essence, a JAR file encapsulates your application and its dependencies into a single executable file. This is particularly useful for distributing and running your application across different environments without complex setups. Spring Boot provides tools and plugins to streamline this process, minimizing the overhead associated with traditional Java packaging methods.

Solution: Building a JAR with Spring Boot

Using Maven to Build a Spring Boot Executable JAR

The Spring Boot ecosystem provides the spring-boot-maven-plugin which significantly simplifies the creation of an executable JAR.

1. Setting Up the Maven Project: Ensure your project is structured properly with a pom.xml configured for Spring Boot.

   <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
            xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
       <modelVersion>4.0.0</modelVersion>
       <groupId>com.example</groupId>
       <artifactId>demo</artifactId>
       <version>0.0.1-SNAPSHOT</version>
       <parent>
           <groupId>org.springframework.boot</groupId>
           <artifactId>spring-boot-starter-parent</artifactId>
           <version>2.7.0</version>
       </parent>
       <dependencies>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter</artifactId>
           </dependency>
           <dependency>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-starter-test</artifactId>
               <scope>test</scope>
           </dependency>
       </dependencies>
       <build>
           <plugins>
               <plugin>
                   <groupId>org.springframework.boot</groupId>
                   <artifactId>spring-boot-maven-plugin</artifactId>
               </plugin>
           </plugins>
       </build>
   </project>
   

2. Application Setup: Create a simple Spring Boot application with a main class annotated with @SpringBootApplication.

   import org.springframework.boot.SpringApplication;
   import org.springframework.boot.autoconfigure.SpringBootApplication;
   
   @SpringBootApplication
   public class DemoApplication {
       public static void main(String[] args) {
           SpringApplication.run(DemoApplication.class, args);
       }
   }
   

3. Building the JAR: Use the Maven command mvn clean package to build the application into an executable JAR file.

```bash
mvn clean package
```

This command creates an executable JAR (e.g., `target/demo-0.0.1-SNAPSHOT.jar`) which can be run using:

```bash
java -jar target/demo-0.0.1-SNAPSHOT.jar
```

The plugin automatically sets the Main-Class attribute to a Spring Boot launcher and identifies the class that contains the main method (DemoApplication).

4. Customizing the Build:
   Optionally, you can add more configurations to handle specific use-cases, such as including/excluding files, setting additional properties, or adding classifiers for different types of JAR outputs.

   <properties>
       <spring-boot.classifier>exec</spring-boot.classifier>
   </properties>
   <build>
       <plugins>
           <plugin>
               <groupId>org.springframework.boot</groupId>
               <artifactId>spring-boot-maven-plugin</artifactId>
               <configuration>
                   <classifier>${spring-boot.classifier}</classifier>
               </configuration>
               <executions>
                   <execution>
                       <id>repackage</id>
                       <goals>
                           <goal>repackage</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
   

5. Running the JAR:
   The JAR can be executed simply by running:

   java -jar target/demo-0.0.1-SNAPSHOT-exec.jar
   

By using the Spring Boot Maven plugin, the process of building and running Spring Boot applications is greatly simplified compared to traditional methods.

Summary

Building an executable JAR in Spring Boot involves setting up a Maven project, configuring the spring-boot-maven-plugin, and using simple commands to package and run the application. This streamlined approach enables rapid development and deployment of Java applications, encapsulating all dependencies within a single, executable file.