J'essaie de passer un argument de la ligne de commande à une classe java. J'ai suivi ce post: http://gradle.1045684.n5.nabble.com/Gradle-application-plugin-question-td5539555.html mais le code ne fonctionne pas pour moi (peut-être n'est-il pas destiné à JavaExec?). Voici ce que j'ai essayé:

task listTests(type:JavaExec){
    main = "util.TestGroupScanner"
    classpath = sourceSets.util.runtimeClasspath
    // this works...
    args 'demo'
    /*
    // this does not work!
    if (project.hasProperty("group")){
        args group
    }
    */
}

La sortie de la valeur args codée en dur ci-dessus est:

C:\ws\svn\sqe\sandbox\selenium2forbg\testgradle>g listTests
:compileUtilJava UP-TO-DATE
:processUtilResources UP-TO-DATE
:utilClasses UP-TO-DATE
:listTests
Received argument: demo

BUILD SUCCESSFUL

Total time: 13.422 secs

Cependant, une fois que je change le code pour utiliser la section hasProperty et que je passe "demo" comme argument sur la ligne de commande, j'obtiens une NullPointerException:

C:\ws\svn\sqe\sandbox\selenium2forbg\testgradle>g listTests -Pgroup=demo -s

FAILURE: Build failed with an exception.

* Where:
Build file 'C:\ws\svn\sqe\sandbox\selenium2forbg\testgradle\build.gradle' line:25

* What went wrong:
A problem occurred evaluating root project 'testgradle'.
> java.lang.NullPointerException (no error message)

* Try:
Run with --info or --debug option to get more log output.

* Exception is:
org.gradle.api.GradleScriptException: A problem occurred evaluating root project
 'testgradle'.
    at org.gradle.groovy.scripts.internal.DefaultScriptRunnerFactory$ScriptRunnerImpl.run(DefaultScriptRunnerFactory.java:54)
    at org.gradle.configuration.DefaultScriptPluginFactory$ScriptPluginImpl.apply(DefaultScriptPluginFactory.java:127)
    at org.gradle.configuration.BuildScriptProcessor.evaluate(BuildScriptProcessor.java:38) 

Il existe un projet de test simple disponible sur http://gradle.1045684.n5.nabble.com/file/n5709919/testgradle.zip qui illustre le problème.

Ceci utilise Gradle 1.0-rc-3. Le NullPointer provient de cette ligne de code:

args group 

J'ai ajouté l'affectation suivante avant la définition de la tâche, mais cela n'a pas changé le résultat:

group = hasProperty('group') ? group : 'nosuchgroup' 

Tous les pointeurs sur la façon de passer des arguments de ligne de commande à gradle appréciés.

project.groupest une propriété prédéfinie. Avec -P, vous ne pouvez définir que des propriétés de projet qui ne sont pas prédéfinies. Vous pouvez également définir les propriétés système Java ( -D).

S'appuyant sur la réponse de Peter N, voici un exemple de la façon d'ajouter des arguments (facultatifs) spécifiés par l'utilisateur à transmettre à Java main pour une tâche JavaExec (car vous ne pouvez pas définir la propriété 'args' manuellement pour la raison qu'il cite.)

Ajoutez ceci à la tâche:

task(runProgram, type: JavaExec) {

  [...]

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

... et exécutez sur la ligne de commande comme ceci

% ./gradlew runProgram '-Pmyargs=-x,7,--no-kidding,/Users/rogers/tests/file.txt'

Mon programme avec deux arguments, args [0] et args [1]:

public static void main(String[] args) throws Exception {
    System.out.println(args);
    String host = args[0];
    System.out.println(host);
    int port = Integer.parseInt(args[1]);

mon build.gradle

run {
    if ( project.hasProperty("appArgsWhatEverIWant") ) {
        args Eval.me(appArgsWhatEverIWant)
    }
}

mon invite de terminal:

gradle run  -PappArgsWhatEverIWant="['localhost','8080']"

Depuis Gradle 4.9, le plugin d'application comprend l' --argsoption, donc passer les arguments est aussi simple que:

build.gradle

plugins {
    id 'application'
}

mainClassName = "my.App"

src / main / java / mon / App.java

public class App {
    public static void main(String[] args) {
        System.out.println(args);
    }
}

frapper

./gradlew run --args='This string will be passed into my.App#main arguments'

Il est possible d'utiliser des options de ligne de commande personnalisées dans Gradle pour obtenir quelque chose comme:

./gradlew printPet --pet="puppies!"

Cependant, les options de ligne de commande personnalisées dans Gradle sont une fonctionnalité d'incubation .

Solution Java

Pour finir avec quelque chose comme ça, suivez les instructions ici :

import org.gradle.api.tasks.options.Option;

public class PrintPet extends DefaultTask {
    private String pet;

    @Option(option = "pet", description = "Name of the cute pet you would like to print out!")
    public void setPet(String pet) {
        this.pet = pet;
    }

    @Input
    public String getPet() {
        return pet;
    }

    @TaskAction
    public void print() {
        getLogger().quiet("'{}' are awesome!", pet);
    }
}

Puis enregistrez-le:

task printPet(type: PrintPet)

Maintenant vous pouvez faire:

./gradlew printPet --pet="puppies"

production:

Chiots! sont géniaux!

Solution Kotlin

open class PrintPet : DefaultTask() {

    @Suppress("UnstableApiUsage")
    @set:Option(option = "pet", description = "The cute pet you would like to print out")
    @get:Input
    var pet: String = ""

    @TaskAction
    fun print() {    
        println("$pet are awesome!")
    }
}

puis enregistrez la tâche avec:

tasks.register<PrintPet>("printPet")

Si vous avez besoin de vérifier et de définir un argument , votre build.gradlefichier ressemblera à ceci:

....

def coverageThreshold = 0.15

if (project.hasProperty('threshold')) {
    coverageThreshold = project.property('threshold').toString().toBigDecimal()
}

//print the value of variable
println("Coverage Threshold: $coverageThreshold")
...

Et la commande Sample dans Windows:

test de nettoyage gradlew -Pthreshold = 0,25

J'ai écrit un morceau de code qui place les arguments de la ligne de commande dans le format attendu par gradle.

// this method creates a command line arguments
def setCommandLineArguments(commandLineArgs) {
    // remove spaces 
    def arguments = commandLineArgs.tokenize()

            // create a string that can be used by Eval 
            def cla = "["
            // go through the list to get each argument
            arguments.each {
                    cla += "'" + "${it}" + "',"
            }

    // remove last "," add "]" and set the args 
    return cla.substring(0, cla.lastIndexOf(',')) + "]"
}

ma tâche ressemble à ceci:

task runProgram(type: JavaExec) {
    if ( project.hasProperty("commandLineArgs") ) {
            args Eval.me( setCommandLineArguments(commandLineArgs) )
    }
}

Pour transmettre les arguments à partir de la ligne de commande, exécutez ceci:

gradle runProgram -PcommandLineArgs="arg1 arg2 arg3 arg4"    

Il y a un bon exemple ici:

https://kb.novaordis.com/index.php/Gradle_Pass_Configuration_on_Command_Line

Quels détails vous pouvez passer des paramètres et ensuite fournir une valeur par défaut dans une variable ext comme ceci:

gradle -Dmy_app.color=blue

puis référence dans Gradle comme:

ext {
   color = System.getProperty("my_app.color", "red");
}

Et puis n'importe où dans votre script de construction, vous pouvez le référencer comme cours partout où vous pouvez le référencer comme project.ext.color

Plus de conseils ici: https://kb.novaordis.com/index.php/Gradle_Variables_and_Properties

passez une URL à partir de la ligne de commande, conservez votre URL dans le fichier de graduation de l'application comme suit resValue "string", "url", CommonUrl

et donnez un paramètre dans les fichiers gradle.properties comme suit CommonUrl = "mettez votre URL ici ou peut être vide"

et passez une commande à partir de la ligne de commande comme suit gradle assembleRelease -Pcommanurl = mettez votre URL ici