Command-Line Arguments in Spring Boot

Last updated: February 4, 2026

Written by: baeldung

Reviewed by: Predrag Marić

Spring Boot

Refactor Java code safely — and automatically — with OpenRewrite.

Refactoring big codebases by hand is slow, risky, and easy to put off. That’s where OpenRewrite comes in. The open-source framework for large-scale, automated code transformations helps teams modernize safely and consistently.

Each month, the creators and maintainers of OpenRewrite at Moderne run live, hands-on training sessions — one for newcomers and one for experienced users. You’ll see how recipes work, how to apply them across projects, and how to modernize code with confidence.

Join the next session, bring your questions, and learn how to automate the kind of work that usually eats your sprint time.

Distributed systems often come with complex challenges such as service-to-service communication, state management, asynchronous messaging, security, and more.

Dapr (Distributed Application Runtime) provides a set of APIs and building blocks to address these challenges, abstracting away infrastructure so we can focus on business logic.

In this tutorial, we'll focus on Dapr's pub/sub API for message brokering. Using its Spring Boot integration, we'll simplify the creation of a loosely coupled, portable, and easily testable pub/sub messaging system:

>> Flexible Pub/Sub Messaging With Spring Boot and Dapr

1. Overview

In this quick tutorial, we’ll learn how to pass command-line arguments to a Spring Boot application.

We can use command-line arguments to configure our application, override application properties, and pass custom arguments.

2. Maven Command-Line Arguments

First, let’s see how we can pass arguments while running our application using Maven Plugin.

Then we’ll learn how to access the arguments in our code.

2.1. Spring Boot 1.x

For Spring Boot 1.x, we can pass the arguments to our application using -Drun.arguments:

mvn spring-boot:run -Drun.arguments=--customArgument=custom

We can also pass multiple parameters to our app:

mvn spring-boot:run -Drun.arguments=--spring.main.banner-mode=off,--customArgument=custom

Note that:

Arguments should be comma separated.
Each argument should be prefixed with —
We can also pass configuration properties, like spring.main.banner-mode, as shown in the example above.

2.2. Spring Boot 2.x

For Spring Boot 2.x, we can pass the arguments using -Dspring-boot.run.arguments:

mvn spring-boot:run -Dspring-boot.run.arguments=--spring.main.banner-mode=off,--customArgument=custom

3. Gradle Command-Line Arguments

Next, let’s discover how to pass arguments while running our application using Gradle Plugin.

We’ll need to configure our bootRun task in the build.gradle file:

bootRun {
    if (project.hasProperty('args')) {
        args project.args.split(',')
    }
}

Now we can pass the command-line arguments:

./gradlew bootRun --args=--spring.main.banner-mode=off,--customArgument=custom

4. Overriding System Properties

Along with passing custom arguments, we can also override system properties.

For example, here’s our application.properties file:

server.port=8081
spring.application.name=SampleApp

To override the server.port value, we need to pass the new value in the following manner (for Spring Boot 1.x):

mvn spring-boot:run -Drun.arguments=--server.port=8085

Similarly, for Spring Boot 2.x:

mvn spring-boot:run -Dspring-boot.run.arguments=--server.port=8085

Note that:

Spring Boot converts command-line arguments to properties, and adds them as environment variables.
We can use short command-line arguments, –port=8085 instead of –server.port=8085, by using a placeholder in our application.properties:
```
server.port=${port:8080}
```
Command-line arguments take precedence over application.properties values.

If necessary, we can stop our application from converting command-line arguments to properties:

@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    public static void main(String[] args) {
        SpringApplication application = new SpringApplication(Application.class);
        application.setAddCommandLineProperties(false);
        application.run(args);
    }
}

5. Accessing Command-Line Arguments

Let’s see how we can access the command-line arguments from our application’s main() method:

@SpringBootApplication
public class Application extends SpringBootServletInitializer {
    public static void main(String[] args) {
        for(String arg:args) {
            System.out.println(arg);
        }
        SpringApplication.run(Application.class, args);
    }
}

This will print the arguments we passed to our application from the command-line, but we can also use them later in our application.

6. Passing Command-Line Arguments to the SpringBootTest

With the release of Spring Boot 2.2, we gained the ability to inject command-line arguments during testing using @SpringBootTest and its args attribute:

@SpringBootTest(args = "--spring.main.banner-mode=off")
public class ApplicationTest {

    @Test
    public void whenUsingSpringBootTestArgs_thenCommandLineArgSet(@Autowired Environment env) {
        Assertions.assertThat(env.getProperty("spring.main.banner-mode")).isEqualTo("off");
    }
}