Use of Spring Boot Maven Plugin with Example

📘 Premium Read: Access my best content on Medium member-only articles — deep dives into Java, Spring Boot, Microservices, backend architecture, interview preparation, career advice, and industry-standard best practices.

🎓 Top 15 Udemy Courses (80-90% Discount): My Udemy Courses - Ramesh Fadatare — All my Udemy courses are real-time and project oriented courses.

▶️ Subscribe to My YouTube Channel (176K+ subscribers): Java Guides on YouTube

▶️ For AI, ChatGPT, Web, Tech, and Generative AI, subscribe to another channel: Ramesh Fadatare on YouTube

<< Back to Spring Boot Tutorial

In this article, we will discuss what is Spring Boot Maven Plugin and it's usage in spring boot applications.

What is Spring Boot Maven Plugin and it's Features

The Spring Boot Maven Plugin provides Spring Boot support in Apache Maven, letting you package executable jar or war archives and run an application “in-place”. To use it, you must use Maven 3.2 (or later).

The Spring Boot Maven plugin provides many convenient features:

• It collects all the jars on the classpath and builds a single, runnable "über-jar", which makes it more convenient to execute and transport your service.
• It searches for the public static void main() method to flag as a runnable class.
• It provides a built-in dependency resolver that sets the version number to match Spring Boot dependencies. You can override any version you wish, but it will default to Boot’s chosen set of versions.

Add Spring Boot Maven Plugin to pom.xml

Let's add the latest release of Spring Boot Maven Plugin to our pom.xml:

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <!-- ... -->
    <build>
        <plugins>
            <plugin>
                <groupId>org.springframework.boot</groupId>
                <artifactId>spring-boot-maven-plugin</artifactId>
                <version>2.2.0.BUILD-SNAPSHOT</version>
                <executions>
                    <execution>
                        <goals>
                            <goal>repackage</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
</project>

When you create Spring boot project using SPRING INITIALIZR then by default this plugin will be added this your spring boot project. For example, let's generate a simple spring boot project using SPRING INITIALIZR and give project name as 'myproject'.The pom.xml of this generated project:

<?xml version="1.0" encoding="UTF-8"?>
<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>
    <parent>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-parent</artifactId>
        <version>2.1.2.RELEASE</version>
        <relativePath/>
        <!-- lookup parent from repository -->
    </parent>
    <groupId>com.example</groupId>
    <artifactId>demo</artifactId>
    <version>0.0.1-SNAPSHOT</version>
    <name>demo</name>
    <description>Demo project for Spring Boot</description>
    <properties>
        <java.version>1.8</java.version>
    </properties>
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</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>

Now, let's run above pom.xml using the following command will repackage jar as well as the original jar in the target directory:

$ mvn package
$ ls target/*.jar
target/myproject-1.0.0.jar 
target/myproject-1.0.0.jar.original

We can also specify a repackage goal from the command line:

$ mvn package spring-boot:repackage
$ ls target/*.jar

target/myproject-1.0.0.jar 
target/myproject-1.0.0.jar.original

Packaging Executable Jar and War Files

Once spring-boot-maven-plugin has been included in your pom.xml, it automatically tries to rewrite archives to make them executable by using the spring-boot:repackage goal. You should configure your project to build a jar or war (as appropriate) by using the usual packaging element, as shown in the following example:

To generate jar archive

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!-- ... -->
    <packaging>jar</packaging>
    <!-- ... -->
</project>

To generate war archive

To build a war file that is both executable and deployable into an external container, you need to mark the embedded container dependencies as “provided”, as shown in the following example:

<?xml version="1.0" encoding="UTF-8"?>
<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">
    <!-- ... -->
    <packaging>war</packaging>
    <!-- ... -->
    <dependencies>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-tomcat</artifactId>
            <scope>provided</scope>
        </dependency>
        <!-- ... -->
    </dependencies>
</project>

To learn how to create a deployable war file of spring boot project and deploy on external tomcat here at Spring Boot 2 Deploy WAR file to External Tomcat.

More about Spring Boot Maven Plugin

Goals Overview

The Spring Boot Plugin has the following goals.

• spring-boot:run runs your Spring Boot application.
• spring-boot:repackage repackages your jar/war to be executable.
• spring-boot:start and spring-boot:stop to manage the lifecycle of your Spring Boot application (i.e. for integration tests).
• spring-boot:build-info generates build information that can be used by the Actuator.

Usage

The plugin provides several goals to work with a Spring Boot application:

• repackage: create a jar or war file that is auto-executable. It can replace the regular artifact or can be attached to the build lifecycle with a separate classifier.
• run: run your Spring Boot application with several options to pass parameters to it.
• start and stop: integrate your Spring Boot application to the integration-test phase so that the application starts before it.
• build-info: generate build information that can be used by the Actuator.

You can learn more usage of this plugin at https://docs.spring.io/spring-boot/docs/current/maven-plugin/usage.html.

More Examples

To provide you with better understanding of some usages of Spring Boot, you can take a look into the following examples:

• Custom repackage classifier
• Local repackaged artifact
• Exclude a dependency
• Debug the application
• Using system properties
• Using environment variables
• Random port for integration tests
• Skip integration tests
• Specify active profiles
• Generate build information
• Custom layout

References

• https://docs.spring.io/spring-boot/docs/current/maven-plugin/usage.html
• https://docs.spring.io/spring-boot/docs/current/reference/html/build-tool-plugins-maven-plugin.html

<< Back to Spring Boot Tutorial