Passing Command Line Arguments in Gradle

1. Overview

Sometimes, we want to execute various programs from Gradle that require input parameters.

In this quick tutorial, we’re going to see how to pass command-line arguments from Gradle.

2. Types of Input Arguments

When we want to pass input arguments from the Gradle CLI, we have two choices:

setting system properties with the -D flag
setting project properties with the -P flag

In general, we should use project properties unless we want to customize settings in the JVM.

Although it is possible to hijack system properties to pass our inputs, we should avoid doing this.

Let’s see these properties in action. First, we configure our build.gradle:

apply plugin: "java"
description = "Gradle Command Line Arguments examples"
task propertyTypes(){
    doLast{
        if (project.hasProperty("args")) {
            println "Our input argument with project property ["+project.getProperty("args")+"]"
        }
        println "Our input argument with system property ["+System.getProperty("args")+"]"
    }
}

Notice we read them differently in our task.

We do this because project.getProperty() throws a MissingPropertyException in case our property is not defined.

Unlike project properties, System.getProperty() returns a null value in case the property is not defined.

Next, let’s run the task and see its output:

$ ./gradlew propertyTypes -Dargs=lorem -Pargs=ipsum
> Task :cmd-line-args:propertyTypes
Our input argument with project property [ipsum]
Our input argument with system property [lorem]

3. Passing Command Line Arguments

So far, we’ve seen just how to read the properties. In practice, we need to send these properties as arguments to our program of choice.

3.1. Passing Arguments to Java Applications

In a previous tutorial, we explained how to run Java main classes from Gradle. Let’s build upon that and see how we can also pass arguments.

First, let’s use the application plugin in our build.gradle:

apply plugin: "java"
apply plugin: "application"
description = "Gradle Command Line Arguments examples"
 
// previous declarations
 
ext.javaMainClass = "com.baeldung.cmd.MainClass"
 
application {
    mainClassName = javaMainClass
}

Now, let’s take a look at our main class:

public class MainClass {
    public static void main(String[] args) {
        System.out.println("Gradle command line arguments example");
        for (String arg : args) {
            System.out.println("Got argument [" + arg + "]");
        }
    }
}

Next, let’s run it with some arguments:

$ ./gradlew :cmd-line-args:run --args="lorem ipsum dolor"
> Task :cmd-line-args:run
Gradle command line arguments example
Got argument [lorem]
Got argument [ipsum]
Got argument [dolor]

Here, we don’t use properties to pass arguments. Instead, we pass the –args flag and the corresponding inputs there.

This is a nice wrapper provided by the application plugin. However, this is only available from Gradle 4.9 onward.

Let’s see what this would look like using a JavaExec task.

First, we need to define it in our build.gradle:

ext.javaMainClass = "com.baeldung.cmd.MainClass"
if (project.hasProperty("args")) {
    ext.cmdargs = project.getProperty("args")
} else { 
    ext.cmdargs = ""
}
task cmdLineJavaExec(type: JavaExec) {
    group = "Execution"
    description = "Run the main class with JavaExecTask"
    classpath = sourceSets.main.runtimeClasspath
    main = javaMainClass
    args cmdargs.split()
}

Let’s take a closer look at what we did. We first read the arguments from a project property.

Since this contains all the arguments as one string, we then use the split method to obtain an array of arguments.

Next, we pass this array to the args property of our JavaExec task.

Let’s see what happens when we run this task, passing project properties with the -P option:

$ ./gradlew cmdLineJavaExec -Pargs="lorem ipsum dolor"
> Task :cmd-line-args:cmdLineJavaExec
Gradle command line arguments example
Got argument [lorem]
Got argument [ipsum]
Got argument [dolor]

3.2. Passing Arguments to Other Applications

In some cases, we might want to pass some arguments to a third-party application from Gradle.

Luckily, we can use the more generic Exec task to do so:

if (project.hasProperty("args")) {
    ext.cmdargs = project.getProperty("args")
} else { 
    ext.cmdargs = "ls"
}
 
task cmdLineExec(type: Exec) {
    group = "Execution"
    description = "Run an external program with ExecTask"
    commandLine cmdargs.split()
}

Here, we use the commandLine property of the task to pass the executable along with any arguments. Again, we split the input based on spaces.

Let’s see how to run this for the ls command:

$ ./gradlew cmdLineExec -Pargs="ls -ll"
> Task :cmd-line-args:cmdLineExec
total 4
drwxr-xr-x 1 user 1049089    0 Sep  1 17:59 bin
drwxr-xr-x 1 user 1049089    0 Sep  1 18:30 build
-rw-r--r-- 1 user 1049089 1016 Sep  3 15:32 build.gradle
drwxr-xr-x 1 user 1049089    0 Sep  1 17:52 src

This can be pretty useful if we don’t want to hard-code the executable in the task.

4. Conclusion

In this quick tutorial, we saw how to pass input arguments from Gradle.

First, we explained the types of properties we can use. Although we can use system properties to pass input arguments, we should prefer project properties instead.

Then, we explored different approaches for passing command-line arguments to Java or external applications.

As usual, the complete code can be found over on GitHub.

The post Passing Command Line Arguments in Gradle first appeared on Baeldung.

Find A Teacher Form:
https://docs.google.com/forms/d/1vREBnX5n262umf4wU5U2pyTwvk9O-JrAgblA-wH9GFQ/viewform?edit_requested=true#responses

Email:
public1989two@gmail.com

www.itsec.hk
www.itsec.vip
www.itseceu.uk