gradle编译工具，参数传递

gradle props

Gradle supports both project properties and system properties/enviroment properties).

The main difference between the two that is of interest in this post is how each is accessed.

Project properties are more conducive to direct access by name while system properties are accessed via normal Java/Groovy system properties
access methods.

Passing Project Properties from Command-Line with -P

One of the easiest approaches for passing properties to a Gradle build is to specify project properties with -Pfrom the command line.
Properties passed into the build with -P are readily accessible in the build as project properties and, if their naming structure allows, can be accessed directly like variables.

Passing System Properties from Command-Line with -D

As is the case with other Java applications, one can pass system properties to Gradle builds with -D.

Although these system properties provided to the Gradle build via the -D option are always available to the Gradle build via the normal Java mechanism for obtaining system properties,System.getProperty("xxxx")

Gradle makes it possible to specify Project Properties as system properties. This is done by placing the prefix org.gradle.project. before the name of the property desired in the build.

For example, if one wanted to specify a system property namedname.first with -D that would be available to the Gradle build as if it was provided with -P,
the person could provide it to the Gradle build on the command line as org.gradle.project.name.first
and the Gradle build would see it as a project property named name.first.

Passing System Properties via Environmental Variable

Any Java or Groovy application (including a Gradle build) can access environmental variables via System.getenv(String).

However, Gradle allows environment variables to be accessed within the build like other project properties if the environmental variable is prefixed with ORG_GRADLE_PROJECT_.

For example, if one wanted a project property in the Gradle build to be called name.last and wanted to supply it to the build via environment variable, that person could declare the environment variableORG_GRADLE_PROJECT_name.last and its value would be available to the Gradle build as a project property with name name.last.

gradle.properties

Properties can also be provided to a Gradle build via a properties file named gradle.properties. Any properties specified with systemProp. at the beginning of their property name are seen as system properties in the Gradle build and other properties (without their names beginning with "systemProp.") are seen as Gradle project properties. For example, if my gradle.properties file had a property name.last=Marx and a propertysystemPropr.name.first=Dustin, the name.last property would be seen and accessed in the Gradle build like any project property while the name.first property would be seen and accessed in the Gradle build like any system property.

The screen snapshot indicates how properties are seen/accessed in the Gradle build depending on their source and naming convention. In short, the output demonstrates the following "rules" of property availability in a Gradle build:

demo buid.gralde

apply plugin: 'groovy'

repositories {
    mavenCentral()
}

dependencies {
    compile 'org.codehaus.groovy:groovy-all:2.3.11'
    testCompile group: 'junit', name: 'junit', version: '4.12'
}


task mkdir {
    doLast {
        mkdir("src/main/groovy")
        mkdir("src/main/resources")
        mkdir("src/test/groovy")
        mkdir("src/test/resources")
    }
}


task displayProperties {
    doLast {
        printSystemProps()
        printProjectProps()
    }
}

def printSystemProps() {
    println "\n=== System Properties ==="
//    println "systemProp_environmental_variable: ${System.properties['systemPropA']}"   //need to change to below line,env variable
    //in linux:             export systemProp_environmentalVariable='systemProp from environmentalVariable'
    println "systemProp_environmentalVariable: ${System.getenv('systemProp_environmentalVariable')}"
    //in gradle.properties file , make sure the prop starts with systemProp.,that is
    //systemProp.systemProp_propertyFile=systemProp from propertyFile
    println "systemProp_propertyFile: ${System.properties['systemProp_propertyFile']}"

    //gradle :gradlePropertiesStudy:displayProperties -DsystemProp_dashD='systemProp from -D'
    println "systemProp_dashD: ${System.properties['systemProp_dashD']}"
}

def printProjectProps() {
    println "\n=== Gradle Project Properties ==="

    //in linux:             export ORG_GRADLE_PROJECT_projectProp_environmentalVariable='projectProp from environmentalVariable'
    println "projectProp_environmentalVariable: ${getProjectProp('projectProp_environmentalVariable')}"
    println "projectProp_propertyFile: ${getProjectProp('projectProp_propertyFile')}"
    //gradle :gradlePropertiesStudy:displayProperties -PprojectProp_dashP='projectProp from -P'
    println "projectProp_dashP: ${getProjectProp('projectProp_dashP')}"

    //gradle :gradlePropertiesStudy:displayProperties -Dorg.gradle.project.projectProp_dashD='projectProp from -D'
    //make sure it starts with org.gradle.project.
    println "projectProp_dashD: ${getProjectProp('projectProp_dashD')}"

}

def String getProjectProp(String propertyName) {
    if (hasProperty(propertyName)) {
        return this.properties[propertyName]
    }
    return "N/A"
}

demo gradle.properties

projectProp_propertyFile=projectProp from propertyFile
systemProp.systemProp_propertyFile=systemProp from propertyFile

demo cli command

hunter@hunter-ubu:~/workspaces/groovy$ gradle -q :gradlePropertiesStudy:displayProperties -PprojectProp_dashP='projectProp from -P' -DsystemProp_dashD='systemProp from -D' -Dorg.gradle.project.projectProp_dashD='projectProp from -D'

=== System Properties ===
systemProp_environmentalVariable: systemProp from environmentalVariable
systemProp_propertyFile: systemProp from propertyFile
systemProp_dashD: systemProp from -D

=== Gradle Project Properties ===
projectProp_environmentalVariable: projectProp from environmentalVariable
projectProp_propertyFile: projectProp from propertyFile
projectProp_dashP: projectProp from -P
projectProp_dashD: projectProp from -D

主要还是参考下我提供的这个例子，里面列举了所有传递参数的方式。

总结

Command-line -P properties are "project properties"
Command-line -D properties are, with one exception, "system properties",use System.getProperty("xxxx")
Command-line -D properties that begin with org.gradle.project. are "project properties"
Properties specified in gradle.properties are, with one exception, "project properties"
Properties specified in gradle.properties that begin with systemProp. are "system properties",use System.getProperty("xxxx")
Properties specified via environment variable are, with one exception, "enviroment properties",use system.getenv("xxxx")
Properties specified via environment variables that begin with ORG_GRADLE_PROJECT_ are "project properties"